Sure, there are all sorts of metrics that you can collect about an open source project, but there’s only one that really matters: friction.
Friction can be measured as the amount of time that elapses between “I want to contribute”, and “I have contributed”. It’s the energy level necessary to transform a potential contributor to an actual contributor. It’s TTFC — time to first commit — and minimizing it is absolutely essential to building a strong open source community.
Think through the contributor UX
Think through every aspect of the experience of a potential contributor. They’ve found a bug. They’ve got a great idea for a new feature. Now what? What’s the first action they take, and how do they know to take it? For many projects, this will most likely involve cloning down the source code, establishing a development environment, making the change, testing things to verify it now does what I want it to do, and figuring out how to get this proposed change back to the project maintainers.
That’s a lot. And if the time it takes to do that is more than a few minutes, you’re unlikely to find a contribution from that person, especially if it’s their first time contributing to the project. Potential contributors may have a high tolerance for the bug itself to be tricky or time consuming (hey, that’s half the fun), but if the workflow and tooling surrounding that bug fix takes longer than the fix itself, they’re likely to move on to another project, and rightfully so. You’ve forever lost that contributor to friction.
So how do you reduce it? Wherever possible, absorb complexity on your contributors’ behalf.
It starts with documentation. What anticipate questions. All of them. Don’t let the potential contributor think. What are the projects goals? What’s the founder’s vision? What’s the development roadmap look like? What’s the release schedule? Where are we on the project timeline? What’s the project current status, is it even being developed? What language is the project in? What are the system requirements to run this thing locally? How do I get it set up? How do I contribute? Does the project have a style guide? Where can I find the FAQ?
If the same task is going to be performed by all contributors, just script it. There’s no need to decentralize a headache. Setup my development environment for me. Install the gems I need. Get that random database engine you chose configured. At GitHub, we call this
Okay, I’ve got my development environment, great, now what? How do I run this darn thing. Give me a single command. Absorb all that complexity you just created on my machine. Spin up the fifteen different processes you need running, each with their own unique arguments, and when I’m done, shut it all down so my CPU doesn’t melt. At GitHub, this is always
How do I know my change didn’t break something else four modules away? Have automated testing baked in, and give me an easy way to run it. Better yet, run it for me when I submit the proposed change. Give my contribution instant feedback. Give yourself the confidence to merge it. At GitHub, that’s
Something went wrong and I have a question. If I post it to your forum will I find a timely and helpful response? Will community members go out of their way to make me feel welcome and to make sure my desired contribution becomes a reality? When I do submit my potential change, no matter how stupid or poorly coded it is, is someone there to thank me? This process is scary. If my code sucks, will you give me feedback and help me to get it to where it needs to be? Okay, so I’ve contributed, do I get my name in lights? On the about page? In the changelog? How do you acknowledge that I am now a contributor?
Friction in the wild
So what’s the TTFC of your open source project? Once I’ve got the desire and have found the appropriate information (not an easy task), contributing to Drupal, for example, on OS X requires you to manually download, install, configure, and start it’s MySQL database server; edit your Apache server configuration in four different places; download their Drush command line tool; use Drush to download Drupal’s source code, move it to the appropriate folder, create a configuration file, and modify Drupal’s file permissions; create a database for Drupal, and as one guide I found put it best at this point in the tutorial, “now we are finally ready to install Drupal.”
If your potential contributor is like most people, they have a certain tolerance for friction, and once they’ve hit it, they’re just going to move on. Absorb your project’s complexity, so they don’t have to, and all of a sudden, by lowering the barrier to entry, you’ve just empowered an even greater slice of the open source community to contribute. Friction can easily kill an otherwise great project, or at the very least, it may attract a highly-technical subset of developers that will likely be out of touch with your users’ needs. Minimizing friction is absolutely essential to building a strong open source project. Potential contributors should be pampered and encouraged, not hazed and subjected to needless work.
Prior to GitHub, Ben was a member of the inaugural class of Presidential Innovation Fellows where he served as entrepreneur in residence reimagining the role of technology in brokering the relationship between citizens and government. Ben has also served as a Fellow in the Office of the US Chief Information Officer within the Executive Office of the President where he was instrumental in drafting the President’s Digital Strategy and Open Data Policy, on the SoftWare Automation and Technology (SWAT) Team, the White House’s first and only agile development team, and as a New Media Fellow, in the Federal Communications Commission’s Office of the Managing Director. His paper, Towards a More Agile Government was published in the Public Contract Law Journal, arguing that Federal IT Procurement should be more amenable to modern, agile development methods. More about the author →