Showing posts with label GSoC. Show all posts
Showing posts with label GSoC. Show all posts

Monday, July 18, 2011

My epic internship quest

Here's the story of how I spent four months of my life locating and applying for internships.

My initial plan was simple. Spend the summer doing a research internship at a major CS university to simulate pursuing a postgraduate degree. I had been receiving contradictory advice on whether I should attend grad school or go straight to work once I finish my Bachelor's degree. I thought I would settle the issue by experiencing research first-hand.

I applied to two REU programs: the Information Trust Institute at the University of Illinois at Urbana-Champaign and the Summer Undergraduate Program in Engineering Research at Berkeley – Information Technology for Sustainability at the University of California Berkeley. I sent seven inquiries by email to professors from both programs, receiving two positive responses. I spoke with Dr. Roy Campbell, a researcher at UIUC, and Leo Meyerovich, a grad student working with Dr. Ras Bodik at UC Berkeley. I submitted my applications successfully around the middle of February, although my UC Berkeley application was a day late.

During the application period, I stumbled upon another internship opportunity I couldn't ignore. Fog Creek Software in New York, NY was looking for a summer intern to help them build tools for programmers. The idea of working in New York under the venerable Joel Spolsky was irresistible. I didn't think I had a chance, so I drafted an email of application and sent it within two days. I didn't want to waste too much time on a fantasy.

When Fog Creek contacted me to set up a phone interview, I was both surprised and elated. I solved a few programming challenges from Project Euler to prepare for the programming examination, and I tried to anticipate the interview questions. Unfortunately, I forgot about most important question, "What programming projects have you done recently?" When the interviewer asked that question, my confidence was shattered, and I slipped into panic mode. During my programming test, I forgot how to use static variables, writing some terrible C. However, I spent my next class mentally debugging it, and I rewrote, tested, and resubmitted a not obviously broken version with a brief explanation later that evening.

At the end of the interview, I was told that I would be told whether I got the job within a couple days. I didn't hear back for about a week. At the time, I thought that meant that everybody at Fog Creek was too busy to bother sending me a rejection email, but in retrospect, I was probably a finalist who wasn't ruled out until the end.

Around this time I realized that what I wanted was an industry internship, so I refocused my efforts on finding an internship with a big tech company. I started gathering links and working on my resume.

Early in March, I heard about the Cascadia Fellowship, a program that matched technical students with Seattle-based startups. I answered a couple questions and provided a statement of intent. The following week, I received a mass-mailed rejection, in error, and then a personalized request for my resume and couple programming puzzles. Everything was due the following day. However, before the deadline, they sent me another impersonal rejection email. I ignored it and submitted my code before the deadline (barely). When I hadn't heard from them for a week, I asked if the second rejection was sent in error. I never received a response.

It was late in March now, and I didn't have an offer. I had narrowed down my list of major tech companies offering summer internships to Facebook, Google, Microsoft, and IBM. I missed the unpublished deadline for the Facebook software engineering internship, so that left Google, Microsoft, and IBM. I wrote a spartan list of reasons for Google to hire me and submitted my application. I filled out Microsoft's on-rails application, and submitted that next. Finally, I answered IBM's primarily experience-related application and turned it in.

After all this, I had only to apply to one more program: the Google Summer of Code. GSoC was my ultimate fail safe. I was accepted last year, and I felt that I had the process figured out. Unfortunately, I didn't have much time left to apply; I hadn't even looked at the list of mentoring organizations when the student application period began. I had eleven days to find at least two interesting organizations, pick interesting summer projects, and submit a detailed proposal to each, plus another two weeks to convince the organizations that I could complete my chosen projects.

I chose two organizations: Learning Unlimited, producers of a sophisticated Django-based web app; and Sencha Labs, developers of the JavaScript InfoVis Toolkit. I thought that LU was a long shot, but I found the project more interesting than the JIT. I split my application time between designing a student registration system for LU and fixing bugs for JIT. I had some independent experience with JavaScript graphics, and the project I chose was well within my capability, but I got cocky. I didn't spent nearly enough time learning about the core library; I simply assumed I would get the project. I worked hard on the LU project because I wanted it more and it was far more demanding. In the end, I was rejected by both projects because I didn't focus on either one. If I had dedicated myself to either project, I would've gotten it.

After the GSoC application deadline but before the decision date, I received a surprising message from UIUC. Dr. Masooda Bashir informed me that two researchers were interested in working with me over the summer, Dr. Klara Nahrstedt and Dr. Roy Campbell. Dr. Nahrstedt asked me for my resume, but Dr. Campbell remained silent. I sent him an email asking what he would be working on over the summer, but I didn't receive a response.

At this point, I was frantic. I hadn't received a positive response from any of the companies I had applied to, and when I didn't receive a decision from Drs. Campbell and Nahrstedt, I assumed that I hadn't made it into the highly competitive ITI internship. I tried to start over, looking for less exclusive internships, because I didn't want to waste my summer taking classes.

It was the beginning of May now. I had almost given up, but I decided to ask Drs. Campbell and Nahrstedt for final decisions. When I asked them whether they were still interested in working with me, Dr. Nahrstedt told me that I hadn't made the cut, but Dr. Campbell responded with an enthusiastic "Yes!" It was almost too late to file the paperwork, but Dr. Bashir came through for me. I received the official offer letter May 4.

Now, I've spent half my summer working at the University of Illinois at Urbana-Champaign, and I couldn't be happier. You could say that all my hard work paid off, or you could say that I got lucky at the last second. Either way, I'm just happy that I won't have to submit any more applications until the fall.

Monday, May 10, 2010

GSoC project status update

Now that I've finished this semester's final exams, I've started working on my GSoC project: porting OI to uClibc, the featherweight C standard library. I'll post project updates periodically, saying what I'm doing and relaying what I've learned. I promise they won't all be this boring.

The first step of my project is adding my new architecture, Linux based on uClibc, to dpkg, the foundation of the Debian package management system. dpkg plays a part in packaging code, installing applications, and compiling binary packages; it's a very important tool. Before I start modifying dpkg, I plan to learn about dpkg and the relevant build systems; I'm starting by reading the Debian New Maintainer's Guide.

Thursday, May 6, 2010

I'm a GSoC student!

After months of hard work, I was chosen by the OpenInkpot organization to port OI to uClibc. I will be spending my summer reducing the memory OI consumes to allow it to run on e-readers with little memory. If you're curious about the Google Summer of Code, check out the official FAQ.

Friday, April 9, 2010

Port OpenInkpot to uClibc

This GSoC proposal is for OpenInkpot, a Debian-based e-reader OS.

Project proposal

I plan to port OpenInkpot to the lightweight uClibc C library in order to improve its memory usage. Here are some of the other benefits this project could provide.

Possible benefits

  • Increase number of devices on which OI could run
  • Improve performance
  • Decrease compile time
  • Reduce firmware transfer and installation time
  • Simplify porting OI to other architectures

Plan of action

Follow these instructions for porting IPLinux to a new architecture.

  1. Acquire target device (my own e-reader!)
  2. Add new architecture identifiers (uclibc and ucarmel) to dpkg.
  3. Build and package toolchain for new arches.
    • Cross-compile existing packages to new arches with toolchain, starting with most important packages
    • Build and test firmware once the necessary packages (uClibc, dpkg, and BusyBox) have been packaged
    • Test packages on device with chroot
  4. Test complete firmware and allow autobuilders to start porting packages to new arches

Background

Programming experience

I've been programming for about two years. I've primarily used five programming languages: Javascript, PHP, ActionScript 3, Python, and C++. I've finished several small independent programming projects, but two in particular have taught me important lessons.

Last fall, I created an example game for Pygame2, a low-level Python wrapper for SDL. The game ran, but it was worthless as an example because my clumsy graphics abstraction obscured the underlying Pygame2 graphics calls. From this failure, I learned to never lose sight of the purpose of my project. My initial announcement for the flawed example.

Earlier this year, I decided to rewrite my Flash app for drawing snowflake patterns with Javascript and SVG. Once I chose the right data structure, the whole library fell into place. This project taught me that few programs must be complex; with enough thought, you can find a simple solution to many complicated problems. Read more about the SVG snowflake micro-library.

Personal qualities

I'm hard-working
When I am assigned a task, I feel compelled to do it as well as I can. I find it difficult to walk away from an unfinished task.
I'm self-motivated
Events in my life have taught me to work independently and seek out my own answers. When I discover a problem I don't know how to solve, I start looking for a solution. I check any relevant manuals, search for tutorials, look for examples, and — if I still haven't found a solution — ask for help. Finding answers on my own gives me a feeling of satisfaction and accomplishment.
I love programming
Writing code is my favorite hobby, and I will someday make it my profession. I'm not participating in the Google Summer of Code because I really need the money or I want another bullet point for my resume; I'm participating because I want to create software and learn more about software development.

Open-source experience

In addition my recent OI patch, I've spent some time working with Pygame2. While developing an example game with the unstable development version, I found, isolated, and reported several bugs.

GNU/Linux distributions development experience

I've used Ubuntu for about a year, learning much about Linux and Debian. I've become proficient at finding, installing, and upgrading Debian packages. I packaged my first .deb and started my own repository in order to test my fix for Ticket #834. I've compiled my share of source code, and I'm familiar with the GNU build system as both a user and a developer. I've written several bash scripts, and I'm comfortable with the major Unix commands and concepts. I've even spent some time configuring and troubleshooting the GRUB bootloader.

Kernel hacking

Unfortunately, I haven't worked on the Linux kernel yet.

Replace dap-server WWW Interface

Below is my GSoC proposal to OpenDAP, the developer of a scientific data server. You can see the official proposal here.

Have you contributed to any open source projects in the past? If so, which ones?

I've worked two open-source projects other than OpenDAP: Pygame2, a low-level Python SDL wrapper library; and OpenInkpot, a Debian-based e-reader OS. While developing an example game with Pygame2, I found, isolated, and reported several bugs. In preparation for my OpenInkpot GSoC application, I added a feature to OpenInkpot, closing Ticket #834.

What are your other summer plans?

I plan to go on a vacation with my family for a week or two. I'm not taking any college courses, and I have no other commitments.

Where are you going to school?

I've graduated with highest honors from Broward College with an Associate in Arts degree, but I'm still picking up some prerequisite classes before I transfer. I plan to pursue a BS in Computer Science at the Massachusetts Institute of Technology, the University of Florida, or another school — I haven't decided yet.

Have you used any of our software in the past? If so, which?

My first experience with your software was installing Hyrax from source (from this branch.)

What experience do you have that's relevant to your project?

Code

I've been programming for two years. Writing code is my favorite hobby, and one day, it will be my profession. I love to develop software, and I read everything I can to improve my skills.

Examples

Javascript
Javascript snowflake SVG micro-library
JSON Javascript slideshow
C++
I've taken a college course on C++, and I've read Effective C++, but I haven't published any C++ code yet. If a code sample is required, I could send you one of my class projects.
Shell scripting
OpenInkpot patch
Several system utilities for my personal use

Website creation

I've developed more than ten commercial websites from the ground up. I'm proficient in (X)HTML and CSS, and I'm comfortable with SVG. I enjoy creating simple, usable websites.

Examples

Software development

I've been developing software on Ubuntu for about a year. I've compiled several applications from source, and I'm familiar with the GNU build system as both a user and a developer. I'm comfortable using the major Unix commands and chaining them together into useful shell scripts. I've used both SVN and Git to retrieve and commit code. I have all the necessary skills to collaboratively develop software.

Project proposal

I plan to replace the dap-server WWW Interface with a more intuitive data request form.

Plan

  1. Remove WWW Interface from dap-server
  2. Create new BES module for generating data request forms
  3. Design intuitive HTML form for constructing data request URLs
  4. Write server-side form generator
  5. Write Javascript to read user input, construct request URL, and send data request
  6. If I have extra time:

    1. Write server-side data request generator to improve accessibility
    2. Add JSON format to dap-server to simplify Javascript metadata access

Goals

  • More logical, easier-to-use interface
  • Simpler, more readable code due to separation from dap-server
  • Greater accessibility with semantic XHTML form

Execution

  1. BES receives request for data specification form
  2. Request is sent to form-generation module
  3. Module generates data-specific data request form
  4. Form is sent to user
  5. User specifies desired data through form
  6. Javascript constructs data request URL
  7. User clicks on generated link
  8. BES receives data request and sends it to dap-server
  9. dap-server returns requested data

Why not Ajax?

  • Server-side caching
  • Greater speed
  • Fewer HTTP requests
  • Easier to implement

Sunday, March 14, 2010

InstaPyGame progress report

I spent the last three days working on a prototype "space shooter" module for my InstaPyGame framework. I had hoped to have a prototype ready today, but the framework isn't usable yet. You can see my progress so far at my Google Code repository, but be warned; the code is messy and inconsistent, and nothing is set in stone.

However, I have created an API with which I'm satisfied. Making the sample below work properly is my goal for this prototype.


from insta.spaceshooter import *

def startDemo():

    game = Game(640, 480)
    
    player = Player()
    player.setSprite('resources/ship.gif')
    
    player.when(player.moving, 'left').setSprite('resources/bankingleft.gif')
    player.when(player.moving, 'right').setSprite('resources/bankingright.gif')
    
    shot = Shot()
    shot.setSprite('resources/shot.gif')
    
    player.setAmmo(shot)
    
    enemy = Enemy()
    enemy.setSprite('resources/alien.gif')
    
    boss = Enemy()
    boss.setSprite('resources/angryalien.gif')
    
    mapGen = LevelMapGenerator({'0' : None, '1' : player, '2' : enemy, '3' : boss})
    
    level = Level(mapGen.generate('data/levelmap1.txt'))
    level.setBGSprite('resources/space.gif')
    level.setBGMusic('resources/spacemusic.ogg')
    
    game.setLevels([level])
    game.start()

if __name__ == '__main__':

    startDemo()

Right now, I'm working on the event system and the controls, but the event system appears far more challenging. I'm planning to encapsulate the data for the "Player" and "Enemy" objects within another object, protecting the data behind its member functions. This should allow me to create a special data object that will apply its changes only when a condition is fulfilled.

Although the framework is far from complete, I'm excited about the possibilities. I have plenty of work ahead of me, but I think my goal is worth the effort.

Sunday, March 7, 2010

GSoC project idea: Insta-PyGame

I'm still trying to choose new GSoC organizations to join, but I know one of the organizations to which I'll apply: PyGame, the SDL-based Python multimedia library. I plan to write a micro-framework on top of PyGame to dramatically simplify the creation of conventional games.

The Problem

PyGame is a wrapper for the C SDL library. Some of the library hides the complexity of the underlying SDL library, but in most areas, PyGame is simply a Python binding for SDL. For that reason, you often need to write several lines of code to accomplish a simple task, such as checking whether the user has pressed a button. In addition, many pieces of the API are based on C coding idioms that are unfamiliar to most Python programmers.

The Plan

I propose the development of a new framework on to of PyGame that operates at a much higher level of abstraction. Through this new framework, people would create games by declaring the sprites the characters use, the arrangement and graphics of the levels, and the interactions between the player and the contents of the levels.

The framework would be divided into modules with each module representing a genre. The "platformer" module would contain everything necessary to create a platformer game, including a physics engine, a tile map engine, and enemies that die when you jump on them. In contrast, the "scrolling shooter" module would contain tools for controlling the behavior of projectiles and enemy ships.

Here's an example of the type of code games using the framework could look like. I haven't put much thought into the API, but I would like game code to be written at this level of abstraction.


from insta.menu import *

from insta.platformer import *



def startMenu():

    titleScreen = Screen(600, 400)
    titleScreen.setTheme(themes.MEDIEVAL)
    titleScreen.setTitle("Porcupine's Tiny Adventure")
    titleScreen.setOptions(["Play", "Controls", "Credits"])
    titleScreen.getOption("Play").setAction(startGame)
    # More code for other menu options

def startGame():

    game = Game()

    hero = Player()
    hero.setSprite("standing.gif")
    hero.setRunningSprites(["running1.gif", "running2.gif", "running3.gif"])
    hero.setJumpSprite("jumping.gif")
    hero.setDeathSprite("gravestone.gif")

    hero.setMovementTriggers(constants.ARROW_KEYS)
    hero.setJumpTrigger(constants.SPACE_BAR)

    goal = Item()
    goal.setSprite("bigring.gif")
    goal.setBehavior(constants.FLOATING)
    goal.setAction(game.nextLevel)

    itemGenerator = ItemGenerator([None, goal, hero])

    '''
    Tile generator translates level maps (text files full of numbers) into tile
    maps in a context-sensitive manner
    '''
    tileGenerator = TileGenerator()
    tileGenerator.setFloorSprite("levelground.gif")
    tileGenerator.setUndergroundSprite("underground.gif")
    tileGenerator.setPlatformSprite("platform.gif")
    # Edge and corner sprites could also be set

    mushroom = Enemy()
    mushroom.setRunningSprites(["step1.gif", "step2.gif"])
    mushroom.setDeathSprite("explosion.gif")
    # Some simple behaviors would be pre-defined
    mushroom.setBehavior(constants.WALKING)

    bird = Enemy()
    bird.setFlightSprites(["flap1.gif", "flap2.gif"])
    bird.setDeathSprite("feathers.gif")
    bird.setBehavior(constants.FLYING)

    # List associates enemy types with numbers in the text file
    enemyGenerator = EnemyGenerator([None, mushroom, bird])

    level = Level()
    level.setTileMap(tileGenerator.generateTileMap("levelmap1.txt"))
    level.setEnemyMap(enemyGenerator.generateEnemyMap("enemymap1.txt"))
    level.setItemMap(itemGenerator.generateItemMap("itemmap1.txt"))

    level.setBackground("background.gif")
    level.setBackgroundOptions([constants.TILED, constants.PARALLAX])

    game.setLevels([level])
    game.start()

if (__name__ == "__main__"):

    startMenu()

The Goal

I want to free PyGame developers from thinking about the hows of game development, allowing them to focus on the whats of their ideas. By freeing game creators from thinking about the implementation of their games, I hope to allow them to explore new ideas in video game design, such as dynamically-generated levels, media mashups, user-created content, and AI.

This is just a rough outline of the framework I'd like to build and the effects I hope to see. I plan to start work on a prototype soon if the PyGame community appears receptive to my idea.

Thursday, May 28, 2009

Google Summer of Code application tips

I have been meaning to write about my Google Summer of Code experience since I learned of my rejection, but I've only now found the free time to finally do it. For those who haven't heard about it, the Google Summer of Code is a program in which Google pays students $4500 to work on open source projects over the summer. (More info.) I learned about the Google Summer of Code on March 23, the first day that applications were being accepted. For the 28 days until the winners were announced, I devoted my life to perfecting my proposals, socializing with the mentoring organizations, and fantasizing about the immense heft that "GSoC student" would carry on my application to MIT.

Unfortunately, I simply wasn't good enough. I had only about 1.5 years of programming experience (none with open source projects), I was a freshman at Broward College, and I made several mistakes on my applications.

However, although I couldn't affect my programming experience or my enrolled college, I certainly could've improved my applications. Below, I've compiled a list of tips that I picked up from numerous IRC conversations, mailing list posts, and direct emails to mentoring organizations. Learn from my mistakes and net yourself that $4500 next summer!

Think inside the box

Although most of the Google documentation on the Summer of Code implies that each organization's ideas list is simply a loose guideline, you should write your proposal on a project explicitly listed on your target organization's ideas list. Resist the urge to set yourself apart from the crowd by proposing something new and revolutionary. Mentoring organizations carefully choose only the most useful projects to be listed on their ideas lists; you are unlikely to think up a project more important than the ones they chose.

Use all available tools

On the same day that I learned of my rejection, I stumbled across this invaluable resource page for GSoC applicants. It has a categorized list of mentoring organizations, a search engine for mentoring organizations, and tons more useful info. Even if the information isn't updated for GSoC 2010, it should still give you a good starting point in your search for a mentoring organization.

There's no safety in numbers

No canned applications! Sending out several generalized proposals will only waste the time you could be spending on your serious applications. You should use all your available time writing targeted, high-quality applications to specific organizations; spamming twenty organizations with your resume is simply a waste of your time and theirs.

Be professional

Don't crack any jokes unless you personally know the proposal reviewer at your target organization. When I wrote an application to Sunlight Labs in which I included one irrelevant but humorous fact and several corny lines, the proposal reviewer thought that the entire application was a joke. I promptly assured him that my proposal was in fact serious, but the damage was done.

Do the work

Unless you want a quick rejection, you should comply with all of your target organization's application requirements. If they ask you to fix a bug, you should actually fix one of their bugs, not just make a patch that somebody else suggested. If you can't dive headfirst into the development of your organization's project, you should probably find another organization. Nothing will get you rejected faster than an hole in your proposal.

Choose wisely

Only apply to organizations you know something about. Although the temptation is strong to apply to some of the obscure supercomputing or AI organizations, you can be sure that there's a bored Computer Science grad student ready to put your proposal to shame. If an organization doesn't get enough skilled students for their projects, they will return their slots to Google. However, if you apply to work on a small project you think you can handle, but the organization doesn't have enough slots for you, they might get one of the surplus slots from another organization. You have a much greater chance of success when you shoot for a project at your level.

Start now

From what I've seen, the majority of accepted Google Summer of Code students had participated in their organization before they even knew about the GSoC. The best way to increase the probability of your acceptance is to be involved in the organization before you apply to work with them. Organizations want to give their slots to students who will complete their projects over the summer and stick with them after the money stops. There's no better way to prove your commitment than to be committed, so find a project that interests you and jump in.