Introduction

There is always a fear of large and unknown codebases among beginners who want to get started with open source, due to which most people give up at the beginning. With the help of this article, I want to explain some simple steps that can be employed by everyone and which I personally used to become a successful open source contributor.

Little Bit About Me

I was engaged in open source from mid-2021 to mid-2023, after which I took a break. During that time, I was able to get over 70 pull requests merged into several organizations. I even participated in open source programs such as Google Summer of Code 2022 and Hactoberfest 2021. Now, I am planning to restart my open source journey starting in July 2024.

Benefits of Open Source Contribution

• Skill development: While contributing to open source projects, you get exposed to different tools and frameworks, due to which you can learn many new things and get the opportunity to brush up on your existing skills. P.S. My first exposure to software testing and automation was through open source.

• Adhering to industry best practices: Most organizations require you to follow a certain coding style and write proper tests for any changes you make. These habits will definitely give you a head start in your first tech job.

• Networking: You get to collaborate and learn from professionals in several fields in the tech world. This improves your networking and communication skills.

• Resume friendly: Meaningful open-source contributions carry a huge weight on your resume. Hence, make sure to include them.

These are some of the numerous benefits of open-source contributions. Apart from that, you also get a huge amount of satisfaction when your contributions positively impact people's lives.

Prerequisites

There are no such prerequisites for getting started with open source. However, if you want to make meaningful contributions, you should have intermediate knowledge of any particular tech stack of your choice and a generic understanding of how things work in your particular field (irrespective of the tech-stack).

Identifying Beginner-Friendly Organizations

Beginner-friendly organizations always have some of the following characteristics:

• Detailed documentation on how to make the first contribution.

• Detailed steps explaining the process of installing and running the project locally.

• Active communication channels for new contributors.

• Regular activity on their issues and open pull requests.

• Good amount of open issues.

To identify them, first shortlist some organizations based on your field of interest, such as web, data, security, etc. Note that during this step, you have to be a little bit flexible with your tech stack. For this, you can use sites like gsocorganizations.dev and summerofcode.withgoogle.com.

After shortlisting organizations, you can visit their GitHub pages and have a look at their projects. If the projects satisfy the conditions listed above, you can consider that organization for further steps.

After this step, you should have at least three organizations that satisfy the above-listed conditions. Now, you can install popular repositories of these organizations in your local system for testing purposes.

Choosing the First Issue

Filtering Beginner Friendly Issues

To choose the first issue to work on, you can visit the issues tab of a particular repository of a particular organization and filter out the issues using the "good first issue" label. Note that the exact label might not be available for the project you are considering, but there will be something similar to this, such as "beginner friendly", "new contributors only", etc. These issues are specifically curated for new contributors and are present in many repositories.

My Advice on Choosing the Type of Issue to Work On

These issues will be related to several tasks, such as writing tests, refactoring existing code, solving UI problems, etc. Through personal experience, I advise that you don't try out refactoring or complex UI issues at first. This is because these issues require some knowledge of the codebase, which you don't have at the beginning.

Hence, you should start with simple UI issues and testing, which are a lot simpler and don't require much knowledge of the codebase. For UI issues, you can find the related files by global searching (VSCode) the keywords mentioned in the issue and start solving them. They mostly consist of changing the color of a button, changing the text inside an element, etc.

For testing-related issues, you can learn how to write tests by referring to the documentation and by looking at the tests of other files. Most of the time, you will be able to find another file with similar code that you need to write tests for. You can just refer to those files while writing your own tests. Similar to the previous case, you can make use of global search (VSCode) to find similar files. For writing tests, you can also use tools like ChatGPT, which did not exist during my time. Also, work on unit testing at the beginning. Don't jump on E2E testing just yet.

Identifying Maintainers

After you have chosen your first issue, tag the maintainers of the project in the issue thread and let them know that you want to work on that issue. To find the maintainers, you can see the threads of other issues and check who is assigning the issues to contributors. Check this for several issues, and you will be able to find some common people who are the maintainers of the project. Maintainers are the first point of contact in case you are stuck on something.

A Note on Maintaining Consistency

Now comes the most difficult step, which is maintaining consistency. Fixing the first issue typically takes a lot of time and effort. It might take three to four days to barely identify what is wrong with the code and what you need to do to fix it. There might be instances where you are stuck and need help from the maintainers of the project. Even if you fix the issue and submit a pull request,

In this stage, you might feel like giving up, but the key here is to keep going on until the pull request gets merged. Once it gets merged, you will feel a great sense of achievement as your code gets merged into a popular public repository.

At the beginning, it will take a lot of time for you to solve very simple issues, but this will decrease eventually as you contribute consistently. After working on around ten beginner issues, you can jump on to moderately difficult ones. At this stage, you will have a decent knowledge of the codebase, and it will be very easy for you to determine the areas of the codebase where you need to make changes.

Once you have carried out this process for one to two months, you will gain enough confidence in open source contributions. Now, you won't face any fear or difficulty in contributing to unknown codebases and can start contributing to other projects too.

Conclusion

Maintaining consistency is the key to becoming a successful open-source contributor. As you get better and better, you will be able to detect bugs in the project and solve them on your own. At this stage, you will be well-equipped with the skills required for solving complex issues, which involve feature-design documents and constant communication with the core maintainers.

Remember that being a good open source contributor also helps you to easily adjust in your first job as a software engineer, as you will be well-equipped with the skill of contributing to an unknown codebase.