Google Summer of Code is an open source program that is managed by Google's Open Source team.

They invite developers to spend their summer contributing to the source code for various different organisations taking part in the program.

There are many organisations that list their project ideas for participants to choose from. Last year, in the 2022 season, a whopping 202 different organisations took part in the program and the program ended with around 1166 projects being completed.

Think about the sheer amount of code that was written and how much open source organisations and users in general benefited from it. You can learn more about last season here.

I was among those contributors, writing code for the TUF project. My work involved introducing backwards compatibility to TUF's Python client so that downloading metadata adhering to different tuf versions could be easily managed.

I am writing this tutorial to teach you about GSoC and how you can increase your chances of getting selected into the program. I'll also go over how it'll benefit you both from a learning and a career perspective. I hope it will get you inspired enough to contribute to open-source and apply for GSoC, even if you've never done that before.

GSoC Timeline

GSoC follows a similar timeline every year. You can find the page for the 2023 session here.

The page pretty much explains all you'll need to know, and you can find the precise dates for each announcement. But still, I'll share my tips on how to prepare for each step of the journey and the best courses of action to take along the way.

The first 3 announcements are org-specific. Meaning, you don't have to worry about them since they are dates for organisations to apply to have their projects included as part of the GSoC program.

List of Accepted Mentoring Organizations Published:

Once the orgs get announced, start going through the list and take a look at the project ideas that seem interesting to you.

Don't target too many orgs. Try to go for a maximum of 2 or 3 project ideas within the same org. This makes you drive your efforts towards participating in that org and that really boosts your chances of getting selected.

Targeting too many orgs divides up your efforts and it may result in you not getting admitted into the program.

Org search page

Filter through the orgs by entering your preferred programming language/org name/topic in the search bar. Once you open up an org's page, you'll be able to find the technologies and topics mentioned. Let's take a look at CNCF's page:

CNCF GSoC page

Here you can see all the different technologies and topics. Don't be discouraged if you don't know all of the tools, since those lists are for all the project ideas mentioned under the org (so there's a high chance that your particular project won't require all of them). Plus since the program is a learning experience, you'll be learning those topics yourself.

Click on the Ideas List next, and you'll be taken to a page that will show you all the different project ideas under that org. This is where you get to read through the description for each project and look at the tech stack for each one.

You might find the Difficulty label under your project, but don't get disheartened if a project you find interesting is labelled hard. You can always learn on the go and implement what you learn. Chances are that you'll have to work a bit harder, but that's ok.

Also under the project idea, you'll find the upstream repository and/or the upstream issue's page. Check it out and start reading the repository docs and all the other info.

Now you might be thinking – where would you go if you had any questions? Go back to the org's page on the GSoC website and you'll find links for the organisation's mailing list, public Slack channel, and Twitter among various other links.

If you can't find this info there, then go to the repository's page and you'll probably find links for the communication channels in the Readme file there.

After joining the public channel, introduce yourself over there and express your excitement to contribute to the project.

When you're asking questions, here are some thing to keep in mind. First of all, make sure you do your research by searching about your question online and then asking your question saying: "Hey, I have this problem. I did x research about this and came up with y answer though I think it may not be correct. I'd appreciate it if someone could help me, thanks."

Phrasing your question like this shows to other people that you've thought about your question and tried searching about it online and you haven't just given up and not thought about the problem. People are then more likely to help you.

Many times, if your question is a pretty common one, you'll get the actual answer online. Also, with the proliferation of AI tools, there's a pretty high chance that you'll find what you need. If not, go ahead and ask your question.

Also, always try not to personally message someone. Ask your questions in the public channels. This way you have many people looking at your problem and so the chances of you receiving help increases. Personally messaging someone doesn't always guarantee a response since they're probably busy with their own work. So you asking a question with no one else to answer adds onto that work.

GSoC Contributor Application Period Begins:

As a contributor, you'll have to form a proposal for your particular project idea within a deadline.

For the 2023 session, contributor proposals start getting accepted from the 20th of March until the deadline on the 4th of April. Start working on your proposals beforehand and don't wait until the submission deadline.

Here are a few tips from my side:

Start the review process early

It's totally fine to ask your mentor to review your first draft of the proposal – but try to start the review process as early as possible. Implement your mentor's suggestions and then ask for reviews again.

While doing that, be respectful of their time. They might not always be available, and in that case, try to get feedback from other maintainers working on the project.

Always keep in mind that the maintainers are people who have a seperate work-life and that they're working on the project in their own free time.

Create a timeline

A good proposal is an important aspect of the selection process. This page has some good info regarding the subtopics you should mention.

Make sure that you formulate a proper Timeline (Deliverable section) since that shows the mentor and maintainers that you've really thought about the project and how you aim to solve it. The actual dates of when you would implement something don't really matter – it's more about how you've thought about solving the project.

Personally speaking, creating a timeline made a big impact on my selection process since my mentor mentioned multiple times that she liked the way I had thought about implementing the project.

This really goes to shows that you've thought about the problem hard enough to come up with an approach toward solving it.

Contribute to the project's repository

Contribute and work on issues in the project repository. They don't need to be big changes, but make sure they aren't only trivial ones either (like fixing grammar, deleting files, and so on).

As you start contributing, start from easy issues and keep ramping up as you keep getting the grasp of the project. If you're someone who's new to all this then understand that the first step is usually the hardest and the upcoming ones are comparetively less difficult.

When formulating your proposal, be sure to mention these prior contributions as they help make your proposal much more impactful. They also show your mentor that you are someone who has been contributing to the project.

Talk about past experience

Include a passage about your past work experience and achievements (Biographical Information section). Mention work for which you have evidence as that helps add value to your proposal. Include any past open-source or hackathon or application building experience.

Try to rank these experiences in order of relevance to the project and try not to overfill this section if you have too many. Keep it to a max of 8-10.

In addition to all these points, I suggest you to go through the page mentioned above and study the remaining points to get a good idea of what you should be mentioning in your proposal.

Once you're done formulating a proposal, create your own GSoC account and go to your contributor page. There you'll find the link to select the project you'll be working on and the link for submitting the proposal.

In all, focus on 3 major key points while applying:

1. Have good code contributions to the project repository
2. Have a high-quality and well-reviewed proposal
3. Be active in the community by engaging with other contributors and participants

There were a few changes that got implemented in the 2022 session which are here to stay. They are:

• Flexible project timing. You could take anywhere from 10 to 22 weeks to complete your project. Extend your deadline if you feel that the 12 week period is not enough, but make sure to communicate with your mentor about this.

• Choice of time commitment. You'll have a choice between either a medium or long project.

• Open to all. GSoC as a program was open only to students until its 2021 season. But ever since the 2022 season, the program has started accepting everyone, student or not. Anyone looking to get into this program can get started.

The application deadline for the 2023 season is on the 4th of April, and you'll be hearing back on the 4th of May.

I know, a month seems like a long time and you'll probably be getting anxious as the result date approaches. I know I was. If you do get selected, congratulations to you and your hard work.

But if you don't, don't get disappointed since you've probably learnt so much about open-source through the process. And now you can work towards submitting your application for other open-source mentorship programs. This page has some great info about all the other programs.

Why You Should Do GSoC

So far, we've talked about the timeline and how to prepare your proposal. Now let's talk about the why.

Why should you be interested in this program and in open source in general? Let's start by talking about open source.

Why Open Source?

Working on Open Source software is a great way to help the broader community by contributing to projects that are used by millions of people around the world. The work that you put in helps improve software that is an important part of many large scale systems.

Also the fact that almost all open source software is free makes it way for everyone to use it in their daily lives, be it large organizations or an everyday user. So devoting time from your busy life to work on OSS is a great and commendable feat.

All of this sounds awesome, but how does contributing to open source help you sustain yourself? Working on open source allows you to obtain industry level experience. You'll learn what it's like to actually work on large projects.

Being a contributor myself, I've had the pleasure of getting to know so much about how to actually work on changes. There are many factors that come in to play such as downloading the source code, adding changes to the code, running tests, testing out the changes manually by building a binary, pushing the changes, and so on. So much to learn.

Being a college student myself, I didn't have to wait for a job to learn about the industry. All I had to do was work hard and contribute to open source projects.

Here are some excerpts from The Linux Foundation's 10th Annual Open Source Jobs Report that might inspire you:

According to 93% of the hiring managers surveyed, open source talent is increasingly difficult to find. As a result, companies are now turning towards training their staff in new cloud automation, orchestration, and developer productivity tools to close that gap as much as possible

The vast majority of employers (93%) report difficulty finding sufficient talent with open source skills. This trend is not going away with nearly half (46%) of employers planning to increase their open source hiring in the next six months, and 73% of open source professionals stating it would be easy to find a new role should they choose to move on.

The report goes on to talk about how companies are willing to offer greater compensation to open source professionals and how financial incentives are making a much bigger difference. I'd recommend you to read and download the report to get a much more detailed description.

All in all, open source is a great way for you to learn and obtain real world knowledge and also provide you with skills that will help you to get an edge in this competitive job market.

How Does GSoC Help?

We talked about the benefits of open source and how it helps you learn a lot of real world skills. Now the question arises – how does GSoC play a role in this?

Working on a repository and contributing code is great, but it can seem really daunting. Under a mentorship program like GSoC, you get to work on a project idea with the help of a guide who's an experienced mentor. They'll help you throughout the entire process. This over a period of 3 months or more really boosts your skills and makes you a much better developer than you were previously.

You'll develop a lot of new skills all while learning to code in a team. Your code contribution helps the project grow, too, since you'll be working on implementing various important features. This benefits both the project and the open source community in general.

When I was participating in GSoC, I learned a lot about collaboration, good code practices, working with Git and so much about testing. I got to understand async practices and how to communicate my developments with my team, even if we were time zones apart.

I was responsible for the code that I put in and delivering the work that was expected of mel. I believe that this really helped me to grow as a person and become a better developer.

I also got to learn so much about what it actually was to work in a real life project and gain so much industry level experience from such talented professionals. This became an experience that I will always cherish.

Through this program you get introduced to the world of open source and get to meet and network with amazing developers who are going the extra mile to keep open source software free and available to all. You're introduced to a wonderful community of like-minded and passionate developers who are extremely welcoming and are willing to help other budding developers.

You also get sponsored while you work on writing code for such organisations which I believe is a great plus point too. All of this makes contributing to Open Source via GSoC an amazing learning experience which I believe every developer should get to enjoy.

Thanks for reading!

That's it for now! If you've decided to apply for GSoC, good luck. I hope you enjoy the process, learn a lot, and have fun contributing to open source.

In this tutorial, I’ll be using python to scrape data from the Google Summer of Code (GSoC) archive about the participating organizations from the year 2009.

My Motivation Behind This Project

While I was scrolling through the huge list of organisations that participated in GSoC’18, I realised that exploring an organisation is a repetitive task - choose one, explore its projects, check that if it has participated in previous years or not. But, there are 200+ organizations, and going through them all would take a whole lot of time. So, being a lazy person, I decided to use python to ease my work

Requirements

• Python (I’ll be using python3.6, because f-strings are awesome ?)
• Pipenv (for virtual environment)
• requests (for fetching the web page)
• Beautiful Soup 4 (for extracting data from the web pages)

Building Our Script

These are the web pages which we are going to scrape:

1. For the years 2009–2015: Link
2. For the years 2015–2018: Link

Coding Part

_[GIF from Giphy](https://giphy.com/gifs/nascar-owen-wilson-daytona-500-xTiN0GMUaOI726QYZa" rel="noopener" target="blank" title=")

Step 1: Setting up the virtual environment and installing the dependencies

virtualenv can be used to create a virtual environment, but I would recommend using Pipenv because it minimizes the work and supports Pipfile and Pipfile.lock.

Make a new folder and enter the following series of commands in the terminal:

pip install pipenv

Then create a virtual environment and install all the dependencies with just a single command (Pipenv rocks ?):

pipenv install requests beautifulsoup4 --three

The above command will perform the following tasks:

• Create a virtual environment (for python3).
• Install requests and beautifulsoup4.
• Create Pipfile and Pipfile.lock in the same folder.

Now, activate the virtual environment:

pipenv shell

Notice the name of the folder before $ upon activation like this:

(gsoc19) $

Step 2: Scraping data for the years 2009–2015

Open any code editor and make a new python file (I will name it 2009–2015.py). The webpage contains the links for the list of organizations of each year. First, write a utility function in a separate file utils.py which will GET any webpage for us and will raise an Exception if there’s a connection error.

Now, get the link of the web page which contains the list of organizations for each year.

Webpage preview

For that, create a function get_year_with_link. Before writing the function, we need to inspect this webpage a little. Right-click on any year and click on Inspect.

Note that there’s a <ul> tag, and inside it, there are

The tasks performed by this function are in this order:

1. Get the MAIN_PAGE, raise an exception if there’s a connection error.
2. If the response code is 200 OK, parse the fetched webpage with BeautifulSoup. And if the response code is something else, exit the program.
3. Find all the <li> tags with class mdl-list__item mdl-list__item — one-line and store the returned list in years_li.
4. Initialize an empty years_dict dictionary.
5. Start iterating over the years_li list.
6. Get the year text (2009, 2010, 2011,…), remove all \n, and store it in the year.
7. Get the relative link of each year (/archive/gsoc/2015, /archive/gsoc/2016,…) and store it in the relative_link.
8. Convert the relative_link into the full link by combining it with the HOME_PAGE link and store it in full_link.
9. Add this data to the year_dict dictionary with the year as key and full_link as its value.
10. Repeat this for all years.

This will give us a dictionary with years as keys and their links as values in this format:

{  ...  '2009': 'https://www.google-melange.com/archive/gsoc/2009',  '2010': 'https://www.google-melange.com/archive/gsoc/2010',  ...}

Now, we want to visit these links and get the name of every organization with their links from these pages. Right-click on any org name and click on Inspect.

Note that there’s a <ul> tag with class mdl-list, which has

The tasks performed by this function are in this order:

1. Get the org list page, (https://www.google-melange.com/archive/gsoc/2015, https://www.google-melange.com/archive/gsoc/2016, ….), raise an exception if there’s a connection error.
2. If the response code is 200 OK, parse the fetched webpage with BeautifulSoup. And if the response code is something else, exit the program.
3. Find all the <li> tags with class mdl-list__item mdl-list__item — one-line and store the returned list in orgs_li.
4. Initialize an empty orgs_dict dictionary.
5. Start iterating over the orgs_li list.
6. Get the org name, remove all \n, and store it in the org_name .
7. Get the relative link of each org (/archive/gsoc/2015/orgs/n52, /archive/gsoc/2015/orgs/beagleboard,…) and store it in the relative_link.
8. Convert the relative_link into the full link by combining it with the HOME_PAGE link and store it in full_link.
9. Add this data to the orgs_dict with the org_name as key and full_link as its value.
10. Repeat this for all the organizations for a particular year.

This will give us a dictionary with organizations’ names as keys and their links as values, like this:

{  ...  'ASCEND': 'https://www.google-melange.com/archive/gsoc/2015/orgs/ascend',

'Apache Software Foundation': 'https://www.google-melange.com/archive/gsoc/2015/orgs/apache',  ...}

Moving ahead, we want to visit these links and get the title, description, and link of each project of each org for each year (?). Right-click on any project’s title and click on Inspect.

Again, the same pattern. There’s a <ul> tag with class mdl-list which contains the

The tasks performed by this function are in this order:

1. Get the org’s description page, (https://www.google-melange.com/archive/gsoc/2015/orgs/ascend, https://www.google-melange.com/archive/gsoc/2015/orgs/apache, ….), raise an exception if there’s a connection error.
2. If the response code is 200 OK, parse the fetched webpage with BeautifulSoup. And if the response code is something else, exit the program.
3. Find all the <li> tags with class equal to mdl-list__item mdl-list__item — two-line and store the returned list in projects_li.
4. Initialize an empty projects_info list.
5. Start iterating over the projects_li list.
6. Initialize an empty dictionary proj_info in each loop.
7. Get the project’s title, remove all \n, and store it in the proj_title .
8. Get the relative link of each project (https://www.google-melange.com/archive/gsoc/2015/orgs/apache/projects/djkevincr.html, ….) and store it in the proj_relative_link.
9. Convert the proj_relative_link into the full link by combining it with the HOME_PAGE link and store it in proj_full_link.
10. Store the project’s title, description and link in the proj_info dictionary and append this dictionary to the projects_info list.

This will give us a list containing dictionaries with the project’s data.

[  ...  {    'title': 'Project Title 1',    'description': 'Project Description 1',    'link': 'http://project-1-link.com/',  },  {    'title': 'Project Title 2',    'description': 'Project Description 2',    'link': 'http://project-2-link.com/',  }  ...]

Step 3: Implementing the main function

Let’s see the code first:

The tasks performed by this function are in this order:

1. We want to have a final_dict dictionary so that we can save it as .json file.
2. Then, we call our function get_year_with_link(), which will return a dictionary with years as keys and links to the list of organizations as values and store it in year_with_link.
3. We iterate over the dictionary year_with_link.
4. For each year, we call the function get_organizations_list_with_links() with the link for it as the parameter, which will return a dictionary with organizations’ name as keys and links to the webpage containing information about them as values. We store the returning value in final_dict, with year as keys.
5. Then we iterate over each org for each year.
6. For each org, we call the function get_org_projects_info() with the link for the org as parameter, which will return a list of dictionaries containing each projects’ information.
7. We store that data in the final_dict.
8. After the loop is over, we will have a final_dict dictionary as follows:

{    "2009": {        "Org 1": [            {                "title": "Project - 1",                "description": "Project-1-Description",                "link": "http://project-1-link.com/"            },            {                "title": "Project - 2",                "description": "Project-2-Description",                "link": "http://project-2-link.com/"            }        ],        "Org 2": [            {                "title": "Project - 1",                "description": "Project-1-Description",                "link": "http://project-1-link.com/"            },            {                "title": "Project - 2",                "description": "Project-2-Description",                "link": "http://project-2-link.com/"            }        ]    },    "2010": {        ...    }}

9. Then we will save it as a json file with json.dumps .? ?

Next Steps

Data for the years 2016–2018 can be scraped in a similar manner. And then python (or any suitable language) can be used to analyze the data. Or, a web app can be made. In fact, I have already made my version of a webapp using Django, Django REST Framework and ReactJS. Here is the link for the same: https://gsoc-data-analyzer.netlify.com/

All the code for this tutorial is available on my github.

Improvements

The running time of the script can be improved by using Multithreading. Currently, it fetches one link at one time, it can be made to fetch multiple links simultaneously.

About Me

Hi there.

I am Vaibhav Gupta, an undergrad student at Indian Institute of Information Technology, Lucknow. I love Python and JS.

See my portfolio or find me on Facebook, LinkedIn or Github.

This article is a quick summary of my experience participating in and completing Google Summer of Code 2018 (also referred to as GSoC).

What is GSoC?

Google Summer of Code is a program organized by Google to bring student developers into open source development. As the name suggests, it takes place every summer, during the months of April to August. During those months, selected students spend their summer coding for one of the several open source organizations taking part in the event.

Students can browse the list of organizations taking part in the event, with most of them having an ideas page that indicates which part of their existing projects could use some more work. Students can then submit up to three proposals to these organizations. The proposal should describe exactly what you have planned to work on over the summer, and why you should be the person to work on that.

Then, after a month long wait, the selected students are announced — and after a brief “community bonding” period, they can begin coding. Apart from the certificate of being a GSoC scholar, Google further incentivizes participation by providing a stipend to the student — varying from $6600 to $2400, depending on your location — it’s $2400 here in India.

What are open source organizations? How are they important?

_The best tools are often open source! (Image credit: [hackernoon](https://hackernoon.com/lessons-for-creating-good-open-source-software-1b7bbbc13b13" rel="noopener" target="blank" title="))

Open source organizations have the code for their product(s) on a collaboration platform, such as GitHub. The idea here is that a core team directly working for the organization will maintain the code repository (and often contribute the largest chunks of code) — while anyone else can contribute to the code, open issues with the existing product, or use the product themselves (for free, usually).

Open source organizations are the backbone of the FOSS culture, which promotes free and open source software, encourages sharing and collaboration, and tries to make software available to a wider audience by removing monetary restrictions. Some of the best products and tools out there are open source, particularly in the software development world with just about everything from popular IDEs to the programming languages themselves being open source.

Getting Selected

_We all have to start somewhere! (Image credit: [xkcd](https://xkcd.com/" rel="noopener" target="blank" title="))

Initially, since I was a freshman, I had planned to apply for GSoC at the end of my sophomore year in college — and spend the time in between sharpening my skills so as to be good enough to get selected.

Out of curiosity, I decided to browse through the GSoC organizations list a week before the proposal submission deadline to see what kind of projects was available. Interestingly enough, I found quite a few projects that I felt was not too complicated for me.

After a brief “Oh, I could try for this right now” moment, I hastily drafted three proposals for three different organizations and submitted them before the deadline. The proposal I had submitted for Zulip, an open source productivity chat application, based around improving the UI/UX of their React Native mobile app ultimately got accepted.

Most organizations select students who have previously contributed to their code base, since they would have an assurance on the quality of code these students could produce — rather than selecting solely on the basis of their proposals. The Zulip proposal guidelines explicitly asked the students to submit links pointing to their previous contributions to Zulip and other open source organizations, which was a blank for me. As a result I wasn’t particularly hopeful that I would get selected, but I decided to try all the same.

Communication with the members of the organization is crucial for GSoC. Sometimes you’ll have to go hunting for IRC channels or mail lists to establish communication. Zulip is a chat application and had a dedicated chat server for developers. I hopped on it after the proposal submission deadline and made sure to get involved in the conversation there. I solved a few minor issues, submitted a number of Pull Requests to the Zulip mobile repository on GitHub, updated them as per code review and got them merged.

Of course, there were several other students doing this too, but when the selected students were finally announced, my name was on the list. This was the single biggest achievement I had obtained so far, and I was incredibly happy.

The Coding Period

I had a wonderful time coding with the fantastic and helpful community at Zulip. My mentors were two former GSoC students — and along with the admins who carefully reviewed my code — they patiently explained the mistakes I had made, if any, and helped me shape my code to hit the standard required for it to be merged in.

Another pleasant perk of being part of Zulip was attending the week-long meetup of Zulip members. Getting to personally know the team of coders from all over the world was amazing, and was truly an experience that made me feel part of the community.

The week-long Zulip retreat was quite amazing!

In short, I can definitely say my coding skills have improved over the three months of GSoC. My git-fu (GitHub skills) — which were restricted to the basic cycle of add-commit-push — significantly improved first. I was required to rebase, reorder and split commits to get them in an order that made more sense.

The single biggest difference between contributing to an organization and a personal project is that the organization’s product is used by thousands of people around the world. The existing code base was created by someone else, and the code I contribute should be understandable to another person who might work on it in the future.

Writing clear documentation, structuring your code to meet standards, and making sure your changes does not break anything else was a truly educational experience — for a person who was used to tearing down and hastily refactoring large chunks of code to make room for new features and write little to no documentation for my hobby projects ‘till then.

Conclusion

Google Summer of Code is a great opportunity for students to work on a project that truly matters, and exponentially increase their ability as a coder and the ability to work in a large team. Of course, coming off $2400 richer is great as well :)

Going forward I will continue to contribute to Zulip, and remain a part of that community. I would strongly recommend to anyone who has a passion in coding and FOSS to apply to GSoC’19 when it is announced, as it is quite the experience to remember.