Samad Yar Khan for Middleware

Posted on Aug 22 • Originally published at middlewarehq.com

Top 10 Tips to Get Started with Open Source and GSoC

#programming #opensource #webdev #beginners

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.

Choose the Right Organization
Become a User First
Start Small: Pick a Tiny Functionality
Tackle Open Issues
Communicate and Ask Questions
Focus on Consistency, Not Quantity
Learn to Navigate Large Codebases
Don’t Overlook Documentation and Testing
Sharpen Your Git Skills
Read the Code

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.

Back to Table of Contents

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.

Back to Table of Contents

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.

Back to Table of Contents

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.

Back to Table of Contents

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.

Back to Table of Contents

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.

Back to Table of Contents

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.

Back to Table of Contents

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.

Writing test cases helps you understand the project’s core logic while documenting code deepens your understanding and helps others.

Back to Table of Contents

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.

Back to Table of Contents

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.

Back to Table of Contents

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👇🏻

middlewarehq / middleware

✨ Open-source DORA metrics platform for engineering teams ✨

Open-source engineering management that unlocks developer potential

Join our Open Source Community

Introduction

Middleware is an open-source tool designed to help engineering leaders measure and analyze the effectiveness of their teams using the DORA metrics. The DORA metrics are a set of four key values that provide insights into software delivery performance and operational efficiency.

They are:

Deployment Frequency: The frequency of code deployments to production or an operational environment.
Lead Time for Changes: The time it takes for a commit to make it into production.
Mean Time to Restore: The time it takes to restore service after an incident or failure.
Change Failure Rate: The percentage of deployments that result in failures or require remediation.

Table of Contents