License: CC BY-NC-SA 4.0

Getting Started with Open Source Contributions

Stefanie Molin

Bio

👩‍💻 Software engineer at Bloomberg in NYC
🚀 Core developer of numpydoc
✍ Author of "Hands-On Data Analysis with Pandas"
🎓 BS in operations research from Columbia University
🎓 MS in computer science (ML specialization) from Georgia Tech

Agenda

Open source contribution myths
Finding a project to work on
Identifying a way to contribute
Making your contribution
Q&A

Let's dispel some myths.

Myth #1

Only professional developers or maintainers can contribute to open source projects.

Myth #2

Only experts can contribute something meaningful.

Find a project to work on

Brainstorm potential projects

Make a list of the projects you frequently use now or have used in the past.

Evaluate potential projects for suitability

1. Software license

2. Recent activity

3. Codebase size

4. Tech stack

5. Repository access

Which license is the software distributed with? Your employer may have restrictions on your participation depending on the license.
Is the project still active? Has it been a long time since the project was last updated/released? The project may be very mature, and therefore light on activity. Are people still using it? If not, the project may have been abandoned or replaced. In either case, try to find something else.
How big is the codebase? While there will likely be more opportunities for contributions in a larger codebase, it may be harder to get a foothold if you are newer to the codebase.
Is the project built on top of another project that you are familiar with? If so, you can use that knowledge to contribute even if you are less familiar with this project's codebase. Example: Seaborn is built on top of Matplotlib, so if you know Matplotlib, you can tackle some issues in Seaborn.
Can you find where the project's repository is hosted? Is it public? If not, then this isn't an option. Keep in mind that not everything is hosted on GitHub.

Identify a way to contribute

#1. Participate in sprints

Source: tweet from François Goupil

This is me, working on scikit-learn.
Sitting across from me are two of the scikit-learn maintainers.
While working on scikit-learn, I learned about numpydoc, which I ended up using later and eventually contributing to.
The maintainers also helped me fix some issues I was having by introducing me to pre-commit. This also led me to several other contributions with other projects.
It was a great experience, and I have done multiple sprints since. I can't recommend them enough. Regardless of your experience, you can learn something.

Tips💡

Pick a project that interests you.
Look for beginner-friendly projects.
Ask the maintainers for support as needed.
Go in with an open mind.

Sprints are a great way to contribute. Here are some tips to get the most out of your experience:

Pick a project that interests you, as this will motivate you to make your contribution and set you up for further contributions after the sprint.
Maintainers will mention if they are able to support beginners. This could mean a beginner to programming or just to that project.
Maintainers curate a set of issues for the sprint and help people contribute. Be sure to use them as a resource – they want to see you make a contribution just as much as you want to make one.
A sprint is a tremendous opportunity to meet and learn from maintainers. Ask them questions. What development tools do they use? How do they navigate the codebase? Depending on the project and your experience, you may also be able to teach them some things.

#2. Contribute examples to the documentation

Screenshot of NumPy's Polynomial.degree() documentation page with contributed examples. (Source: Stefanie Molin)

Tips💡

Every project needs good documentation.
Writing good documentation can be time-intensive.
Contributing examples helps you learn about the functionality.
Examples also help others learn.

#3. Browse open issues for ideas

Screenshot of open issues tagged "good first issue" in the scikit-learn repository as of July 24, 2023 11:44AM. (Source: Stefanie Molin)

Tips💡

Look for tags such as beginner, easy, or good first issue.
Don't disregard old issues, but make sure to check those changes are still desired.
Search for meta-issues.
Make sure to indicate that you are working on something by commenting on the issue.

Look for tags such as beginner, easy, or good first issue. Try to find issues with few (or no) comments as these are likely just the description of the task. In GitHub, you can see this from the listing of issues, which saves you time compared to opening each issue individually. Another option is to use sites like goodfirstissue.dev, but be sure to filter down to the projects you found in the brainstorming step, otherwise this will be overwhelming.
Older issues may have less action, but may still be relevant. Be sure to ask the maintainers. I've had success with this on Seaborn. I found an old issue that I knew how to do, and I asked if it was still of interest. This led to a PR for the reference line functionality on grid plots (FacetGrid and JointPlot).
Check for meta-issues. These are issues that list a set of desired changes that should be performed on multiple areas of the codebase. Often, this means you have a template to follow. These are common for sprints.
Comment on the issue if you are interested in working on it. You can also ask the maintainers for clarifications here.

#4. Identify and fix a bug

Screenshot of Bug Report issue template for the pandas GitHub repository as of July 24, 2023 11:52AM. (Source: Stefanie Molin)

Tips💡

Check if the bug has already been reported or fixed.
Put in a detailed, reproducible bug report.
Volunteer to fix the bug after the maintainers triage it.
Feel free to ask the maintainers for guidance.

Make sure that someone else hasn't already reported this bug. Check open and closed issues. Also, make sure it still exists in the main branch (someone may have fixed it already).
Your bug report should contain all the information necessary for others to reproduce the bug. If there is a bug report template, be sure to provide all information requested. Bonus: this can also be a test case for the fix.
Make sure the maintainers agree it is a bug before starting work (you don't want to waste your time on something that won't be merged). Maintainers might not be able to prioritize the bug fix, so by volunteering to work on it, the bug can be addressed much sooner. You can even volunteer to fix a bug reported by someone else.
You can volunteer to fix the bug even if you aren't sure where you should start. Ask the maintainers for guidance to get you started.

#5. Propose and implement a new feature

Screenshot of issue #450 in the numpydoc GitHub repository, which proposes incorporating a pre-commit hook for numpydoc validation. (Source: Stefanie Molin)

Tips💡

Check if the feature has already been requested.
Share your idea with the maintainers, detailing what you would like to be able to do or change.
Volunteer to work on the new feature after the maintainers evaluate it.
Don't take things personally.

Make sure that someone else hasn't already requested this feature. Someone may already be working on it, or the maintainers may have decided not to pursue it. Check open and closed issues.
Put in a feature request to see what the maintainers think. Explain your idea thoroughly with examples, if necessary.
Don't work on anything until you get approval from the maintainers. Again, you want to use your time wisely.
If the maintainers decide not to pursue your idea, don't take things personally. Remember to be polite in all interactions.

No contribution is too small.

Making your contribution

Tips for success ✨

Let the maintainers (and the world) know what you are working on.
Follow any setup instructions the project provides.
New to development? Start with documentation-based contributions, while you get comfortable working with tools like Git and GitHub.
If you can, attend a sprint or perhaps a local meetup for your preferred programming language.
Be polite and patient in all interactions.

Once you have found something that you would like to work on, make sure you claim it (e.g., by commenting on the issue). This keeps the maintainers in the loop (so they can help you if needed) and prevents duplication of efforts.
Make sure to follow any setup instructions the project provides for contributors. This may be in the documentation or in a contributing guide in the repository. If the instructions don't work for you, you can also fix that.
If you are completely new to development, start with documentation-based contributions, while you get comfortable working with tools like Git and GitHub.
If you can, attend a sprint or perhaps a local meetup for your preferred programming language.
Remember to be kind and patient in all your interactions with a project. Many maintainers are doing this outside of their regular work – it might take some time for them to review everything.

Keep up the momentum 💪

Look for knowledge-sharing opportunities across projects.
Help others contribute.
Know that your dedication will not go unnoticed.

Be sure to keep your eyes open for opportunities of cross-pollination: something you are exposed to while working on one project may be something that another project wants to implement.

Take a look at the open PRs. If you see something needs to be fixed, feel free to comment on it. This is also a great way to get noticed by the maintainers if you are interested in joining them.

Your dedication will not go unnoticed. Maintainers will start to remember your name, and you may also be able to meet them in person at other events. I've met maintainers from Matplotlib and pandas at EuroSciPy 2023 after previously interacting with them on GitHub. Sticking with it can even lead to an invitation to become a maintainer, which was how I became a numpydoc core developer.

Thank you!

I hope you enjoyed the talk. You can follow my work on the following platforms:

stefaniemolin.com

github.com/stefmolin

twitter.com/StefanieMolin

linkedin.com/in/stefanie-molin