Summer of Code 2012

From XMPP WIKI
Revision as of 20:25, 17 March 2012 by Remko (talk | contribs) (→‎Swift)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search

The XMPP Standards Foundation is applying to be a mentoring organisation for Google Summer of Code 2012. Project ideas are towards the bottom of this page.

Org acceptances haven't been announced yet, the following text is dependent on us getting in.

We're hoping to be participating in the Google Summer of Code for 2012. Other useful resources include:

Feel free to talk or chat with developers at any of the above resources about potential Summer of Code ideas. Also have a look at the ideas list below, and get in touch with potential mentors for any projects that take your fancy.

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 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).

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's a very popular feature request.

VoIP Support

  • Summary: Implement support for voice (and optionally video) communication.
  • Difficulty: Medium/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.

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.

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.

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

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.

Screen sharing

  • Summary:
  • Difficulty:
  • Details:

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 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

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 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.


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

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

The "it 'effing works as expected" Project

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/

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.

Yor 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.

More info

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


Android or iOS buddycloud client (messaging + pub-sub support)

Summary Build an open-source XMPP client for Android or iOS

Difficulty Given the time constrainsts, extremely

Details

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:

  • 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

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.

Skills

  • Good XMPP knowledge
  • XMPPFramework or Asmack-lib experience

See Also

buddycloud media server

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.

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.

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

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 poezio@muc.poezio.eu to discuss those ideas or submit some new ones.

Pubsub browser

  • Summary: Create a new interface allowing to browse, create and delete PubSub nodes
  • Difficulty: Easy
  • Details':

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.

  • XEPs used: 0060

PEP User additions

  • Summary: Implement user location, user mood, user activity, user tune, and user nickname
  • Difficulty: Easy
  • Details:

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.

  • XEPs used: 0080, 0107, 0108, 0118, 0163, 0172

PEP microblogging

  • Summary: Implement PEP microblogging as defined in XEP-0277
  • Difficulty: Easy-Medium
  • Details:

The XEP-0277 defines a simple microblogging extension to the Personal Eventing Protocol. The implementation must have at least the following features:

    • Publish
    • Receive
    • Reply
    • Repeat
    • Comment

And again, an UI has to be designed.

  • XEPs used: 0163, 0277

Buddycloud-like microblogging

  • Summary: Implement microblogging using buddycloud
  • Difficulty: Hard
  • Details:

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.

  • 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

  • Summary: Implement jingle negotiation and file transfer
  • Difficulty: Hard
  • Details:

The goal of this project is to fully implement jingle file transfers and transport methods into Poezio.

  • 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 gajim@conference.gajim.org room and talk to Asterix.

Jingle Relay Nodes

  • Summary: Implement jingle relay nodes protocol
  • Difficulty: Medium
  • Details:

The goal of this project is to improve reliability of jingle communication using Nodes.

  • XEPs used: 0278

Last Message Correction

  • Summary: Implement XMPP and GUI part of last message correction protocol
  • Difficulty: Easy
  • Details:

The goal of this project is to :

    • 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

XMPP Echo and Mirror

  • Summary: Implement an XMPP component that can Echo and Mirror Audio/Video traffic
  • Difficulty: Medium
  • Details: Implement an XMPP component and Openfire plugin that can provide JIDs/numbers, which, when called, simply play pre-recorded movies or echo and mirror audio and images from the users.
  • XEPs used: 0166, 0167, 0176
  • More info: http://jitsi.org/index.php/GSOC/XMPPEchoAndMusic

libjitsi spin-off

  • Summary: Spinning a libjitsi off of Jitsi so that other XMPP projects could also use it.
  • Difficulty: Medium
  • Details: Jitsi implements a lot of features and supports many complex operations. We’d like to make our work available to all XMPP projects by creating a Jitsi media library.
  • XEPs used: 0166, 0167, 0176
  • More info: http://jitsi.org/index.php/GSOC/LibJitsi

Secure XMPP Server Discovery with DNSSEC

  • Summary: A Java implementation for DNSSEC.
  • Difficulty: Difficult
  • Details: Implement support for the DNSSEC protocol in Java and replace the existing libunbound implementation in Jitsi so that XMPP services (among others) could be securely recovered before connection.
  • More info: http://jitsi.org/index.php/GSOC/DNSSEC

Translating libjingle's PseudoTcp in Java

  • Summary: A Java implementation libjingle's PseudoTcp protocol.
  • Difficulty: Difficult
  • Details: Ever noticed how GoogleTalk allows you to exchange files directly with peers and the speed is so awesome? Well, an important part of that is a tiny TCP implementation that works on top of UDP. Would you like to work on it with us?
  • More info: http://jitsi.org/index.php/GSOC/PseudoTCP

XMPP Goodies

  • Summary: Various XMPP additions to Jitsi.
  • Difficulty: Easy
  • Details: Implement support for various XMPP related features such as user search, last message correction and retrieval of messages sent through other locations.
  • More info: http://jitsi.org/index.php/GSOC/XMPPGoodies

TCP for Jingle Nodes

  • Summary: Implement support for TCP in Jingle Nodes.
  • Difficulty: Medium++
  • Details: JingleNodes provide services that can proxy (relay) media when all participants are in a call. This project is about making this possible over TCP for JN's Java implementation.
  • More info: http://jitsi.org/index.php/GSOC/TCPJingleNodes


More projects

Retrieved from "https://wiki.xmpp.org/web/index.php?title=Summer_of_Code_2012&oldid=6986"