The DO’s and DON’Ts of Google Summer of Code: Student Edition

As Google Summer of Code mentoring organization administrators, we are the people who ensure Google Summer of Code runs smoothly within our organizations. Over the past 6 years, contributors to our four open-source projects (Gentoo, KDE, XMPP, and X.Org) have read more than 1,000 student applications and mentored hundreds of successful, and unsuccessful, students.

Based on our experience with Google Summer of Code, we’ve built cultural and community practices that strongly favor successful student projects, integration of code, and conversion of students to long-term contributors. We’ve also seen a lot of things go wrong—repeatedly. We’d like to share these tips and antipatterns with you to raise awareness and help students avoid the same mistakes when taking part in the program. For even more advice, check out the student guide.

DO DON’T
Be on your best behavior. Clear, respectful communication is just as important to success today as it was 100 years ago. When you write email or chat on IRC, use complete sentences without any SMS abbreviations (but acronyms are allowed, especially on IRC). If you are unsure about your English skills, there are tools available to help you, such as spell checkers and grammar checkers. On a related note, people want to work with others whose company they enjoy. Be friendly and polite; it’s hard to be too much of either. Make a bad first impression: SMS speech, extremely poor English, rudeness/hostility, etc. These fall into two major categories: failure to communicate and inability to get along with other people. Poor first impressions can seriously damage your chances because both of these problems derail collaboration, which is vital to a successful project. Entirely adequate programmers fail Google Summer of Code because of failures to communicate.
Read all the documentation, so you submit a useful application. Your application should provide all the detail necessary to convince people that you can accomplish your project, and you’re the best person to do it. That means showing you have experience, proving you’ve done research, and providing a concrete plan. Submit a useless application. Many varieties of entirely unhelpful applications exist: the one-sentence wonder, the proposal pasted directly from the ideas page, the free-form text that ignores an application template, and the application submitted to the wrong organization.
Be transparent about other commitments. When organizations know about your commitments in advance, you can work with them to develop a plan that deals with your schedule. For example, you could begin your work at a slower pace during the community-bonding period. If another commitment comes as a surprise to your mentor during the summer, you might not be able to compensate for it. Disappear. If your mentor thinks you have disappeared during the summer, this tends to quickly result in failure. The most common problem is failing to mention long family vacations or class schedules in the summer. Disappearing includes taking the initial payment and running with it; if you’re tempted to do this, you might want to consider the damage to your reputation, or the excited students missing out on a slot so you can waste yours.
Make Google Summer of Code your top priority. During the 12 weeks of coding time, nothing should take precedence over your project, and you should have no major distractions. If you have another job, decide whether you prefer it or Google Summer of Code and pick one. Make your choice early enough to leave your slot open for another student. Hold another major commitment. For example, if you have a second job without telling anyone until the start of coding, it’s a major problem. Anything outside of the program that takes more than 5–6 hours a week causes problems; this includes classes that extend through the coding period. Two simultaneous full-time jobs is unrealistic.
Be realistic about your skills. Think through your past experience. If you have trouble fairly assessing your abilities, just write about your coding experience instead and your org can make its own judgment. Additionally, some orgs will gladly provide small sample tasks that you can perform to judge how easy you’ll find the summer-long projects. Over- or under-rate your abilities. As long as you have some programming skill and are able to communicate well (see above), you should be suitable for some projects. This doesn’t mean that every student is equal if they meet these requirements. Overselling yourself leads to disappointment; underselling yourself the same.
Commit and publicize your code frequently. Discussing your code early and often, with your mentor and the broader community, is vital to the success of your project. Make small, easily recoverable mistakes early rather than huge ones when it’s too late to do anything about them. Make last-minute (or later) code drops. Showing your code in public can be scary. Some students wait until the very last minute to show their code to their mentor and other contributors to the project. Do this only if you have a burning desire to fail, because it’s too late for any review to fix holes in your code.
Submit code that’s ready to integrate. The best thing about an open source project is seeing your own code shipped in a release and used by thousands or even millions of people. This requires some effort on your part, however. You should closely track how other developers change related code so yours can be easily added to the latest development branch as soon as—or even before—the summer ends. During the last few weeks, make sure your code is polished enough so it’s ready to add to the project’s main repository; this may require documentation or test suites. Don’t let your summer’s work go to waste. Finish the summer with code that’s “almost ready” but will take forever to ship. Many students leave their project in a state that is very close to being shippable but isn’t quite there yet. Since the mentor tends to be too busy to finish it, these projects ship very slowly, if ever. It’s your project—you need to make it see the light of the day. This can require you to keep driving the project, and not trust that the mentor will keep on top of it once the summer is over.
Complete your project design before writing a line of code. Work with your mentor to define the architecture of your project before you begin coding. You don’t need to go as far as prototyping every function, but you should have a vision of how it will all eventually work at a reasonable level of detail, such as important data structures and algorithms. Determine the libraries and tools you’ll use, and be able to justify your choices. Start coding before finalizing design. You can hit major dead-ends when you haven’t yet finished working with your mentor to design the project, but you choose to begin coding anyway. For example, if you start coding for a NoSQL backend but your mentor and the rest of the community determine that a standard SQL database should be used, this can necessitate rewriting a lot of code for no reason. Changes on the architectural level can be even more disruptive to any code you’ve written prematurely.
Use your resources wisely. Help is just an email away. Don’t be afraid to ask questions when you get stuck; we don’t expect you to be an expert, and we’re happy to answer your questions. On the other hand, remember to do some basic research on your own before asking, such as searching the project documentation, the source code, and Google. Refuse to ask for help. Throughout the whole program, you will encounter problems that need to be solved—some of them small and some of them large. You can waste days stuck on a problem that can be solved in an hour by talking to other team members.
Remember that you’re part of a community. Very little in Google Summer of Code is 100% independent work. You may propose your project design, but you’ll develop it with the help of your mentor and community. You’ll write the code, but others will review it, and you’ll often build upon their previous work. Unlike school, where a grade could be your first feedback, in Google Summer of Code your grade (pass/fail) is your last feedback. By designing and developing your project in collaboration with your entire open-source community, you’ll get people excited about using your work and ready to integrate it. You’ll also give yourself the best chance of passing the program by receiving thorough reviews from your community and responding to them. Many students choose to continue contributing after the summer ends because of their interactions with the community. Consider it a solo project, like it often is in college. It’s not; you write the code, but your mentor is there to help with plans, designs etc. Your mentor is not like a lecturer or course leader at a college or university. There’s a whole community of people working on the project together, and you should interact with them as a whole. Don’t feel like you’re working for your mentor, you’re working for the community and your mentor is helping guide you, they are not your only point of contact. This has other implications too—other people will be working on the code base while you are, and you will see improvements happening around you as you code. You may need to keep your development branch up to date to take advantage of these.

Making Google Summer of Code the best possible program requires a commitment to excellence from participants at every level. In addition to committing to the program, you must also be thoroughly prepared.

In this post we’ve provided suggestions for students, and in later posts in this series we’ll cover mentors and admins. Whatever role you would like to play in Google Summer of Code or a similar program, read everything you can find so you know what you’re getting into. Good luck, and have fun in your endeavors.

Best Practices for Honeycomb and Tablets

The first tablets running Android 3.0 (“Honeycomb”) will be hitting the streets on Thursday Feb. 24th, and we’ve just posted the full SDK release. We encourage you to test your applications on the new platform, using a tablet-size AVD.

Developers who’ve followed the Android Framework’s guidelines and best practices will find their apps work well on Android 3.0. This purpose of this post is to provide reminders of and links to those best practices.

Moving Toward Honeycomb

There’s a comprehensive discussion of how to work with the new release in Optimizing Apps for Android 3.0. The discussion includes the use of the emulator; most developers, who don’t have an Android tablet yet, should use it to test and update their apps for Honeycomb.

While your existing apps should work well, developers also have the option to improve their apps’ look and feel on Android 3.0 by using Honeycomb features; for example, see The Android 3.0 Fragments API. We’ll have more on that in this space, but in the meantime we recommend reading Strategies for Honeycomb and Backwards Compatibility for advice on adding Honeycomb polish to existing apps.

Specifying Features

There have been reports of apps not showing up in Android Market on tablets. Usually, this is because your application manifest has something like this:

Many of the tablet devices aren’t phones, and thus Android Market assumes the app is not compatible. See the documentation of . However, such an app’s use of the telephony APIs might well be optional, in which case it should be available on tablets. There’s a discussion of how to accomplish this in Future-Proofing Your App and The Five Steps to Future Hardware Happiness.

Rotation

The new environment is different from what we’re used to in two respects. First, you can hold the devices with any of the four sides up and Honeycomb manages the rotation properly. In previous versions, often only two of the four orientations were supported, and there are apps out there that relied on this in ways that will break them on Honeycomb. If you want to stay out of rotation trouble, One Screen Turn Deserves Another covers the issues.

The second big difference doesn’t have anything to do with software; it’s that a lot of people are going to hold these things horizontal (in “landscape mode”) nearly all the time. We’ve seen a few apps that have a buggy assumption that they’re starting out in portrait mode, and others that lock certain screens into portrait or landscape but really shouldn’t.

A Note for Game Developers

A tablet can probably provide a better game experience for your users than any handset can. Bigger is better. It’s going to cost you a little more work than developers of business apps, because quite likely you’ll want to rework your graphical assets for the big screen.

There’s another issue that’s important to game developers: Texture Formats. Read about this in Game Development for Android: A Quick Primer, in the section labeled “Step Three: Carefully Design the Best Game Ever”.

We’ve also added a convenient way to filter applications in Android Market based on the texture formats they support; see the documentation of for more details.

Happy Coding

Once you’ve held one of the new tablets in your hands, you’ll want to have your app not just running on it (which it probably already does), but expanding minds on the expanded screen. Have fun!