Summer of Code 2012

= Introduction = XMPP is the Extensible Messaging and Presence Protocol, an XML wire protocol for real-time communication that emerged from the Jabber open-source community. Our community is not a single open-source project because it is not focused on a single codebase. Instead, our community is centered around open standards and open protocols. However, even though there are closed-source implementations of XMPP, we still have a strong commitment to open code and there are many free and open-source projects in our community participating in GSoC under the XSF's umbrella.

We have participated in the Summer of Code since its inception and have learned many lessons, among them:
 * We try to choose few excellent projects and really focus on them.
 * It is difficult to choose excellent projects, so the more helpful information you can provide, the better.
 * We also try to choose excellent mentors and match students with mentors.
 * We expect regular reporting (via blog) and weekly or near-weekly meetings.
 * We take the Summer of Code very seriously and we expect our students to treat it like a full-time job.

This page lists some potential project ideas that students can work on. This is similar to a "Request for Proposal" process for your summer job. The mentors and other project members have defined these RFPs as a way to help structure the summer work. Many of these projects are are relevant to our overall community. A select team of longtime XMPP developers and former mentors will review all the student proposals and "interview" many of the students so that we can make the best possible choices.

If you have any questions about the XSF's involvement with the Google Summer of Code, please contact Mike Taylor via email or (preferably) IM.

Thanks for your interest, and good luck!

=Before Applying= Read this page, understand the available projects and find one you'd like to do. With the idea below there'll be contact details for possible mentors - contact them, get to know them a bit and let them help you in your application. Several of our projects have associated 'teaser tasks' designed to get you set up with a build environment (where appropriate) and running and testing the application, then writing a small change and getting it reviewed - this gets you used to the way the summer would go for you (and the mentors used to you), and is a great way to get to know if you and the project are a good fit for each other.

=How to Apply= Application instructions are available at the main GSoC site on the XSF's page.

There is an application form available at that page, and you should complete all the parts. Here's some of what you need to include:
 * Some details about you (what code languages you like, what programming courses you've taken, etc.)
 * Results of your preliminary research into the protocols and codebases you might work on
 * Your ideas about how to approach the project, including an outline of what work you think is required, a rough timeline of the work, etc.
 * Possible problems you think you may face

In general, we consider your GSoC project to be a summer job, so try to provide detailed information that will enable us to decide if you deserve to earn the money Google will be paying. Our project ideas are like "RFPs" -- your application is your proposal to get the job. Please treat it seriously. Thanks!

=Project Ideas= There are many possible software applications available to work on under the XSF's umbrella for GSoC - here are some ideas for different projects.

Swift
Swift's goal is to provide an IM client that does things 'right' with a good user interface, solid quality, and standards-compliance. This year there are again several opportunities for working on new functionality in Swift. This page lists some of the high priority tasks the Swift development team has. If you're interested in any of these (or other) Swift ideas, please jump into the [xmpp:swift@rooms.swift.im?join swift@rooms.swift.im] room and chat it over with Remko and Kev. Swift is a C++ project, so C++ proficiency is required, with either knowledge of or willingness to learn about unit testing (and ideally test-driven development).

We also have a brief introduction to the project and some ideas for tasks to test the water available at http://swift.im/gsoc.html.

Conversation History

 * Summary: Implement all aspects of keeping conversation history, both local and remote.
 * Difficulty: Easy-Medium
 * Details: Swift doesn't currently store any transcripts. A student would likely start by producing a prototype user interface for accessing chat history, then write the library code to access a remote archive, and plug these together and finally work on a local archive. This is likely to be a very satisfying project, with enough challenge to be interesting, but not so much that it's frustrating - plus it should be satisfying as it's one of Swift's most popular feature requests.
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with Qt GUIs and create feature-full UIs
 * Git version control
 * Understanding of XMPP server-side history technology

VoIP Support

 * Summary: Implement support for voice (and optionally video) communication.
 * Difficulty: Hard. This project requires XMPP and VoIP protocol work.
 * Details
 * Implement signaling using the Jingle XMPP protocol, extending the File Transfer support from last year.
 * Implement firewall traversal (using standard traversal protocols: ICE, TURN, ...)
 * Implement real-time-protocol (using standard RTP)
 * Investigate frameworks for hardware interaction & media encoding/decoding.
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with and create simple Qt GUIs
 * Git version control
 * Platform audio hardware interaction
 * Media streaming
 * Understanding of XMPP 'Jingle' technologies

Constrained Swift

 * Summary: Implement support for XMPP protocols that are targeted towards (resource-)constrained environments
 * Difficulty: Medium
 * Details: XMPP provides protocols for dealing with 'constrained' environments: session resumption and incremental roster retrieval for bandwidth-constrained situations, BOSH for places where keeping a long-lived connection is hard, SIFT for limiting the amount of incoming traffic, Link-local for serverless locations, ... Support for these protocols is not only interesting when XMPP software is used in these particular situations, it also makes the client faster and more reliable in general. In this project, you will study the protocols that can improve Swift in these situations (Session Management, BOSH, SIFT, Link-local, ...), and extend Swift (and the underlying Swiften XMPP library) to support these use cases.
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with Qt GUIs
 * Git version control
 * An understanding of a range of XMPP technologies.

Multi-account Support

 * Summary: Implement support for multiple accounts
 * Difficulty: Medium
 * Details: Swift currently only supports one account at a time. Supporting multiple accounts is one of the most requested features for Swift. Although this is technically not hard to implement, it involves quite some design decisions on providing a clear and easy-to-understand user interface. This project is about designing a good user interface for multiple account support.
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with Qt GUIs, creating potentially complex UIs
 * Git version control

Multi-resource support

 * Summary: Implement and standardize techniques & protocols for supporting being connected with multiple clients simultaneously.
 * Difficulty: Medium
 * Details: Although XMPP has supported multiple simultaneously connected clients from the start, the user experience is in practice seldom what a user would expect. This has not been a big problem up until recently, since most people tend to connect with only one client at the same time. These days, however, people are constantly going back and forth between their always-on mobile IM client and their desktop. Enabling a good user experience for this requires new protocols and techniques for transferring conversations between devices, ... This project is about implementing these protocols to streamline the use case of multiple resources
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with Qt GUIs
 * Git version control
 * An understanding of a range of XMPP technologies.

User activity/profile

 * Summary: Implement social aspects in user profiles
 * Difficulty: Easy
 * Details: XMPP (Through the PEP offerings) supports many social-ish data structures, including a user's location, their mood and their current activity. A student working on this project would add support for these protocols to Swiften, and build a 'user profile' UI around these data to give a view on a contact's state that goes beyond the usual 'Name, address, telephone number' profile. A nice touch would be adding map overlays to the location data, so you could see where all your friends were on a map together, and the suchlike.
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with non-trivial Qt GUIs
 * Git version control
 * An understanding of the "PEP" range of XMPP technologies.

Screen sharing

 * Summary: Make it possible to share your screen with contacts.
 * Difficulty: Medium
 * Details: Create a Jingle profile protocol for negotiating screen sharing. Investigate alternatives for implementing the screen sharing part on various operating systems. Implement the protocol and screen sharing, using Swiften's already present Jingle code for negotiation, and reliable transports.
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with Qt GUIs
 * Git version control
 * An understanding of the Jingle range of XMPP technologies.
 * An understanding of screen sharing technology, such as VNC.

Whiteboarding

 * Summary: Implement shared whiteboard drawing
 * Difficulty: Medium
 * Details: The aim of this project is to initially create an excellent UI for whiteboard sharing, with the simplest possible XMPP implementation (not necessarily standards-based). After this first section of the project is complete, the aim is to investigate the current standard in XMPP (which has gained little implementation traction) and other more recent approaches from elsewhere and to either implement the existing standard or (in consultation with your mentor and the community) prototype a better protocol implementation.
 * Skills (to have)
 * Ability to code in C++
 * Skills (to have or to learn)
 * Ability to work with complex Qt GUIs
 * Git version control

Spectrum
Spectrum is an XMPP transport/gateway. It allows XMPP users to communicate with their friends who are using one of the supported networks. If you're interested in any of these ideas or even has some own idea, you can contact us in [xmpp:spectrum@conference.spectrum.im?join spectrum@conference.spectrum.im] room and chat with HanzZ. Core of Spectrum 2 is C++ project, but the ideas here can be written in any language. However, C++ knowledge would be useful, since student could need to change the Spectrum 2 core as part of the project.

Web Interface

 * Summary: Implement the web interface for managing Spectrum 2 instances
 * Difficulty: Easy/Medium
 * Details: Admins are usually running more Spectrum 2 instances and there is a need for easy interface to manage them and gather the statistics. A student would create web-interface in any language (but Python/Ruby/PHP is preferred) allowing the admin to manage Spectrum 2 instances. The web-interface would communicate with Spectrum 2 instance using the XMPP by sending/receiving messages (Spectrum 2 part of this communication is already implemented and is not part of this project). C++ knowledge is not strictly needed for this project, but would be useful. This is often requested feature and there is a place for student's creativity.
 * More info: http://spectrum.im/projects/spectrum/wiki/Summer_of_Code_2012#Web-interface

Ad-Hoc commands

 * Summary: Add Ad-Hoc commands (XEP-0050) support
 * Difficulty: Medium/Hard
 * Details: The goal of this project is to design an interface for creating Ad-Hoc commands either by Spectrum 2 and also by its backends and create simple Ad-Hoc commands for Spectrum 2 instance maintenance (like "Send message to online users" and so on). A student would use Swiften XMPP library (already used in Spectrum 2) to add Ad-Hoc commands support. Then the student has to map Ad-Hoc commands and data forms into the Google Protobuf to let backends to use it.
 * More info: http://spectrum.im/projects/spectrum/wiki/Summer_of_Code_2012#Ad-Hoc-commands

Twitter backend

 * Summary: Implement better Twitter backend
 * Difficulty: Medium
 * Details: Spectrum 2 supports Twitter network using the Pidgin's microblog-purple plugin. This plugin is not designed to be easily used in the way Spectrum 2 uses it. The goal of this project is to implement standalone Twitter backend. Backend is a console application which connects the main Spectrum 2 instance and then handles XMPP user's requests and map them to the Twitter network. Backend can be written in any language with Google Protobuf support, but C++ or Python is preferred.
 * More info: http://spectrum.im/projects/spectrum/wiki/Summer_of_Code_2012#Twitter-backend

Prosody
Prosody is a lightweight XMPP server written in Lua. It aims to be easy to set up and configure, and light on resources. For developers it aims to be easy to extend and give a flexible system on which to rapidly develop added functionality, or prototype new protocols.

Spam/abuse prevention

 * Summary: Develop spam and abuse reporting modules/tools for Prosody.
 * Difficulty: Medium
 * Details: Although spam and abuse isn't prevalent on XMPP as it is on most other networks, it's on the rise. Implement a range of features to help stop this trend, and help service administrators keep on top of abuse on the network.
 * More info: http://prosody.im/gsoc#spamabuse_prevention

Web Interface

 * Summary: Develop a real-time XMPP web interface for server administration.
 * Difficulty: Medium
 * Details: An XMPP-based web interface to monitor and control Prosody instances (and at some level, other servers). We have an initial version as mod_admin_web, but it has some way to go to become nice and usable.
 * More info: http://prosody.im/gsoc#web_interface

Websocket support

 * Summary: Add support for XMPP over websockets to Prosody
 * Difficulty: Hard
 * Details: Now that the |websockets specification has settled down somewhat, update Prosody's mod_websocket to support it.
 * More info: http://prosody.im/gsoc#websocket_support

XMPP network monitoring

 * Summary: Implement modules for Prosody that help map public services on the network.
 * Difficulty: Medium
 * Details: XMPP is a decentralized public federation of servers, but sometimes a centralized directory of what public services are available is desired. Some work has been done recently on specifying a way opt into inclusion in such directories. This project would have multiple parts:


 * Finish implementation of ||XEP-0309: Service Directories in Prosody to allow servers to opt-in to directories of XMPP services.
 * Develop a Prosody module to publish the service directory to the web.
 * Implement realtime monitoring of the services in the directory.


 * More info: http://prosody.im/gsoc#xmpp_network_monitoring

buddycloud
buddycloud is an open social network designed to be simple to use and built on XMPP. If you're interested in any of these ideas or even has some own ideas, you can contact us in seehaus@channels.buddycloud.com room or see the [https://buddycloud.org/wiki/GSOC_2012 buddycloud GSOC] page for how to apply. also has 'next steps' and 'teaser task' information for these proposals.

private messaging

 * Summary reinvent how we send instant messages
 * Difficulty Difficult
 * Details Instant messaging is broken: you join a conversation with no context or history. Sometimes you wonder if your message really reached the recipient. Some clients tell the other person when you are typing and perhaps you don't want that. Good instant messaging is an essential part of XMPP. This project will add messaging support into buddycloud and make it into something that works so well that user can depend on it. Users of your code and design should fall in love with how smoothly and wonderfully instant messaging can work. You will be hacking on reliability, functionality and usability. You will be looking at other systems, looking at existing protocols for message storage and be inventing a significantly better way to communicate in private.
 * More info
 * http://carsonified.com/wp-content/uploads/2010/04/maslow-hierarchy-interface-design.png
 * http://doomsong.co.uk/extensions/render/message-archive-management.html
 * http://xmpp.org/extensions/xep-0136.html

The "it 'effing works as expected" Project
Tests would fire off the necessary commands to "create user a", "create user b", "a follows b's channel" "b apporves a's follow request" etc. Your project will define the base standard of support that guarantees a buddycloud compatible server works as expected. Your tests will help sysadmins choose standards compliant servers and help users know when their server is not supporting all features (and encourage non-standard implmentations to fix their implementations). This project could / should also be avaliable to test other XMPP services too.
 * Summary buddycloud users deserve a great (and predictable) experience
 * Difficulty Medium - Difficult
 * Details At buddycloud HQ we're trying to make more than a "Yeah I think it supports that..." service. When a sysadmin deploys a buddycloud server they should know that it absolutely works as expeced and has passed your rigerous test suite. To run these tests your project will be to devise a suite of tests that eventually produces a table like http://mobilehtml5.org/


 * More info
 * http://www.tigase.org/project/testsuite
 * http://seleniumhq.org/projects/

buddycloud places

 * Summary Enable users to share where they were, where they are now, and where they want to go next with their trusted friends in buddycloud. This project will build a social location server that keeps user data private and also let's users query for nearby channels.
 * Difficulty Difficult
 * Details Designed to serve HTML5 and mobile clients, your social location server will enable a user to bookmark locations that are then stored as either just a name or with incrementally more information such as address, associated wifi and cellID data and perhaps even a lat/long. When a user moves around the world with their buddycloud-enabled phone or webclient, your server will update their location and place them at previously set location bookmarks.
 * Receive XEP-0255 formatted beacon stanzas from the buddycloud webclient and mobile clients. This could arrive in the form of wifi-MACs, Cell-IDs, or GPS coordinates.
 * match the user with previously bookmarked places like "home", "work" or "Cafe on Main Street"
 * Scale to millions of queries/minute.
 * Provide reverse geo-locate lat-long
 * Cache frequent queries
 * Enable the user to manage their place bookmarks
 * Pattern match on beacon data and place users back at bookmarked places
 * The code should be opensouce and deployable as an XMPP component onto any XMPP domain.


 * Skills GIS functions, database scaling techniques, XMPP component design


 * See Also
 * https://github.com/buddycloud/location-butler
 * https://buddycloud.org/wiki/Place_Management
 * http://m.buddycloud.com/tmp/proofs/20100129-buddycloud-architecture.png
 * http://m.buddycloud.com/tmp/proofs/Android%20place%20handling.png

Android or iOS buddycloud client (messaging + pub-sub support)
To be successful, this project will deliver and XMPP client that is easy to use, and standards compliant. The client should handle roster synchronisation and use XEP-0198 to ensure reliable message delivery on an unreliable mobile network. The client should provide the following social features: The client will need to be well integrated with the Android or iOS core features to ensure long battery life while running in the background.
 * Summary Build an open-source XMPP client for Android or iOS
 * Difficulty Given the time constrainsts, extremely
 * Details
 * location updating and sharing with XEP-0080 and XEP-0255
 * do channel posting and updating using pub-sub
 * handle mood and location setting
 * pay particular attention to ease of use and good UI design principles


 * Skills
 * Good XMPP knowledge
 * XMPPFramework or Asmack-lib experience


 * See Also
 * https://github.com/buddycloud/iphone-client
 * https://github.com/buddycloud/android-client

buddycloud media server
An important part of this project will be getting seamless sharing working by successfully bridging the XMPP and HTTP protocol worlds. The buddycloud media server should enable drag and drop sharing over authenticated XMPP and HTTP connections. The server should also allow viewing of content from open channels to non-authenticated viewers on the web.
 * Summary Work with the core buddycloud team to spec and build a reference implementation of the buddycloud media server
 * Difficulty Difficult
 * Details Sharing videos, pictures and documents powers so much of what we do on the internet and strengthens relationships with loved ones. We all loving seeing photos of loved ones, funny videos or albums of friend's events. Your help on this project will make a huge impact: a well designed media server has the power to change the way we share media and work documents. This project is special - it will be working very closely with the buddycloud core team and other XMPP exports to rethink how  we share media: both in buddycloud channels and when we send instant messages. This project is much more than building another Twitpic clone.
 * Skills
 * very strong XMPP knowledge
 * excellent web frontend design skills
 * web-sockets and XMPP server knowledge
 * great skills in working with an existing team and communicating


 * See Also
 * http://salon.io/
 * https://buddycloud.org/wiki/Buddycloud_media_server

ncurses buddycloud
see: http://wiki.xmpp.org/web/Summer_of_Code_2012#Buddycloud-like_microblogging

Poezio
Poezio is a young ncurses XMPP client focused on usability and efficiency. It was formerly designed to focus on multi-user chat, but has since then extended its features to private conversations and roster management, among other things. This page lists some of the most interesting ideas for new features in future versions of poezio. Poezio is mostly a Python projet, so Python proficiency is required. Poezio uses the Sleekxmpp library, which is also in python, and most of the tasks below will require to create plugins for XEPs. The student should also have used ncurses applications before and understood the limitations and possibilites in order to create new user interfaces. You are welcome to join [xmpp:poezio@muc.poezio.eu?join poezio@muc.poezio.eu] to discuss those ideas or submit some new ones.

Pubsub browser
Pubsub has a long specification, and understanding how it works will be the first task of the student. A Pubsub browser was intended a long time ago and the file remains within the sources, the student may or may not re-use the file or start from scratch. The Pubsub browser interface must be simple and straightforward, but it does not have to be intuitive.
 * Summary: Create a new interface allowing to browse, create and delete PubSub nodes
 * Difficulty: Easy
 * Details':
 * XEPs used: 0060

PEP User additions
The «?set?» part of all those additions will an easy task, but displaying the data of people in the roster might need some thinking in order to not overload the interface.
 * Summary: Implement user location, user mood, user activity, user tune, and user nickname
 * Difficulty: Easy
 * Details:
 * XEPs used: 0080, 0107, 0108, 0118, 0163, 0172

PEP microblogging
The XEP-0277 defines a simple microblogging extension to the Personal Eventing Protocol. The implementation must have at least the following features:
 * Summary: Implement PEP microblogging as defined in XEP-0277
 * Difficulty: Easy-Medium
 * Details:
 * Publish
 * Receive
 * Reply
 * Repeat
 * Comment

And again, an UI has to be designed.
 * XEPs used: 0163, 0277

Buddycloud-like microblogging
The buddycloud protocol, while not a proper XEP yet, seems to show more promise than the PEP microblogging, and being able to browse people’s channel, our own, moderate it, etc, will have to be written in a SleekXMPP plugin. The student should try to follow the Client design guidelines as much as he can.
 * Summary: Implement microblogging using buddycloud
 * Difficulty: Hard
 * Details:


 * The basic features are:
 * Creating a channel
 * Subscribing (or «?follow?») to a channel
 * Posting to a channel
 * Receiving notifications

The student will have to keep in mind that the UI must integrate nicely (remember this is a console client!).
 * XEPs used: 0060, Buddycloud custom

File transfers
The goal of this project is to fully implement jingle file transfers and transport methods into Poezio.
 * Summary: Implement jingle negotiation and file transfer
 * Difficulty: Hard
 * Details:


 * XEPs used: 0166, 0234, 0260, 0261

Gajim
Gajim is a jabber client written in python and GTK. If you're interested in this (or other) project, please jump into the [xmpp:gajim@conference.gajim.org?join gajim@conference.gajim.org] room and talk to Asterix.

Jingle Relay Nodes
The goal of this project is to improve reliability of jingle communication using Nodes.
 * Summary: Implement jingle relay nodes protocol
 * Difficulty: Medium
 * Details:


 * XEPs used: 0278

Last Message Correction
The goal of this project is to :
 * Summary: Implement XMPP and GUI part of last message correction protocol
 * Difficulty: Easy
 * Details:
 * allow user to modify the last message he sent
 * show corrections we received from a contact.


 * XEPs used: 0308

Jitsi
Jitsi is an XMPP audio/video and chat communicator that also supports other protocols such as SIP, AIM/ICQ, Windows Live, Yahoo! as well as many other useful features. Jitsi's XMPP projects are also available here. Teaser tasks can be found here