Top 10 Tips to Get Started with Open Source and GSoC
6 min read
Table of Contents
- 1. Choose the Right Organization
- 2. Become a User First
- 3. Start Small: Pick a Tiny Functionality
- 4. Tackle Open Issues
- 5. Communicate and Ask Questions
- 6. Focus on Consistency, Not Quantity
- 7. Learn to Navigate Large Codebases
- 8. Don’t Overlook Documentation and Testing
- 9. Sharpen Your Git Skills
- 10. Read the Code
- Conclusion
During my sophomore year, I was applying for internships daily but had no luck. Then, I read a blog that recommended contributing to open source to gain real-world experience and mentioned opportunities like Google Summer of Code (GSoC), the MLH Fellowship, and the Linux Foundation Mentorship. Intrigued, I decided to dive in.
However, I quickly felt overwhelmed by the vast number of projects with complex codebases. My initial contributions were minor UI fixes, and I didn't get selected for GSoC that year.
After a break, I returned with a better approach and eventually secured a spot in GSoC the next year.
Whether you’re aiming for GSoC or want to contribute, here are my top 10 tips for starting in open source and preparing for GSoC.
1. Choose the Right Organization
Begin by browsing through various open-source organizations. Focus on projects that align with your skills and interests. For example, if you’re into web development, look for organizations that work on web-based projects similarly, if you’re proficient in languages like Java, Kotlin, or Python, target projects that make extensive use of those languages.
One way to find these projects is by exploring past GSoC organizations and filtering them based on your area of interest.
You can also use this website to view trends of past projects and filter them by the languages used in those projects.
Ensure you’re genuinely interested in the project and that it solves a problem you care about. Aligning your interests, skills, and the organization’s needs will make the contribution process much smoother.
2. Become a User First
Open-source projects often have large and complex codebases, which can feel overwhelming at first. A great way to familiarize yourself with a project is by becoming a user. Build the project locally, explore its features, and use it like any other software. This hands-on experience will help you understand its functionality and spot areas for improvement.
For instance, before contributing to organizations like Joplin, Rocket.Chat, or CircuitVerse, I spent over a week experimenting with their projects. This not only helped me understand the codebase but also gave me ideas on where I could contribute.
3. Start Small: Pick a Tiny Functionality
Before diving into big features or fixing complex issues, start small. Choose a minor feature that interests you—like tweaking logic in a login screen or updating a button’s behaviour—and search the codebase for relevant keywords. Make small changes and see how they affect the project. In short, hack it out! This process will help you get comfortable with the code while boosting your confidence.
4. Tackle Open Issues
Open issues are a great starting point but can be intimidating at first. A helpful strategy is to look for issues tagged as good-first-issue. Example
Websites like Good First Issue and Good First Issues make it easier to find beginner-friendly issues.
A useful trick is to reverse-engineer solved issues. Start by reviewing closed issues similar to the one you’re interested in. Understand how they were resolved, then apply that knowledge to your solution. This approach not only helps you solve current issues but also provides insights into the project’s problem-solving patterns.
5. Communicate and Ask Questions
One of my first open-source contributions to Rocket.Chat involved fixing the login screen. I spent a week working on it and opened a pull request (PR). Moments later, I found out that the internal team was already revamping the entire login screen, so my PR couldn’t be merged. All that effort could have been saved if I had first communicated with the maintainers.
Open-source communities are generally welcoming and supportive. Don’t hesitate to ask questions if you’re stuck or need guidance. Whether it’s understanding the project’s structure, finding relevant files, or figuring out best practices, reach out to the community. Engaging in discussions will also help you build relationships with other contributors and maintainers. Communicating your approach before diving in can save you from unnecessary rework.
6. Focus on Consistency, Not Quantity
Contributing to open source is a marathon, not a sprint. It’s better to be consistent with small contributions than to aim for big changes that might be hard to sustain. As you get more comfortable, you can take on bigger tasks.
For example, one of my first contributions was adding a small brand logo component to Rocket.Chat: Link to PR. A few months later, I worked on adding a GitHub Component Kit, which was a much more complex task. During this period, I focused on learning Next.js and improving my code quality.
Persistence is key—making your first meaningful contribution might take a few weeks, but that’s where the real growth happens.
7. Learn to Navigate Large Codebases
As you progress, you’ll need to get comfortable navigating large codebases. Tools like grep, ripgrep, or your IDE’s search function are invaluable for locating specific functions, variables, or files.
If you’re looking to fix something in the UI, search for the keywords visible on the screen.
If your focus is on data-related issues, examine the network calls happening during the loading process to figure out which call corresponds to which component.
Also, use documentation, GitHub Wikis, and architecture diagrams (if available) to understand how different components interact.
8. Don’t Overlook Documentation and Testing
Many new contributors skip over documentation and testing, but these are areas where help is often needed. Improving documentation, creating tutorials, or adding test cases are valuable contributions. s
Writing test cases helps you understand the project’s core logic while documenting code deepens your understanding and helps others.
9. Sharpen Your Git Skills
Version control is at the heart of open-source development. Get comfortable with Git commands and workflows, including branching, pull requests, rebasing, and resolving merge conflicts.
Git isn’t always as straightforward as it seems, and you’ll likely encounter tricky situations like merge conflicts or rebasing issues. Learning how to navigate these problems is essential. You can start with this Git Guide or find something more beginner-friendly.
Projects often have specific contribution guidelines, so, be sure to follow them and keep your commit history clean.
10. Read the Code
One of the most underrated skills in open source is the ability to dive into a codebase and start contributing, even if documentation is lacking. While documentation is helpful, it’s often outdated or incomplete in many open-source projects.
When I worked on adding a PR review feature during my GSoC period, I needed to integrate a code editor block into the component kit. This required changes across three different codebases, none of which were documented. The only way forward was to read a lot of code and commits, piecing together a solution.
As a newcomer, focus on reading as much code as possible and try to map out how different pieces connect to features you see on the screen.
Conclusion
Your first few contributions might be slow, and that’s perfectly fine. Getting comfortable with a new codebase, understanding the project’s culture, and making meaningful contributions takes time. Enjoy the process and celebrate the small wins. The satisfaction of seeing your code accepted into a project used by thousands (or even millions) of people makes it all worthwhile.
By following these tips and being patient with yourself, you’ll find that contributing to open source is not just a way to level up your skills—it’s also an opportunity to collaborate with like-minded people and create something impactful. Good luck on your open-source journey and in your pursuit of GSoC!
Feel free to checkout open issues in Middleware OpenSource👇🏻