Getting started in open-source software is intimidating. I know, I’ve been
there: it’s always a little scary to have someone you’ve never met before
critique your code, particularly if it’s someone whose work you respect and
admire. More than that, though, I suspect that at least part of the fear most
people (myself included) feel about getting into open-source boils down to one
simple question.
What If I’m Not Good Enough?
The huge proportion of the news we hear about open-source software is related
to or contextualised by discussion about the individuals who maintain these
software projects. Think of Linus Torvalds
and Linux/Git, think of Guido van Rossum
and Python; hell, think of Kenneth Reitz
and Python Requests. These people are all lauded, quite rightly, for both the
quality of their code and the skill they showed in writing it. The maintainers
of significant and notable open-source software projects are in many ways the
rockstars of the programming world.
Hearing so much about these individuals causes programmers to draw comparisons
with themselves, and the reality of the situation is that for most programmers
these comparisons will inevitably turn out negatively. This is not our fault:
we are individuals trying to do the best we can in an industry where the very
best amongst us are more than 10 times more productive
than the average. We should not be surprised that, if we’re honest with
ourselves, we don’t measure up.
It is easy, therefore, to conclude that we have nothing to give to the
open-source world. After all, if the Python open-source community has already
got Kenneth Reitz, and Zed Shaw, and
Armin Rigo, what the hell can I bring to the table?
Open Source Has Enough Rockstars
One of the major unifying characteristics of these open-source rockstars is
that they’re large-scale thinkers. When I say this I don’t meant that they
can’t or don’t solve small-scale problems: they do that every moment of every
day. What I mean is that they tend to think more of the cohesive whole of their
project than of the minutiae of it. When they consider making changes to their
codebases they tend to be thinking in terms of large-scale refactorings or
significant feature changes.
This is brilliant, and there’s no-one better suited for it. Python Requests is
undergoing just such a refactoring right now, and I can say, hat in hand, that
Kenneth will do a much better job of adding the new functionality than I ever
would. Without people who can think and design on this kind of scale, and then
execute, open source software would be significantly less impressive.
However, while this is going on, people are raising issues. They’re filing bug
reports, and finding mistakes in documentation, and finding that the software
library you’re using doesn’t function with a specific version on a specific
platform. And all of these little tasks are sitting there, preventing the
rockstars from doing what they’re good at and what they want to: thinking big
picture.
In many ways, then, what these rockstars need is not some other rockstar who
can come in and add some snazzy new feature and a whole battery of tests for it
in two hours. What they need is someone to come in and take it upon themselves
to answer bug reports, and fix and write documentation, and make the changes it
takes to get the library to function properly on 15 different types of machine,
and make the small fixes that don’t take much conceptual effort for the
rockstar but do take a precious hour and a context switch away from their real
focus.
Every open-source project of a certain size has these people, and in many ways
these people keep the project moving forward. They aren’t indispensable: for
each rockstar there are quite a few developers who are simply ‘good enough’;
but they are important. Much like a good project manager,
these people act like a force multiplier: if each hour the rockstar puts in is
worth ten of theirs, then putting in two hours to give the rockstar one is
actually giving the project 5 times more resource than you put in.
So You Aren’t A Rockstar? Own It.
In the end, open source needs people to do the less-glamorous work that none of the rockstars wants to do. And that’s really ok. You’re just as valuable doing
that as anyone else, and you’re a lot more valuable doing that than nothing at
all.
I work on the Requests project a lot, and that project has some great guys
contribute to it. Quite aside from Kenneth himself, some very competent people
have contributed code to it, doing things that are quite probably beyond me.
But a year of contribution adds up: I’ve got the third largest number of
commits to the repository, the sixth highest number of deletions and the fourth
highest number of additions. None of my changes are glamorous: most are small
and a large number are documentation-related.
But the time I spend plugging these leaks is time that others get to make the
changes I’m not smart enough or talented enough to do. And that makes my
contribution valuable. It’s not glamorous, but it’s important, and that suits
me fine.