With new year upon us, I thought I would take a minute to update everyone on the great progress made in 2009 by the LLVM Project. For those not familiar with LLVM project, it's a cross platform complier infrastructure. We had two successful releases of LLVM, our first release of Clang, a compiler front end for various C languages, and we held our third annual Developers' meeting on October 2, 2009. This meeting is an opportunity for both LLVM and Clang developers to have a face to face meeting, exchange ideas, share their experiences and work together on LLVM or Clang.

This Developers' Meeting was the largest to date! We had 170 attendees with a huge range of different academic and company affiliations. The Developers' meeting was structured to have both a general overview about the major LLVM subsystems and also applications of LLVM for various projects. The LLVM subsystems talks included Clang, scalar evolution and loop optimization, the future of the LLVM register allocator, and a tutorial on building a backend for LLVM. We had many talks on applications of LLVM or Clang, such as OpenCL, Unladen Swallow (a Google sponsored project), Rubinius, and so much more! Community members gave a total of 17 technical presentations on LLVM and its applications, and you can view all the slides and videos from the talks on the Developers' Meeting website.

This event is not possible without the support of our sponsors. Google generously helped fund several students and active members of the LLVM community to attend the meeting and present their LLVM-related work. I'd like to briefly summarize the work by some of these developers and students:

Anton Korobeynikov

Anton is a long time developer for the LLVM project, LLVM's project administrator for Google Summer of Code™ (GSoC) and also an LLVM code owner. For his day job, he is a Ph.D student in applied statistics at Saint Petersburg State University, Russia.

Anton presented an invaluable Tutorial on Building a Backend in 24 Hours. His tutorial overviews the various code generation phases, such as SelectionDAG, Register Allocation, and post register allocation. He goes into the different pieces of the backend that one will need to implement such as the target, subtarget, lowering, register set, instruction selection, and the calling convention. If you have ever wanted to write a new backend for LLVM, this is the talk that you will want to see. (Slides, Video)

Bruno Cardoso Lopes

Bruno is a multi-year participant with the GSoC project, active LLVM contributor, and Ph.D. student at University of Campinas, Brazil. This year, he presented Object Code Emission and llvm-mc. His talk gave a high level overview of the LLVM Machine Code Emitter and focused on the emission of object files. The motivation behind direct object code emission is to bypass the external assembler, and speed up compile time.

His work is a part of the LLVM Machine Code (MC) Toolkit project. The project aims to build better tools for dealing with machine code, object file formats, etc. The idea is to generate most of the target specific assemblers and disassemblers from existing LLVM target .td files and to build an infrastructure for reading and writing common object file formats. His talk goes into the details regarding the design, current implementation status, and future directions. (Slides, Video)

Duncan Sands

Duncan is also a long time developer for the LLVM project and an LLVM Code Owner. His presentation was titled Reimplementing llvm-gcc as a gcc plugin. His project, DragonEgg, aims to replace gcc's optimizers and code generators with those in LLVM without modifying gcc at all. This is done using a plugin via mainline gcc's new ability to load additional logic and passes at runtime via a plug-in mechanism.

The plugin is a shared library that is loaded by gcc-4.5 at runtime and is currently under development. If you are interested in helping with this project, please see the DragonEgg website for more information. Take a look at the slides and video from Duncan's presentation to see where you can get started.

Santosh Nagarakatte

Santosh is currently a Ph.D. student at the University of Pennsylvania. He presented SoftBound, one of his current research projects. SoftBound is a compile-time transformation for enforcing spatial safety of C. It works by recording base and bound information for every pointer as disjoint metadata. It is a software-only approach and performs metadata manipulation only when loading or storing pointer values. The advantage of this approach is that it provides spatial safety without requiring changes to C source code. His talk provides a brief description of the formal proof and LLVM implementation. (Slides, Video)

If you are interested in attending one of our future Developers' meetings, please join the LLVM-announce mailing list. Many thanks again to Google's Open Source Programs' Office for making this event possible!

By The LLVM Team

The yearly MusicBrainz summit serves an important function in building our community: we talk about issues facing MusicBrainz and we plan the road map for MusicBrainz projects. The summits are usually scheduled to allow as many people to attend as possible and this year we chose Nürnberg, Germany as our location. MusicBrainz contributor Nikolai "Pronik" Prokoschenko lives in Nürnberg and was our local contract and ended up planning most of the summit.

Pronik found us a conference room that we rented for the entire day, complete with open WiFi, which is important if you plan to have a room full of geeks. He also found us a cheap Gasthof that provided lodgings slightly better than a Hostel for a mere 20€ per person per night — a really good deal for Europe. The evening before the summit we all sat in the Gasthof and were treated to some confusing German/Greek cuisine with some of the most rude service any of us have ever encountered. But, our group is used to dealing with the crude Internet public, so we managed to laugh off the horrible service and still have a great time.

To our luck there was a grocery store right next door to our Gasthof and we commenced another successful crowd sourced breakfast. Four people were each given 20€ with the instructions to buy food/drinks that they would like to eat/drink for breakfast/lunch. No collusion was allowed between people! Once the shopping was complete we walked to the conference room, settled in and dove into the masses of food we'd collected. Many tasty bread rolls with jam, nutella, cold cuts and cheese were consumed. Of course we had fun things like a case of Bionade, juices, tea, gummy bears and chocolate. Crowd sourcing breakfast takes a potentially frustrating chore and makes it fun for everyone.


Plus, Pronik and his mate Kira brought a MusicBrainz decorated cake to celebrate 10 years of MusicBrainz!


As people were eating, we started to collect an unconference-like agenda of what people wanted to talk about. We decided to have a detailed state of the project talk including recent developments from meeting our customers in Europe. We also talked about current development processes and some of the problems associated with these processes. Oliver Charles, a 2008 Google Summer of Code™ student, gave an introduction on how to hack on the MusicBrainz server, based on his work from the last year.

Most of the time was spent discussing new features for once we release our much anticipated Next Generation Schema. At times we managed to get into deep philosophical discussions about what MusicBrainz is and what it should be. At other times we discussed light hearted topics with lots of joking. These summits do wonders for building our community and getting people on the same page. We manage to explore many topics and reach consensus on many points in one day instead of spending weeks on the same discussions online.

Finally, in the evening we cleaned up our space and retired to a local beer hall where we continued the discussion in a less formal manner. If you're interested, we posted all the session notes from the summit on our wiki. All in all, this event was fun and not much effort to put on — thanks to Pronik! On another happy note, 1/3 of the people in attendance were women, which is much better than most tech summits I've attended.

In total we spent about $1500, including all the food, drinks, lodgings and one person's travel costs. For a summit with 12 people, I think we did rather well! I call that Google's support well spent — thanks again for supporting MusicBrainz, Google!

By Robert Kaye, Executive Director, Metabrainz Foundation

The Globus Alliance is a community of organizations and individuals developing fundamental technologies behind the "Grid," which lets people share computing power, databases, instruments, and other on-line tools securely across corporate, institutional, and geographic boundaries without sacrificing local autonomy. We first participated in Google Summer of Code™ in 2008 and we found the experience extremely productive both for the Globus Alliance and the individual mentors, so we wanted to confirm the value of the program for the students who took part. We contacted our eight students from last year to find out what impact Google Summer of Code had on their lives and careers. While many of our students still remembered the experience fondly, and said it was valued highly by prospective employers, there were two students who had particularly remarkable stories.

AliEn Grid Site Dynamic Deployment and Working at CERN

Last year, Artem Harutyunyan, mentored by Tim Freeman, developed a set of scripts on top of Globus Nimbus to dynamically deploy an entire AliEn Grid site (AliEn is the Grid infrastructure which is used by scientists participating in the ALICE experiment at CERN). His collaboration with the CERN and Globus Nimbus folks went beyond his Google Summer of Code work, and resulted in a new framework, called CernVM Co-Pilot, for execution of 'pilot' Grid jobs on cloud resources. His work is currently used in production to run Grid jobs from CERN'S ALICE experiment, and there are plans to extend it for the execution of ATLAS and LHCb jobs. Artem also co-authored two papers on his work: "Dynamic AliEn Grid Sites on Nimbus with CernVM" was presented at the 17th International Conference on Computing in High Energy and Nuclear Physics (CHEP 2009) in Prague, and "Building a Volunteer Cloud", which includes a description of CernVM Co-Pilot, was presented during the Latin American Conference on High Performance Computing in Mérida, Venezuela.

Holder-of-Key Single Sign-On

Joana M. F. Trindade, mentored by Tom Scavo, spent last summer implementing a Holder-of-Key Single Sign-On profile handler for the Shibboleth Identity Provider in Globus GridShib. And, since then, things have just been getting better for her. Thanks to her outstanding summer work, she was offered an appointment as a Visiting Scholar at UIUC, where she worked on researching fault injection in virtual machines with Professor Ravi Iyer. After six months in that position, Joana was offered admission into the masters program at UIUC, where she is currently working with Professor Marianne Winslett. More importantly, Joana tells us that participating in Google Summer of Code gave her a renewed sense of confidence in her research abilities, having previously thought that her academic background was insufficient to gain admission into a top-tier university in the US. Joana tells us that "After Google Summer of Code, I regained that hope, and I must say I'm really happy to have found a topic in Globus to which I could contribute, and that in turn opened so many doors for me."

Congratulations Artem and Joana for all you have achieved!

Lessons Learned

Our first Google Summer of Code last year also had its fair share of challenges, including two students who didn't make it through the program, but it gave us the opportunity to learn a lot about how to mentor and manage summer students. We were fortunate to be selected again this year as a Google Summer of Code mentoring organization, which allowed us to apply everything we learned. First of all, we required students to provide more information about their background and the project they were proposing. Last year our student application form was essentially a blank form saying "Tell us about your project here," so this year we presented prospective students with more specific questions. We also decided to check in with our students more often which, at least in one case, allowed us to identify a problem between a student and a mentor early on, giving us time to deal with it constructively before the midterm.

In the end, applying what we learned during last year's Google Summer of Code and as well as the Mentor Summit had a noticeable effect. We were fortunate to be given ten students to mentor, and all ten students passed. Furthermore, our mentors report that practically all the code written by the students has either already been released or will be released soon. In fact, overall, we felt that this year's students rocked. Here's a summary of their summer work.

Going Beyond a Single Cluster

The Globus Nimbus cloud toolkit allows you to turn your cluster into an Infrastructure-as-a-Service (IaaS) cloud. However, it was mainly geared towards managing a single cluster. Not any more! Adam Bishop, mentored by Ian Gable, worked hard over the summer to add new components enabling multiple cluster support for Nimbus. He developed a series of production-quality plugins, which have already been committed to the Nimbus source repository, that publish the state of Nimbus cluster back to a Globus MDS Registry. This allows the availability of cloud resources across multiple Nimbus clusters to be gathered together into a single registry, which is the first step towards adding cross-cluster support to Nimbus.

Spilling Over Multiple Clusters

Another student, Jan-Philip Gehrcke, mentored by Kate Keahey, also spent the summer with his head in the clouds, but in a good way: he developed the Clobi project, a job scheduling system supporting virtual machines (VMs) in multiple IaaS clouds, with support for Globus Nimbus and Amazon EC2 clouds. In a nutshell, there are many scientific applications that are typically run as "jobs" on a compute cluster. Jan-Philip's project allows these jobs to be submitted to a cloud instead of to a traditional compute cluster. The most interesting use case is when a site operates a Globus Nimbus cloud and, during peaks in demand for computational capacity, extends its capacity momentarily by spilling the jobs over to a second (or third, or fourth, ...) cloud such as Amazon EC2. Although Clobi is not tied to any particular application (its design is generic and should be useful whenever it’s convenient to distribute jobs across different clouds), the motivating application for Clobi is ATLAS Computing (for the LHC's ATLAS experiment at CERN). In fact, by the end of the summer, Jan-Philip was able to run a common ATLAS Computing application (the so-called “full chain”) successfully with Clobi. If you want more details about Clobi, check out this blog post written by Jan-Philip.

Incremental GridFTP Transfers

Enough about clouds, let's move on to the exciting topic of data. Globus GridFTP is a high-performance, secure, reliable data transfer protocol that is pretty good at moving data. Fast. Of course, there's always someone who wants to go even faster, like Shruti Jain, mentored by Michael Link. Shruti took globus-url-copy, the GridFTP client, and added a 'sync' feature that allows a local and remote file to be synchronized, by sending only the changed sections of the file. This results in more effective bandwidth utilization by avoiding redundant data transfers.

Checksummed GridFTP Transfers

Remember Mattias Lidman? We certainly do. In last year's Google Summer of Code, he developed a compression driver for the Globus XIO input/output library (which GridFTP depends on) to compress/uncompress data as it passes through it. However, although moving data faster is all good and well, it's not worth much if it somehow gets corrupted in-flight. So this year, Mattias, mentored by Joseph Bester, continued to work on Globus XIO and developed a Checksum Driver. Mattias's driver checksums GridFTP data streams allowing both ends of a GridFTP transfer to verify the integrity of the data.

CQL Queries Builder

You know one really cool thing grids are used for? Cancer research. The Cancer Biomedical Informatics Grid, or caBIG®, is an information network enabling all constituencies in the cancer community – researchers, physicians, and patients – to share data and knowledge. caGrid is the underlying service-oriented infrastructure that supports caBIG, and it relies heavily on the Globus Toolkit. Some of the data services in this architecture use a query language called CQL that is, well... complicated. To make life easier for scientists, Monika Machunik, mentored by Wei Tan, wrote a plug-in for Taverna (an open source tool used by scientists to design and execute workflows) for constructing CQL queries, allowing scientists to focus on their work rather than on the intricacies of the CQL language.

GridWay-Google Maps Mashup

Grids require coordinating resources across multiple organizations, and the Globus GridWay meta-scheduler is a great tool to do just that. However, coordinating hundreds or even thousands of machines across dozens of sites can get a bit messy using the console-based tools included with GridWay. Carlos Martín, mentored by Alejandro Lorca, tackled this problem by creating an interactive GridWay-Google Maps mashup, allowing the administrators and users of a GridWay installation to get a quick snapshot of the status of multiple sites and the jobs running in them, as shown in this screenshot:



Carlos used the Google Web Toolkit to develop this application, which is totally decoupled from GridWay, making it easy to install it alongside existing installations of GridWay. In fact, you can download the GridWay+Google Maps application and check out its documentation, including more screenshots, at the application's page on the GridWay site.

GridWay GUI

Srinivasan Natarajan, mentored by Jose Luis Vazquez-Poletti, worked on a more administration-oriented GUI for GridWay, allowing users to compose, manage and control their jobs instead of using the command line interface. This GUI includes a host of other features, such as host and user monitoring, filtering account statistics and execution history information, and support for processing DAGMan workflows, including visualizing dependencies between jobs in the workflow.



Both of the GridWay projects were presented in several sessions, including one on nuclear fusion, at the EGEE'09 conference in Barcelona, Spain back in September.

GridFTP Benchmarking

How about we get back to the subject of data management? The recent addition of UDT (UDP Data Transfer) support to GridFTP has made even faster transfer speeds possible. You guessed it: here's another student who couldn't resist the need for speed this summer. Jamie Schwettmann, mentored by Raj Kettimuthu, sought to characterize the performance of GridFTP over 10Gb/s networks, specifically to measure the speed increase given by UDT as compared to TCP transfers, as well as a number of other considerations such as CPU and memory overhead at both ends of the transfer. In doing so, they decided to develop an automated GridFTP benchmarking and throughput optimization utility called globus-transfer-test, which takes URL pairs from a list or on the command line, and allows for varying input parameters such as parallelism level, transfer type (memory-to-memory, disk-to-disk, etc), TCP Buffer Sizes, MTU sizes, and all other standard globus-url-copy options (except multicasting) and when possible, compares with other performance and throughput utilities such as iperf or scp. Designed for general use by users or administrators as well as to carry out our performance characterization, globus-transfer-test aims to provide enough information to optimize GridFTP options for maximizing throughput between grid sites. This common need has allowed collaboration with many other projects and organizations in the course of development and testing, including the US ATLAS Project, TeraGrid, and OSCER. Jamie even presented a poster on her project at the 2009 Oklahoma Supercomputing Symposium.

AJAX Framework for Globus Web Services

Many of the components in Globus are web services, which are not exactly human-readable creatures. Fugang Wang, mentored by Tom Howe, developed a JavaScript API that enables accessing Globus services from a web client using AJAX. Fugang's framework, which includes a backend service that mediates service requests to the Globus toolkit and an AJAX web client to access this services, makes life easier for Globus developers and users by allowing them to interact with Globus services from the comfort of their web browsers.

Secure Cloud Communications

And we'll end with the ever-popular subject of data management. Melissa Weaver, mentored by John Bresnahan, developed a PSK driver for Globus XIO. She first developed a program that, using OpenSSL libraries to encrypt and decrypt data using a stream or block cipher of the user's choice, allowed her to experiment with different lengths of keys and initialization vectors and different file sizes to make performance measurements. Then, she developed the XIO PSK driver itself, which used the results of the first program to implement an RC2 block cipher to ensure any communication between computers, once a connection has been set up, is secure.

High energy physics experiments at CERN! Cancer research! Nuclear fusion! Cloud computing! Fast data transfers! Oh my! Oodles of congratulations to our mentors and students for all their hard work and for making this such an awesome Google Summer of Code for the Globus Alliance!

By Borja Sotomayor, Ph.D. Candidate, University of Chicago and Google Summer of Code Organization Administrator

Photo Credit: John 'Warthog9' Hawley

This past weekend, approximately 250 Open Source developers from around the world gathered at Google's headquarters in Mountain View, CA for the fourth Google Summer of Code™ Mentor Summit. These developers who mentored students in this year's Google Summer of Code program gathered "unconference" style to discuss ways to improve the program, share their experiences, and learn about each other's projects.

One of the recurring comments about what makes the Mentor Summit special was that it gathers developers from a diverse range of projects (all 150 organizations participating in this year's Google Summer of Code were invited to send two delegates). This allowed for a cross pollination of ideas that isn't usually found at conferences dedicated to one specific platform or language. In addition, the summit was an opportunity for developers who usually collaborate online to meet face to face. In fact, some of our attendees met colleagues they had been working with for several years in person for the first time at the summit!

Most of all, the summit was a great place to meet like minded Open Source developers who are passionate about bringing in new contributors to their communities. Check out photos from the event or read through the session notes to find out more about what happened at this year's summit.

by Ellen Ko, Open Source Team

The leaves are turning here in Mountain View, but they are not the only ones blazing away. It's a busy time of year for open source for Google, with lots of talks and events going on.

Recently:
- Ben Collins-Sussman and Brian (Fitz) Fitzpatrick gave their "Myth of the Genius Programmer" talk as part of the Opening sessions at "Reflections / Projections", the 15th ACM@UIUC Student Computing Conference at the University of Illinois Urbana-Champaign.

- They were joined by Googler and Python maintainer Alex Martelli, who spoke on "Python and the Programmer".

- Chris DiBona, head of the Open Source Programs Office at Google gave a keynote at AstriCon in Glendale, Arizona.

Currently:
- Earlier this week Leslie Hawthorn, manager of the Google Summer of Code program, was part of the amazing team that completed a new "Manual on GSoC Mentoring" in 2, count them, 2 DAYS, finishing up late last night. You will hear more about this feat in a later post after the...

- Google Summer of Code Mentor Summit 2009, being held in Mountain View this weekend, October 24th and 25th. This invitation-only gathering of mentors from each of the participating mentoring organizations in this year's GSoC gives the projects a chance to come together to compare notes on the mentoring process and cross-pollinate their projects. A good time promises to be had by all, and a full report will be forthcoming.

Coming up:
- Jonathan Blocksom will be speaking on Google App Engine and the All For Good project at the DC edition of Stack Overflow Dev Days, October 26th.

- On October 4th the LISA Conference in Baltimore, Maryland will feature a talk by Daniel Berlin and Joe Gregorio on the Google Wave Federation Protocol, the underlying open network protocol for sharing waves between wave providers. Interested attendees of LISA will be able to sign up for a developers Wave Sandbox Account. They will also have a chance to win Googley prizes at the Google Birds of a Feather session the next evening, hosted by Cat Allman and Tom Limoncelli.

By Cat Allman, Open Source Programs

We at the MoinMoin Wiki software development team had a wonderful time with our participation in Google Summer of Code™ 2009. We greatly enjoyed collaborating with our students, hacking Python and Javascript code for the wiki engine. Thanks to Google's support, we had four student projects total, and three of them were successfully completed:

Christopher Denter, whom I mentored, worked on making MoinMoin's modular storage code production-ready by adding an access control middleware. Christopher's work in this area made MoinMoin safer and more flexible. He also worked on a router middleware - think of it as a kind of a wiki
"mount/fstab" - and a SQLAlchemy backend. Our users can now enjoy MoinMoin with MySQL, PostgreSQL, SQLite, etc. Christopher's work was done directly in the repo that will become the 2.0 release of MoinMoin.

Alexandre Martani, mentored by Bastian Blank, worked on a realtime collaborative wiki editor based on Google's mobwrite. Multiple people can now choose to edit the same wiki page at the same time and they all see each other's changes shortly after typing. We hope that we can merge his code into the MoinMoin 2.0 repository soon.

Dmitrijs Milajevs, mentored by Reimar Bauer, worked on groups and dictionary code with modular backends. You can now fetch group definitions from wiki pages or a wiki, and preparations have been made to make an LDAP group backend possible as part of future development. Dmitrijs also refactored the search code to get rid of the unmaintained xapwrap library and use the new xappy library. All his work has already merged into the MoinMoin 1.9 main repo.

Thanks also to Alexander Schremmer for his contributions as a mentor. Unfortunately, his student's project did not work out, but in true community fashion he provided valuable help and feedback for the other students.

In case you're curious about when all this nice code will be released:

MoinMoin 1.9 will be released later in 2009 (likely in November). Please help us beta testing, translating and generally making the release ready.

MoinMoin 2.0 will not just 1.9 + 0.1, but a major rewrite of big parts of the code base. Right now, it's like a big construction site, so it'll naturally take some time until the release will be ready, likely 2010 or 2011. We'd be happy to have your help with it; if you enjoy coding in Python, playing with new features, cleanly refactoring code and working with a fun team, then do join us to make MoinMoin an even better wiki. Check out the MoinMoin 2.0 page for more details.

Many thanks to all the students and mentors as well as everyone in the community who helped or supported the process. It was a very productive summer and we are greatly looking forward to continued work with our new contributors!

By Thomas Waldmann, Google Summer of Code Mentor and Organization Administrator

Ed. Note: You may recall that last week we published the first installment of Emil Ivov's report on SIP Communicator's participation in Google Summer of Code™. This week, Emil shares more of the project's 2009 success stories and lessons learned by the project over the past three instances of the program.

Geek Communicator

Linus Wallgren from Sweden completed a task that many of us have been dreaming about for a long time now: handling SIP Communicator entirely through the command line. So what exactly does this mean? Well, now, you can exit the application, hide or show it, send or receive messages, make or answer phone calls and open or close chats, entirely through the command line. So, you remember that super script that you always wanted to do? The one that sends a message to all your online friends at 3 o'clock every morning? You can now do it thanks to Linus! His work is going to be integrated into SIP Communicator some time this year so stay tuned!

Geek Communicator: Using SIP Communicator through the Console

Setting Your Own Avatar

Shashank Tyagi from India was accepted for the "Dude, checkout my photo!" project. His work consisted of making sure that it was possible for SIP Communicator users to upload a new photo/avatar with popular protocols like XMPP, MSN, Yahoo! Messenger, ICQ and AIM. He first started by exploring the mechanisms supported by the various protocol stacks that allowed this, discovering a few glitches on the way. He then worked on the glue that allows the SIP Communicator protocol modules to export this functionality to the rest of the application, and the GUI. Finally, with some help from his mentor, he also managed to wrap up a module that allowed users to take a picture of themselves using their webcam right before uploading it. Cool, isn't it?

Shashank's work is definitely going to get integrated into our trunk as soon as possible. However, until then you can either test it through his SVN branch or at least sneak a peek here:

Setting Your Own Avatar via SIP Communicator

DTMF with RTP

Romain Philibert from France worked with us on the project "DTMF with RTP" which had the goal of providing an alternative transport for DTMF tones in audio RTP streams in addition to the existing SIP INFO method. The first phase of the development consisted of research on the possible approaches to solving the problem and the viability of each of the approaches was explored with proof-of-concept implementations. The second phase was the actual implementation of the chosen solution and involved refactoring existing source code to generalize it enough to also serve the goal of the project, employing the rearchitected design for the sake of sending and receiving DTMF tones as part of audio RTP streams, writing new UI to allow switching between the alternative DTMF transports, and creating unit tests to assure the correct operation of the functionality. Romain was exposed to communicating on our development mailing list where he reported his progress throughout the program, gathered feedback from members of our community and helped another contributor in resolving a common problem related to the unit tests. The source code he produced has been reviewed and currently awaits for a major redesign of the media service of our project to be finished in order to be updated and integrated into trunk.

DTMF with RTP

Impressive list, right? We're quite happy with it :)

So, let's now get to the final part and look through the three most important lessons we've learned throughout the past three years.

Lesson 1: You've Got to Have the Time

Google Summer of Code is a two-way process. Really! You take a lot so you have to be prepared to give as much. This is not a subcontracting deal where you could simply expect work to get done by itself because it is being paid for (not that this ever happens in subcontracting, anyway). Having a dedicated mentor for a student's project is almost as important as having a dedicated student. I've seen very few exceptions to this and it actually comes down to the following:

1. We are dealing with students who are still learning. As eager as they are to get things done, most of them have little development experience. Therefore if left to themselves, students would tend to over-engineer, go for a dirty hack, overlook existing documentation, misunderstand the goal of the project or a bunch of other things that seem so natural to experienced project developers.


2. Three months is hardly enough time even for experienced developers to fully grasp the internals of a mature project that they've never seen before. It is therefore naive to expect that a student would be able to come up with a usable and integratable contribution without a fair amount of guidance.

I am far from saying that you should be spoon feeding your student or do their work for them. To make things a bit more specific, I'd say that according to our experience a mentor should be ready to spend an average of about 45-60 minutes per day working with their student. Time is rarely equally spread across the summer. Our mentors would often find themselves spending up to two or three hours a day in the beginning of the program while 15 minute chats would be enough to resolve issues toward the end of the term.

Lesson 2: Less is More

I know, I know ... what a cliché! Still, it took us some time to actually realize it so I think it's important to note this lesson. I already mentioned that in 2008 we took 15 students and that this was not our best year. Mentoring resources were of course part of the issue. We had 4 of our most active developers take up two students each. First, this proved to be quite hard for the mentors themselves. Dedicating two hours a day to mentoring may turn out to be an issue when this is not part of your day job. Second, it was also a problem for the other students and their mentors. Given that our most active mentors had their hands full with their own students, they had little time to spare giving advice to other mentor-student pairs when they needed it. This turned out to be a blocking factor on more than one occasion and there was no one happy with the situation.

In addition to mentoring resources, a higher number of students are also hard to handle by the community itself. This means that people would be less aware of the progress of every project, there would be hence less interest, less encouragement, less acknowledgment and community integration for the students.

At the end of the day, we did manage to handle things and we only had a single failed project in 2008. However, the experience was far from the pleasing memories we had from 2007. It was therefore a good lesson to learn because taking less students was one of the main reasons for a successful 2009.

Lesson 3: One Committer per Student

I believe the one-mentor-for-one-student ratio is now commonly accepted practice for Google Summer of Code and that most projects are striving for it. We definitely have done our best to avoid mentor sharing since 2008. Having more than one (non-shared) mentor per student is even better but unfortunately not always possible. Another ratio that is just as important, and probably not that popular, is the number of committers involved as mentors. Code integration represents a significant part of the effort that projects spend over Google Summer of Code. It is quite obvious that if the developer committing the work of a particular student is also their mentor, integration is going to be a lot easier than if it were someone else.

For example, we had some very valuable stuff written during 2008, like support for proxies from Atul Aggarwal. Atul did a good job, but, his only mentor, despite being very technically savvy and knowing the project quite well, did not have committer access. Proxy support is quite important for SIP Communicator, although not necessarily critical. Committing Atul's work however, would require an existing committer to study all his work, and there always seems to be something in the critical path for development that must be reviewed. Things would have been a lot easier if one of the people that were expert in this field had been following the project right from the start.

We therefore decided to add pair each student with a committer in 2009, and each committer only had to take care of one student. The results were excellent, and as I already mentioned, we already have approx 30% of the GSoC code committed barely a week after the end of the program!

Lesson 4: Specific Tasks and Clear Conditions (Learning in Progress ...)

Ok ... this case is not really that straightforward and we have more learning to do before we really get it. Here's the problem:

In 2007 and 2008, we had a couple of students who would get to 50% or 60% of their work and then get distracted with unimportant stuff or simply disappear for a while. At a point their mentors would remind them that they have more to do and this would cause the students to feel uneasy, panic, or start arguing about things, such as:

"Oh, I didn't know I had to do unit testing!" or "I was never told this feature was part of the job!"

The statements weren't completely false. It could indeed happen that a task would seem obvious to a mentor and in the same time feel utterly unnatural to a student. In one case, it was actually the mentor who didn't request a task that was considered important by other community members.

So either way, in order to try and limit the surprises we decided that we needed to start every project with a list of clearly defined sub-tasks. This way, we thought, students would know exactly what they need to do and organize better. It would also help make sure that everyone on our side was well aware of the "official" project vision. Sounds neat, right?

Well, it didn't really work out that way.. Most of the students didn't have a problem with the new system, but then again, most of the students didn't have problems without it either. One of the students we failed, however, claimed the requirements list had been misleading and had made them believe they could plan a few weeks off. When we told them that this would be risky they complained it was too late to cancel the reservations, so they didn't listen ... and eventually failed.

So it appears that a list of what we believe to be specific requirements doesn't seem to change much in terms of understanding the goals of a particular project since there's always something that could be misunderstood. Clearly, continued mentor-student communication is crucial here but it seems that we'd also need explicit there-may-be-more-to-this-than-you-think notes.

Phew, that sums it all up! Hope the lessons we've learned above would help others in similar situations. Good luck to all of you future Google Summer of Coders!

Ed. note: Post title corrected.

By Emil Ivov, Project Lead, SIP Communicator and Google Summer of Code Mentor

Google Summer of Code™ 2009 (GSoC) was filled with fresh faces and exciting new projects for The Perl Foundation (TPF). As I write this, we are currently in the final stage of the summer where students submit evidence of their work in a zip/tar.gz file by uploading it to a publicly viewable repository. I very much like that now anyone on the 'net can download a file containing the entire summer of work by the student, and there is even a download count next to each file for each student!

We started the summer with nine students, but Kevin Tew was not able to work on "A prototype LLVM JIT runcore for Parrot" in the program due to external issues. He is still a core Parrot Virtual Machine developer and I hope that he can find time to work on this awesome project some time in the near future. Since Parrot is currently redesigning its JIT framework from the ground up, a project similar to this would be great for next year.

The other Parrot VM project was Daniel Arbelo Arrocha working on "Decimal Arithmetic: BigInt, BigNum and BigRat for parrot" with Christoph Otto as a mentor. Big Decimal Arithmetic basically means storing arbitrary large/arbitrary precision numbers internally in a decimal format rather than the binary format usually used. Doing this can prevent catastrophic rounding errors. If you can store numbers internally with exactly NO error, then obviously this is A Very Good Thing. Daniel worked on making dynamic PMC's (Polymorphic Parrot Classes, or Parrot Magic cookies, take your pick) which wrap the mature and extensive IBM's libdecnumber library. What this means is that Parrot can do arithmetic on arbitrarily large integers (BigInt's) or floating point numbers with arbitrary precision (BigNum's.) Financial people are very interested in these as well, since no one wants to be short-changed on their interest due to rounding error. Daniel has also been contributing patches to many other parts of Parrot and will probably be getting a commit bit soon, which is great news to hear.

Devin Austin worked on "Refactoring Catalyst helper modules", with Kieren Diment as a mentor. This involved some "Moosification", which means refactoring home-rolled object-oriented code to use Moose (the post-modern Perl 5 object system), i.e. less code to maintain and more features at your fingertips.

I am excited to talk about our next student, who worked on a Perl 6-related project. Carl Mäsak mentored Hinrik Örn Sigurðsson on "Perl 6 End-User Documentation Tools" (github repo) . Hinrik is working on the grok command, which is the Perl 6 relative of perldoc. With it, you can get documentation for Perl 6 functions from the spec, read the Synopses and Apocalypses, and occasionally attain temporary enlightenment. If you have a properly installed CPAN client on your computer, you can install it with cpan App::Grok.

Our other exciting Perl 6 project was Paweł Murias working on "Multimethods for SMOP", mentored by Daniel Ruoso, the lead developer of SMOP. SMOP stands for Simple Meta Object Programming (or Simple Matter of Programming, if you are feeling snarky) and it is an implementation of Perl 6, a sister of Rakudo. Multimethods, short for Multiple Method Dispatch, is a feature where a language can determine which variant of a set of functions to call, based on the type of their arguments. One way that this becomes very powerful is that you can use wildcard arguments when you declare your multimethod, so you can essentially write many functions at once. Less code to maintain is a big WIN ! Paweł's code is being directly merged into the mainline SMOP codebase and from what I hear, he is and will continue to be a core contributor. That is what GSoC is all about. That and free t-shirts.

State Transitions in Mojo::Pipeline

Pascal Gaudette worked on "HTTP/1.1 Compliance Testing and User-Agent Development for the Mojo Web Framework" with mentor Viacheslav Tykhanovskyi. This is important because Mojo, one of the newest and most exciting Perl Web frameworks did not have much testing for acting correctly according to HTTP/1.1 . Part of the work of this summer has become the CPAN module MojoX::UserAgent. He has a great blog post about "State Transitions in Mojo" wherein he explains how Mojo deals with state and generated some pretty cool transition diagrams by documenting when a state transition happens in the test suite and then feeding this data into Graph::Easy.

WebKit has become often-forked and very influential open source browser engine, so it is no surprise that Perl hackers want bindings to it. Ryan Jendoubi worked on "Cross-platform Perl Bindings for wxWebKit" with mentor Michael Peters, which allows WebKit and WxWigdets, a cross platform GUI library, to talk to each other via wxWebKit. I think this was one of the more difficult projects this year, not because of the programming/algorithms involved, but because it requires getting lots of cross-platform, constantly-changing and fickle pieces of software to get along with each other. This is often like inviting zebras and lions to the same party. Messy and dangerous. But Ryan prevailed and we give him much respect and hope that he continues to maintain and improve the Wx::WebKit bindings.

I had the pleasure of mentoring Robert (Bob) Kuo this summer on his work entitled "Implement BPSW algorithm as a Perl 5 CPAN module, Math::Primality with extensive test-suite." The Math::Primality module is already on CPAN and I am glad to announce that Bob is listed as co-maintainer and published the latest release. This module is important because the Perl 5 Cryptography CPAN modules (mostly in the Crypt::* namespace) have one, very large, very fragile dependency, called Math::Pari. Math::Pari is an amazing library that gives Perl access to the extensive state-of-the-art number theory library PARI, but to attain ultimate speed, Math::Pari pokes into undocumented internal-only Perl core internals, which means that changes to Perl internals that *shouldn't* have any effect on the outside world can cause the entire Crypt::* namespace to break. Also, most of the Crypt::* namespace require only 5-10 functions from Math::Pari, which provides an interface to thousands of functions. Math::Primality implements the few prime-checking (primality) functions that Crypt::* modules want from Math::Pari in a small, easy-to-maintain, pure-Perl CPAN module. Bob implemented the BPSW algorithm, a state of the art prime-number checking algorithm which allows you to check if an arbitrarily large number is prime in O( log(n) ) i.e. logarithmic running time. It is actually a combination of very different prime number checks, which weed out different types of non-prime numbers. So far, no one has found a counter-example to the BPSW algorithm (even though those pesky mathematicians say there probably are), so it is the best out there currently. It is estimated that because no one has seen this algorithm fail yet, and it being used extensively from within other algorithms, that the first counter-example must be at least 10,000 decimal digits long! Future steps for this module will be to work on its sister module, Math::Factoring, which implements the remaining factoring-related functions that Crypto modules want and then use both modules as new dependencies for the Crypt:: namespace, instead of Math::Pari.

Justin Hunter was mentored by Ash Berlin on the project "SQL::Translator Rewrite" (github repo). SQL::Translator is a very popular CPAN module for translating various "flavors" of SQL to and from each other, such as Postgres to MySQL. This involved more "Moosification", as described above. Justin also has some advice for hopeful GSoC students:

• Get over yourself.


• Understand there are people smarter than you or people better at some things than you.


• Just the same, you're still needed.


• Just Go Ahead and Do It and find your niche.

I wish someone had told me that about 10 years ago. I would not have wasted a lot of time worrying that people would think I was stupid and starting diving into Open Source projects much more earnestly.

In total, we had a success rate of 8/9 = 88.8%, just a bit above this year's all time high of 85%. Please join me in congratulating all these students and mentors for their top-notch work ! I can honestly say that I had much fun interacting with so many corners of the Perl community. This was my first year being an organization administrator, I learned a lot by my favorite method: sink or swim. I was handed over the magic rocket-powered surf board by Eric Wilhelm after successfully mentoring Thierry Moisan last year on the Math::GSL CPAN module. Organizing and communicating with people spread across a dozen time zones is definitely an art that I am still mastering. I think using as many mediums as possible to communication with people is key. I already use chat, email and IRC, but I wish I had done voice/skype and/or video chat with some of my students and mentors, so that everyone has a face to attach to a name.

I would also like to thank Jerry Gay for being The Perl Foundation co-pilot this year and welcoming me into the Parrot community. Your guidance in certain matters went a long way.

For anyone that would like to help/be involved in Google Summer of Code with The Perl Foundation next year, we cordially invite you to our IRC channel, #soc-help on irc.perl.org, and the mailing list.

By Jonathan Leto, Google Summer of Code Mentor and Organization Administrator

So, here we are: we have just completed our third Google Summer of Code™. Despite the nostalgia that has settled in after the end of the summer, we are all feeling very, very happy about how things went this year. While observing my fellow mentors, who are busy integrating our students' contributions into our code base, I am tempted to reminisce about our three year history with the program and the lessons we've learned.

First of all however, a quick history of our participation: Our adventures started in 2007 when we were accepted into the program for the first time. I can still remember jumping all around the room when I saw SIP Communicator's name in the list of accepted organizations. Back then we were a brand new project and this acceptance was a tremendous recognition. As it turned out later, it made a great difference in terms of popularity, credibility, and bringing new contributors both directly and, above all, indirectly.

Our first summer went exceptionally well. First of all, we had a decent number of applications, 87 to be precise, and by decent I mean not too much for the available mentors to handle and yet enough for us to have a wide choice of candidates. We received funding for eight student projects, which, as it turned out later, was also just right. At the end of the summer we had 7 successful students. During the months following Google Summer of Code 2007, we integrated virtually all the work that came out of it. We also voted and accepted two of the students as permanent committers.

Then came 2008. Once again we were all rejoicing in anticipation of a productive summer. This time we had 187 candidates and were received funding for 20 student projects. At that point, however, we started realizing how big a number 20 is and we got a bit scared. We were afraid that would be too many students for us to handle so we decided to only take 15 and let other projects mentor the additional five. It turned out later that 15 was still a bit too many - more on that later. The summer went pretty well and a lot of work got done. Once again we voted and accepted two of the students as permanent contributors and only had a single failing student at the end of the season.

This leads us to 2009, and boy was this year a good year! I can now safely say that this has probably been our best participation so far. We received a staggering number of applications: 203 to be precise. We only had around 15 mentors so it took us quite some time to go through all of them. Once we were done with the evaluations we requested 12 student projects but played it safe and decided to go with only ten, leaving the rest of the funding for other student projects. Once again, it was a really great summer. We are still in the process of integrating all the contributions and it will probably take us a few months before we are done. Even at this point, with about 30% of the work in our repository, we have already voted and accepted 2 of the students as permanent committers with probably two or three more to come in the the following months. Hip Hip ... Hoorray!!!

Here's an in-depth look at some of our 2009 projects:

Growl Notifications, and Next Generation Sparkle Updates

Egidijus Jankauska from the United Kingdom has implemented a native popup notification for the MacOS X version of SIP Communicator. It makes use of the Growl notification daemon through a new implementation of the Java bindings of the Growl API. For that purpose, Egidijus has implemented a dynamic library using Java Native Interfaces, a set of Java interfaces, and the corresponding implementations for SIP Communicator. The new born library can of course be used in other projects and this implementation has already been integrated in our source trunk.

Egidijus has also updated our package update system on MacOS X. It was based on Sparkle 1.1, and Egidijus has provided the necessary patches and documentation to switch to Sparkle 1.5b6. This work has also been integrated in our source trunk.

Egidijus has since been voted as a committer and is now part of our developer team!

Software Updates Using Sparkle and Popup Notifications Using Growl

Hush-hush Chats with Off The Record (OTR) Messaging

George Politis from Greece worked on extending SIP Communicator with Off The Record (OTR) message encryption. OTR provides encryption, authentication, deniability, and strong forward secrecy. Until now SIP Communicator did not have any text message encryption and our chats were often unprotected. George started with the implementation of our own Open Source native java OTR library, which can also be used in other projects. George also implemented all the message transformation functionalities and the GUI necessary for us to integrate OTR support in SIP Communicator. It is already implemented in many of the other popular instant messengers such as Kopete, Pidgin, Adium, mICQ, Miranda, and Trillian. SIP Communicator is now able to carry out encrypted communications with other SIP Communicator clients and the aforementioned messengers.

George's implementation has already been integrated in our source trunk and George has achieved committer status for SIP Communicator with a strong approval of our community.

An OTR Session with SIP Communicator

Storing Chat History and Contact Lists in a Database

Ajay Chhatwal from India was in charge of implementing a Database system to allow us to store all chats in a database instead of XML files. Ajay has studied many database systems, produced a comprehensive comparative evaluation on them and suggested a winner that would best suit our use case. He has then implemented a database service and a backend to provide a working database service to all the components of SIP Communicator, after which he worked on a transition mechanism that would allow transferring XML files from the old implementation into the new database system.

Once he completed his work on the history modules - yes, he still had time to hack before the end of the summer - Ajay has also coded a new version of the contact list service which now also uses the database service.

We're hoping to vote Ajay in as a committer soon.

Recognizing and displaying remote user agents

This one was worked on by Brett Geren from the United States. The project consisted of retrieving the names of the applications that our buddies are using when chatting with us, and showing the application icons to the user. In order to accomplish this task, Brett first completed extensive research determining which of the protocols we support in SIP Communicator actually deliver such information and how they transport it.

He then defined the interfaces necessary for a new user agent module and implemented the feature for MSN, IRC and XMPP. During the second half of the program, he worked on the user interface that actually displays the remote client icon and allows users to configure the behaviour of the user-agent plugin. He also completed tests with a long list of known clients in order to confirm the way they are publishing their client name and to make sure that SIP Communicator was working with them as expected.

Ed. Note: This post is the first installment from the SIP Communicator project on their participation in the Google Summer of Code program. Look forward to even more information on their 2009 student projects and some in-depth details on lessons learned on this blog next week. Stay tuned!

By Emil Ivov, Project Lead, SIP Communicator and Google Summer of Code Mentor

Celebrating Software Free Day at Atlanta Linux Fest? Should you happen to find yourself in Georgia's capital this Saturday, please stop in hear our very own Ellen Ko deliver a talk on Endless Summer: Create Your Own Program Based on Google Summer of Code™. Ellen will be covering topics from marketing to motivating a developer community, with a special emphasis on lessons she's personally learned during her first year as the program's coordinator. You can also get your questions about the program answered and meet up with fellow Google Summer of Code participants during an evening Birds of a Feather Session. We hope to see you there!

By Leslie Hawthorn, Open Source Team

While many students might be spending their summers backpacking around Europe, working at an investment bank, or catching up on their studies, our Google Summer of Code™  2009 students Udai Gupta and Johan Hilding were helping to transform technology in the fight against global poverty through their work with the Grameen Foundation, a global organization working to end poverty through microfinance and other initiatives to strengthen local business and social institutions. Udai and Johan recently concluded their projects with the Mifos Initiative, an Open Source information technology platform built by the Grameen Foundation to help microfinance institutions more effectively deliver financial services to the poor.  Sponsored and provided a stipend by Google, they spent their entire summer making stellar contributions to advance testing and quality assurance in the Mifos platform, improving the quality of our software for our customers and making it easier for developers around the world to contribute code to our platform.

Udai, a recent Bachelor’s of Technology recipient from the LNM Institute of Information Technology India and Johan, a second year-student attending the Kungliga Tekniska Högskolan (KTH)  in Stockholm, Sweden, both applied to the Mifos Initiative to learn about testing, agile development, and pair programming all while helping to deliver a flexible technology solution to the microfinance industry.  Lead by their mentors, Jeff Brewster from the Grameen Technology Center in Seattle, Washington, USA and Adam Monsen, working remotely out of Minnesota, they collaborated across the globe with our entire community of microfinance practitioners and technology professionals.  

With their work stretching across so many time zones and physical and cultural borders, at times it was challenging for Johan and Udai to work while being so far away.  Technology like Google Groups, IRC, Skype, and TokBox were instrumental in bridging the communication divide; yet, it was the steadfast commitment and passion to work late into the night that made successful collaboration possible.  

Through Google’s commitment to the Open Source community, the Grameen Foundation has been able to utilize Udai and Johan's skills to make enormous contributions to the Mifos Initiative.  Udai’s major accomplishments throughout the summer included standardizing the naming conventions of our unit and integration tests, making these tests run independently of one another and optimizing the MySQL database to improve overall performance of these tests. His efforts helped lay the foundation for greater modularity in Mifos which will allow our community to build new functionality more effectively, enabling microfinance institutions to release new products and pioneer new technologies like mobile banking to serve the poor.  

Udai Gupta

At the same time, Johan helped to triple the number of acceptance tests in Mifos, allowing us to do more frequent releases with the assurance that no code is breaking. His improvements to the acceptance test infrastructure from making drop-down boxes language independent, to making tests run in different locales are a huge value-add to our international customer base. His work will be utilized significantly as the Mifos team delivers an Arabic version of Mifos in their upcoming release.  

Johan Hilding

With Google Summer of Code 2009 now complete, Johan, like the majority of the more than 1000 students who contributed to one of 150 different projects, will be returning to his studies at KTH in Sweden.  However, for Udai this marks the beginning of a new path for him as he will be moving to Bangalore, India for the next 12 months to continue contributing to Mifos and supporting one of its leading customers, Grameen Koota.  The Grameen Foundation hopes to participate in future instances of Google Summer of Code and we invited all folks interested to join our community at www.mifos.org/developers. You too can help to change poverty one line of code at a time!

By Adam Monsen, Mifos Summer of Code 2009 Mentor and Software Engineer, Grameen Foundation

The sun has set on our fifth year of introducing college and university students to Free and Open Source software development, and what a year it's been! Just under 2000 mentors and 1000 students began working together to improve the code bases of 150 projects, and we're pleased to let folks know that 85 percent of our student participants have received passing final evaluations, up a full two percent over 2008 and our best success rate to date.

These successful Open Sourcerers are busy preparing code samples for the world's perusal, and we'll post an update here when actual source code produced during this year's Google Summer of Code has been made available on project hosting on Google Code. Of course, there's no real need to wait for code samples - many of these students have already had their work integrated into their project's code base, so check out their work by visiting the websites and mailing lists of your favorite participating projects now. We'll also be publishing more extensive statistics from our program evaluations, along with wrap up reports from some of our participating mentoring organizations, so stay tuned for more details in the coming weeks.

Google Summer of Code Mentors Dimitri Gaskin and Karoly Negyesi
Photo courtesy of Scott Hadfield

Congratulations to all of our students for their achievements this Summer. We certainly hope you will continue helping your project communities with source code, documentation and general enthusiasm long after this Summer has ended. Many thanks also to our community of mentors, without whose time, skill and dedication this program would not be possible.

By Leslie Hawthorn, Open Source Team

Every year several hundreds of Debian contributors from around the world get together at DebConf in a different city to share a week (or more!) of work, friendship and fun.

The 10th annual Debian Developers Conference just ended a few days ago in the beautiful medieval city of Cáceres in Spain with Debian Project Leader Steve McIntyre concluding: "This has been one of the most productive conferences we have ever held. Our developers and teams achieved a great deal during this short period, and this will surely have a big impact on the upcoming release of 'Squeeze'."

Among the many notable talks were the release goals and plans for Debian GNU/Linux 6.0 "Squeeze" as well as the new timed freezes release policy, and the Project Leader's keynote about working further towards Debian's motto of being the "universal operating system".

In all, over 130 different sessions took place during the conference, ranging from formal talks to numerous spontaneously scheduled meetings. For most of these sessions, live video streams were made available over the internet as well as recordings: http://debconf9.debconf.org/video.

Also this year, several students from the Google Summer of Code program in the Debian project were present to receive feedback on their projects, gather new ideas, and establish relationships with fellow developers. Along with the technical discussions and idea exchange, the students were able to experience by themselves the Debian community, one of the key factors that makes Debian the amazing project that it is.

Google Summer of Code™ students and Debian Developrs, left to right: Sha Liu, Per Andersson, Diego Escalante, Michael Schultheiss, Obey Arthur Liu, Bdale Garbee, Neil McGovern, Steve McIntyre (Debian Project Leader)

Attending as Google Summer of Code students were: Per Andersson, Diego Escalante and Sha Liu. Aurelien Jarno and Wookey were present as mentors and, Obey Arthur Liu and Steve McIntyre as administrators. Sadly this year we couldn't have the full Google Summer of Code crew due to problems with visas, work, universities.. but the very high concentration of Debian Developers has helped several Google Summer of Code projects both on site and remotely.

As the week progressed students were able to get feedback from different people about their current work:

Per Andersson, flying from Stockholm, Sweden: working on adding support for installing Debian on MTD flash based devices, opening Debian to a whole new class of popular embedded devices.
"DebConf9 really met my expectations. Loads of freedom loving nerds -- People like me! During the week I had the chance to engage people whom worked with related software; amongst them Debian Installer and GNU Parted developers. I also made contact with the Debian FreeSmartphone.org team, who maintains packages targeted at OpenMoko phones."

Diego Escalante, flying from Lima, Perú: working on Amancay, a new interface to the Debian Bug Tracking System targeted at improved collaboration.
"I was able to talk with others about ideas and important points to consider to get more people involved in triaging bugs in Debian. Also users and developers shared thought-some feelings about increasing triaging and how it would affect them. Above all, the conference also gave me the chance to get an inside look of how Debian developers work and think and how they are different from other developer communities I know, allowing me to take more things into account in designing the UI of."

Sha Liu, flying from Shanghai, China: working on creating a mips3 port, bringing to an important range of netbooks popular in Asia.
"I discussed problems I encountered in the project and introduced the loongson2F CPU to many developers interested in porting their software to mips. The members of the emdebian team shared with me a lot of valuable experience including using the qemu simulator, the process of building a Debian armel port etc. However, the most important things I learned during DebConf9 was the infrastructure and philosophy of Debian-the most universal operating system."

All the attendees going to the daytrip to Valle del Jerte: hiking, swimming, sunbathing.

The whole Debian community is grateful to Google for being a great sponsor of the conference and specifically sponsoring the entire travel costs of our Google Summer of Code students.

The Google Summer of Code has been a success for each of the past four years Debian has participated, and we look forward to welcoming more students at Debian and DebConf.

See you in 2010 at DebConf10, taking place this time in the heart of Manhattan, New York City, USA!

Photos courtesy of Aigars Mahinovs

By Obey Arthur Liu, Debian Google Summer of Code 2009 Organization Administrator, 2008 Student

On August 13th, 2009, starting at 6 PM a little more than 50 people trickled into our Zurich, Switzerland office to share thoughts and snacks about all things free as in freedom for the 8th edition of the Zurich Open Source Jam. By 7 PM, a great variety of talks were lined up on the whiteboard and we started with our traditional lightning talks.



Markus Michael Geipel introduced us to his research on Dynamics of Open Source Code, providing quantitative insights into laws of growths, change dynamics and special structures applicable to open source development. He also presented us with a research tool developed for this project and contributed to Open Source, a workbench for relations visualization.



Lukas Lang, a Google Summer of Code™ 2008 student, talked about a program at the Institute for Software Technology of Vienna University of Technology to involve students in Open Source during a semester as a subject. Students participate into Open Source organizations such as Apache Software Foundation and develop independent proposals to achieve during the semester, not unlike the Google Summer of Code.



Matthaus Ringwald presented BTstack, a lightweight and portable Bluetooth stack for embedded machines. BTstack targets devices such as the iPhone, where the existing Bluetooth stack is severely limited, or embedded operating systems lacking any Bluetooth support. He presented us with a live demonstration of a WiiMote controlling over Bluetooth a 3D object in an OpenGL ES application running on an iPhone.



Michel Pauli recounted to us his travels in Africa and in particular his work in a school in Limbe, Cameroon. He has been using Open Source software to run a computer lab using partly scavenged hardware with great success. With tools such as LTSP,Xen, Edubuntu or Moodle, he used computers to transmit a broad range of knowledge on only a few watts of electricity.



David Anderson presented NxOS, an operating system base for the Lego Mindstorms NXT robotics kit. The system aims to simplify the basic job of other NXT operating systems such as Lejos, as well as open the doors for new experiments with the kit. The topic of killer robot armies made of lego, foremost in everyone's minds, was of course discussed.



Tara Andrews told us how Open Source would help the Humanities. She explained how the current state of specialty humanities software impedes collaboration and research, and envisaged what computing in the Humanities could achieve if open source software development methodologies were being efficiently used. We traveled all over Europe through her fascinating stories of copist monks, manuscripts collecting, Unicode mangling and massive textual corpus diffing.

The rest of the evening saw Googlers and guests happily chatting about all kinds of subjects and 10 PM was too soon and the (Swiss) beer still unfinished when we had to mark the end of this edition of the Zurich Open Source Jam.

To stay informed about future Open Source Jams in Zurich, please join the Open Source Jam Zurich Google Group. Open Source Jams are sponsored by the Google Open Source Team.

By Obey Arthur Liu, Software Engineer in Test Intern

Potential Google Summer of Code™ students often ask us, "What can I do to gain an edge the program?" New mentors and project admins often ask, "What helps students succeed?" Well, we have heard several responses to these questions from existing students, mentors, and admins at our Google Summer of Code BoFs, and now we have the numbers to back up their observations.

Last week I posted some preliminary numbers from the Google Summer of Code midterm mentor survey, and since then I have continued to crunch more numbers from the survey, beginning with an analysis of which factors are correlated with student success. To accomplish this I separated the survey into five groups, based on the student's status as reported by the mentor: Already Completed, Ahead of Schedule, On Schedule, Behind Schedule, and Far Behind Schedule. Once the answers, each representing a student, were separated out into these groupings, I compared the percentages of each group's answers.

The first question on the midterm mentor survey was, "At what point did you first make contact with your student?" The answers revealed a clear trend, showing that the earlier that students and mentors came into contact, the more likely they were doing well in the program.

(click on graph to enlarge)

This comes as no surprise, as making contact with a mentoring organization early reflects a student's motivation and initiative. This comment has been heard frequently when mentors discuss hallmarks of their most successful students.

The second question on the mentor survey had to do with the frequency of mentor-student interaction. The mentors' answers to "How often do you and your student interact?" were just as revealing as the first survey question, as it showed students that have interaction with their mentors more than once a week were more likely to be on schedule, ahead of schedule, or have already completed their projects.

(click on graph to enlarge)

A new area of feedback gained from this survey is how the method of communication between mentor and student correlates with the project's status. Question #4 on the midterm mentor survey was, "Of the different communication methods you use with your student, which do you use most frequently?" There were several possible answers, with IRC/instant messaging and private emails making up the majority of responses. Interestingly enough, when looking at the percentages of responses by status, a clear trend emerged here as well. Those using IRC/instant messaging as their primary method of communication were far more likely to be on or ahead of schedule than those using email.

(click on graph to enlarge)

I suspect that this is because of the immediate, real time nature of IRC/instant messaging. Students and mentors may feel a greater sense of accountability when there is no time gap between responses, or perhaps since IRC/instant messaging requires coordinating a particular time to meet, there is a greater amount of commitment involved, in turn indicative of a generally higher level of commitment to the work.

One of the questions that gave a murkier picture was "How much time have you spent per week interacting with your student, on average?"

(click on graph to enlarge)

I have yet to find a definite message from this graph after sorting the data several different ways. Perhaps these numbers simply tell us that the amount of time interacting is less important than the frequency of interactions.

These four graphs boil down to the following:

• The earlier a student begins interacting with the mentor/mentoring organization, the more likely the project is to be on or ahead of schedule.
• The higher the frequency of interaction, the more likely the project is to be on or ahead of schedule.
• Projects that are on or ahead of schedule are more likely to be interacting via real time methods of communication (such as IRC).
• The amount of time spend during these interactions has a less clear relationship to the project status.

Those familiar with FOSS should know the advice "release early, release often." My advice to Google Summer of Code participants is to "contact early, contact often!" I welcome your personal take on these numbers in the comments section.


By Ellen Ko, Open Source Team

One of the great things about Google Summer of Code™ is that it's a great way to meet other Open Source-minded people. Not only do students get paired with their mentors, but students get to know each other, as do mentors and project administrators.

Last month, Leslie Hawthorn, Cat Allman, and I attended the Google Summer of Code Birds of a Feather session at Open Source Bridge, organized by Jonathan Leto. We had the pleasure of meeting with Google Summer of Code students, mentors, admins, and potential participants to discuss what works, what doesn't work, and ways the program could be improved. We got some great feedback, and best of all, we had the opportunity to interact face to face with participants instead of solely via email, mailing lists, or IRC! You can see a photo and read more about the meetup on Jonathan's blog post about the event.

Last week, the Open Source Programs Office outreach team met with more Google Summer of Code participants at our BoF session at OSCON. Our session extended late into the night with some really interesting discussions about how to help students succeed in computer science.

If you would like to know about upcoming Google Summer of Code meetups, please join our meetups mailing list - we'd love to meet you!

by Ellen Ko, Open Source Team

(click on graph to enlarge)

Thursday at OSCON, Leslie Hawthorn gave an update on the state of the 2009 Google Summer of Code program. One of the points that she shared with the audience was the 93% student success rate as of midterm evaluations, which were submitted July 13th. Congratulations to our students, mentors, and admins for all their hard work! Based on our mentor survey, most of our students are doing well, with a few students already finishing their project!

For the rest of the students, the summer is not over yet and there is still lots of coding left to do. I hope that this year will be our most successful to date! Read the statistics about previous years here.

By Ellen Ko, Open Source Team

OSCON has returned to the San Francisco Bay Area for 2009, and Googlers will once again be out in force to spread the joy of all things Google and Open Source. Please make sure to join us on Tuesday, July 21st for the conference opening ceremonies, where we'll announce the winners of the 5th Annual Google O'Reilly Open Source Awards. If you've already arrived for the conference, you may want to stop by our Birds of a Feather session for the Google Summer of Code™ community this evening at 8:00 PM. We're also proud to feed all of you in the great Google tradition at Wednesday's lunch.

And, of course, there will be several talks and tutorials delivered by Googlers, including:

• Introduction to Google App Engine by Joe Gregorio, 8:30 AM on July 20th (tutorial)
• Zen and the Art of Abstraction Maintenance by Alex Martelli, 10:45 AM on July 22nd
• Even Faster Websites by Steve Souders, 11:35 AM on July 22nd
• Getting Started in Free and Open Source, by Cat Allman and Leslie Hawthorn, 11:35 AM on July 22nd
• Programmer Insecurity and the Genius Myth, by Ben Collins-Sussman and Brian Fitzpatrick, 1:45 PM on July 22nd
• Green Computing for the Little Guys with Bill Weihl, 1:45 PM on July 22nd (panel)
• Your Work in Open Source, the Numbers, by Chris DiBona, 9:15 AM on July 23rd
• JRuby on Google App Engine by John Woodell and Max Ross, joined by Ted Han, 10:45 AM on July 23rd
• The Google Open Source Update, by Chris DiBona and Leslie Hawthorn, 11:35 AM on July 23rd

If you're around Silicon Valley and can't make the entire conference, keep in mind that the Birds of a Feather sessions, OSCamp and a host of other events at OSCON are free of charge to attend with your expo hall registration. We hope to see you there!

By Leslie Hawthorn, Open Source Team

Google's Open Source Programs Office has been supporting the MetaBrainz Foundation for the last three years and has just let us know that they'll be continuing their support in 2009. The MetaBrainz Foundation operates the MusicBrainz project, which can be likened to Wikipedia for music. MusicBrainz knows which artists have released which CDs as well as where and when they were released. MusicBrainz also knows all of the tracks as well as who performed which instrument or vocals on a given track. This and many other data pieces are made available to the public and form the underpinnings of services such as audio CD identification and digital music collection cleanup tools.


Last year, Google's generous donation paid for a much needed server and it allowed us to hire our Google Summer of Code™ student (Oliver Charles) part time after the program wrapped up. The donation also helped pay for mundane things like keeping the lights on, backup disks and paying for insurance. But the most fun part that we spent money on last year was our phenomenal MusicBrainz Summit in London. Our summit allowed the community to come together and to bond face to face at the Last.fm offices. MusicBrainz paid for its Summer of Code students to come to London from Sweden, Germany and Lancaster. MusicBrainz arranged for the summit space, subsidized accommodations and provided food. But, most important was our gathering at a pub near the last.fm offices — we had fun and bonded for many hours that evening.

Holding yearly summits has been a long tradition for MusicBrainz. We're planning on having another one this year and this year's donation will certainly help make this one memorable as well!

Thanks for your continued support Google!

By Robert Kaye, Executive Director, Metabrainz Foundation

If you are in South America this week and you have been wanting to find out more about Google's Open Source activities or the future of Open Source and its communities, Chris DiBona and Leslie Hawthorn from the Google Open Source Programs Office will be speaking at the tenth annual Fórum Internacional Software Livre (FISL) in Porto Alegre, Brazil.

Leslie will be presenting tomorrow, June 24th, 1 PM local time about Google Summer of Code™, and she'll be staying afterward to meetup with Google Summer of Code participants who are in the area. On June 26th at 2 PM, Leslie will be presenting "Community Management Basics" and how to make FLOSS projects and communities welcoming for new contributors.

Chris' first talk, "Open Source: Then, Now and Tomorrow" takes place on June 26th at 3 PM local time. In addition to the past, present, and future of FOSS, Chris will discuss how Google uses and releases Open Source software. In Chris's second talk, "An Introduction to Android" at 5 PM on the 26th, he will explain the ideas and structure behind the Open Source mobile operating system Android.

All four talks are great opportunities to learn more about Google and Open Source. Come ask questions and get to know members of the Open Source Team!

by Ellen Ko, Open Source Team