Google Summer of Code 2010

For the last few years, Google has offered a fantastic opportunity for students to help out Open Source software projects in the summer while getting paid for it. It's called Google Summer of Code™, and it provides free software projects a great way of attracting development effort while providing software developers who are still in university with some interesting and useful experiences. Find out more about the Summer of Code (SoC) from their site.

Mercurial is a Distributed Version Control System (DVCS), and we would like to participate in 2010's Summer of Code. In recent years (notably since the Linux kernel project started looking for a new VCS), DVCSs have rapidly started to gain traction. For open source projects, especially, the use of a distributed system can be a great enabler, in that it's much easier to keep track of your own changes and publish them back to the community in a structured way. With centralized systems, you have a central repository that only a happy few have (write) access to, and people spend a lot of time mailing around diffs. With distributed systems, everyone has their own branch, and it's very easy to publish it on the web, compare the changes to those on some other branch or merge two branches back together.

We believe distributed version control is the future, and it looks like many other technologists believe the same. There's some heavy competition between open source VCS systems: git, Bazaar-NG and Mercurial are constantly fighting over users, while many more conservative projects are still on Subversion or even CVS. Competition is fierce, stimulating fast-paced development in the three DVCS contenders. It's therefore important (and good for the competition) that projects like ours gain more developers, to keep up with the race for robustness, performance and features. We view the Summer of Code as a great opportunity to help us in this competition.

Written largely in Python (with the exceptions of a few performance-critical core modules), it is easy to develop for and allows for good code organization and clean abstractions. Moreover, it has been optimized from the start for good performance, using an append-only datastore, minimizing random disk access and smart uses of compression. Finally, it has extensive features for sharing changesets, over HTTP, SSH and in files over email and has an innovative extension (Mercurial Queues) to help building and organizing changesets into a thoroughly useful source history.

1. Notes on applying

Here are some tips on what you might want to include in your application.

• First of all: get feedback on your proposal from the community. The MailingLists and IRC (#mercurial on irc.freenode.net) are quite responsive. Ask around and get to know some people, see if they think your project is feasible or how you should change the scope to better fit the timeline and the project. (If you are new to Open Source development, reading this part of "Producing OSS" may help you find the right tone.) Talking to people before applying dramatically increases your chances of approval: it shows us that you are genuinely able to communicate your ideas, allows us to gauge your expertise level and see who might be the right mentor for you.

• Tell us about yourself. We don't know you, so it helps if you give an outline of your background and what your prior experiences are (e.g. Open Source development, using Python, general software engineering experience or education). If it turns out you wouldn't be a good fit for Mercurial or your project idea, it's helpful for everyone involved if that can be determined before you get started. However, don't hesitate to apply just because this would be your first time working in Open Source or with Python; at some point this was new for each of us.

• Make it clear that you've thought through your application. Don't use a project idea from this page verbatim. Instead, come up with your own proposal, or expand on a proposal from this page. Explore the code a little bit (it's Python, quite easy to read), read CategoryContributing to get a feel for how the community works. Make a clear schedule to show the intermediate milestones you'll reach while progressing towards your final goal.

• Let us know why you care, what you like about DVCSs in general and Mercurial specifically, what things you think could be improved and how they could be improved. We like working on this project because this project makes our work more effective, and we hope you'll like it, too. Showing your motivation helps.

2. Getting things done

Some tips on how you can get to project completion within the scheduled timeline.

• Working on Mercurial in the summer should be your main activity. Having a vacation for one or two weeks is fine, of course, but we want you to take the project and the time mentors put into it seriously. If you are working two other jobs this summer, that probably won't work. Realize that collaborating on software development takes time, and not just the time used to reason about and write the code. This also means that we want you to set some intermediate milestones to be able to keep track of your progress.
• Communicate. In some ways, open source software development is more about communicating than about writing code. Some part of your time will be spent writing code, but a large part of the time spent will go towards explaining the code on mailing lists, asking and answering questions on IRC and in general reasoning about proposed software changes. If you can't do this, you take the risk of not understanding the goals of our project or not being able to explain why your patch is necessary.

• We want you to work in the open, with our community. Get on the MailingLists, both to ask for help and to provide it to other users, spend time on IRC (#mercurial on irc.freenode.net) discussing your work with other developers and explaining Mercurial to all the new users coming in with questions. Set up a public repository with an MQ containing your patches against the crew repository (on Bitbucket, for instance; see also MercurialHosting).

• We're not going to just compare what you did at the end to what you stated you'd be doing in the beginning. We want you to put effort into the project, to think about the feature you're doing, to communicate with the community and integrate your code with the project. If you end up implementing some other cool feature or fixing some annoyance, that is great as well.

3. Project Ideas

Here are a bunch of project ideas you might like to apply for. Of course, if you have a different idea of something in Mercurial that badly needs fixing or some feature you think would make a difference, go ahead and apply with it! Some more project ideas can be found via NewFeatureDiscussions, CategoryNewFeatures and NewIdeas.

3.1. Lightweight copies/renames

(very difficult - a successful student will become an expert in Mercurial's storage format and transmission protocol)

Copies and renames currently are not too efficient. Mercurial copies the copied/renamed source file to the new initial revision of the target file in its internal history store. For renames, this is especially counter-intuitive, as renaming a large file grows the store by the file's size. It would be better if Mercurial had some way of referring to the existing revision from the new file, while preserving backwards compatbility and bounded I/O guarantees for retrieving revisions. See issue883 for discussion. There's an mq from an old attempt at this located here.

Contact: mpm, tonfa, cyanite

3.2. Parent Delta

(very difficult - a successful student will become an expert in Mercurial's storage format and transmission protocol)

Revlogs such as the manifest that have significant amounts of branching can suffer from revlog's linear delta model. Parent delta would allow storing deltas against parent revisions, greatly improving compression. Like lightweight copies, it will require extending the wire protocol to allow backwards compatibility.

Contact: mpm, tonfa

3.3. Better Changeset Discovery

(difficult - a successful student will become an expert in Mercurial's protocol and will experiment with difficult graph theory)

Mercurial currently uses a simple graph discovery protocol to discover what new changesets need to be pushed or pulled without transmitting the entire list available on either side. We suspect that a significantly better protocol exists that has fewer round trips and less data transfer, but research remains.

Some details can by found at DiscoveryPlan, you can also ask parren or tonfa on IRC.

Contact: parren, tonfa

3.4. Partial cloning

(difficult - a successful student will become familiar with most of Mercurial's core algorithms)

(existing work in progress - contact Peter Arrenbrecht, parren on irc)

Currently, it's only possible to clone one whole repository at a time. PartialClone and TrimmingHistory could help make cloning more efficient by limiting the cloning process in either of two dimensions: time or space. For time, we could maybe clone the last few changesets and lazily fetch the rest as needed. For space, it would be nice if it was possible to clone just a subtree of any repositories. For these features, any number of thorny issues can arise because of current assumptions in Mercurial code. These are hard projects, but the result will be worth it to many Mercurial users (in terms of developers and in terms of projects).

Contact: parren

3.5. Instantaneous status on Windows, OS X

(difficult - a successful student will need to debug complex race conditions and master Mercurial's dirstate algorithms)

The InotifyExtension makes a huge difference to performance on moderate to large repositories on Linux (though it still has some difficult bugs). Windows and Mac OS X provide file status notification APIs, so it should be possible to port the inotify extension to one or other (or both) of these platforms, providing the same kinds of speed improvements as on Linux. (Don't try to do all of these in one project; instead, pick one platform you are comfortable with, read about the relevant APIs, then come up with a coherent proposal.)

Contact: nicdumz

3.6. TortoiseHg

TortoiseHg is a GUI front-end, similar to TortoiseCVS and TortoiseSVN. For many people, this makes interacting with Mercurial much easier. There's a lot of room for improvement. An applicant could pick one or more of:

• add graphical UI to interesting extensions like bfiles and others
• add a repository monitoring mechanism, to detect when a GUI application requires a refresh
• add support to Mercurial for paramiko as an ssh agent, hooking password prompts through ui.password
• integrate Meld, which is also written in PyGTK and just recently added support for Windows
• tight integration of hgtk.exe into Visual Studio
• graphical hunk splitting, as discussed in the next task

or their own ideas.

Contact: muggs

3.7. Interactive patch selection for commit/Mercurial Queues/record/import

Being able to select parts of the existing changes, with hunk or greater granularity, in an interactive way, can improve the use of commands and extensions that take changes, such as commit, MqExtension(Mercurial Queues) and import. The RecordExtension currently allows patch hunk selection, but sometimes a better granularity is desired, as when a set of adjacent function definitions should go in different commits. This feature could be added as an --interactive mode for many of Mercurial's core commands.

3.8. Mercurial on Jython

Some Sun projects have taken to using Mercurial as their VCS of choice (OpenJDK, NetBeans; see ProjectsUsingMercurial for a full list). Recently, Mercurial has re-gained pure-Python implementations of the modules that are now in C. It would be nice if someone could take the effort to get this code to run on Jython, opening up Mercurial for use from within the JDK.

3.9. Mercurial on Py3k

(difficult - a successful student will have to master Mercurial's pervasive approach to character set handling and reconcile it with Py3k's)

In 2008, the Python project has finally released their 3.0 branch of Python (affectionately known as Python 3000). This is a major release of Python, with some large changes. Porting to Py3k would be an interesting effort, operating on the current edge of the software, with nice long-term viability results for Mercurial.

3.10. GUI integration

Mercurial is currently lacking features to support integration into a GUI, like TortoiseHg or Mercurial Eclipse. One example of a feature that would benefit GUI is a progress indicator on operations that may take some time.

3.11. Web interface work

The hgwebdir repository interface is one of the successful parts of Mercurial. It allows projects to quickly setup a web interface with access to multiple repositories, and it has some decent ACL features. It's a Python WSGI application, meaning it's relatively easy to run on many platforms and behind differing web servers. It can still be improved, though: there are still some holes in the WSGI implementation (notably, it writes to stdout/stderr in some error conditions) and the access control features aren't always functional enough for complex setups.

Also, improved support for named branches and filtering (like hg log -f and the like) are often requested features.

Also, improving/updating the django application "FreeHg" would be an option, with:

• server side clone
• access rights, with users/groups

Contact: djc

3.12. Conversion tools

Mercurial is a relatively new entrant in the VCS market, and many projects are still using older VCSs such as CVS and SVN. While we currently have some tools to help migrate to Mercurial in the form of the ConvertExtension, these tools could certainly use more improvements. Specifically, enabling the use of Mercurial as a client for SVN or even git and/or Bazaar-NG repositories would be very nice, as it enables developers to make their own choice regarding the use of their VCS client, thereby drastically enlarging our userbase.

The HgSubversion extension already works quite well, but better integration with the existing Mercurial user interface would be nice.

Contact: durin42, pmezard

3.13. Performance tuning

(difficult - a successful student will master performance benchmarking, tuning Python algorithms, and possibly writing C extensions in Python)

There are numerous opportunities for additional performance tuning. Possibilities include:

• faster startup (can we optimize Python load time further? can we minimize loading of unused code further?)
• faster status (can we further improve directory walking? ignore logic? dirstate parsing?)
• faster checkout (can we reduce the overhead of our file I/O paths?)

A project in this area would probably involve picking an important benchmark (eg checkout of a large repository) and tuning multiple areas to meet a performance goal (eg 2x overall performance increase).

4. Mentors

A list of potential mentors.

• MattMackall (mpm on IRC; creator of Mercurial)

• DirkjanOchtman (djc on IRC)

• PeterArrenbrecht (parren on IRC)

• AugieFackler (durin42 on IRC)

• Benoit Boissinot (tonfa on IRC)

5. Students Considering Application

Go on, list your name here!

• Paul Malmsten

• Mark Determann

• Rafael Martins

• Vishakh Harikumar

6. Applications Received From

Not Yet.

7. Project status

Not Yet.

8. Other GSoc Projects related to Mercurial

CategoryNewFeatures

"Google Summer of Code" is a trademark by Google Inc.