|
|
Subscribe / Log in / New account

The value of drive-through contributions

By Nathan Willis
May 25, 2016

OSCON

The conventional viewpoint among open-source projects is that drive-through contributors—meaning people who make one pull request, patch, or other contribution then are never seen again—are problematic. At best, one would prefer to lure the contributor back, eventually cultivating them into a regular project participant. At worst, they can be seen as a disruption, taking up developers' time for work that may, ultimately, lead nowhere. At OSCON 2016 in Austin Texas, however, Vicky "VM" Brasseur from HP Enterprise presented an alternative viewpoint. Drive-through contributors are a good sign of a healthy project, she said, and optimizing the project to meet drive-through contributors' needs benefits contributors of every stripe.

Brasseur noted at the outset that the desire to capture drive-through contributors and convert them into regulars was a good [VM Brasseur] instinct, but said it was simply out-of-scope for her presentation. Instead, she wanted to explore what motivates drive-through contributors and see how projects can best make use of them. For the purposes of the talk, she explained, a "contribution" included anything that could be kept in version control, be it code, documentation, artwork, or anything else.

There are four major categories of drive-through contributor, she said: self-service contributors, work-related contributors, special-project contributors, and documentation fixers. Self-service contributors are those needing to get the project working for some other, larger purpose; perhaps they fix a bug that affects them, so they submit a patch for that fix and never return. Work-related contributors are similar, except that they are working with the open-source project at their day job, and have no other attachment to it: they will submit patches needed to get the job done, but do not get invested otherwise. Special projects include people enabling obscure hardware ports or supporting peculiar configurations; they care enough to get the project code working for that new scenario, but that is all. And documentation fixers are rather self-evident: they see a missing section or typo, send a fix, and consider the job done.

For projects, the interesting questions are why the contributor shows up at all and why they disappear. Many drive-through contributors tend to show up in the first place just to scratch their own itch (the self-service and special-projects contributor categories in particular). But there are other possibilities, she said: the contributor may have no choice but to use the project, even though they do not care for it, for instance. An example would be a developer who prefers PostgreSQL, but who is working on a MySQL project at their day job. When the job is complete, they will likely return to PostgreSQL. And, in some cases, drive-through contributors submit a patch simply because they like you: they notice something wrong and send a fix because they care about open source.

On the flip side, these contributors depart for a handful of reasons worth reflecting on, too. When the itch is scratched or the work project is finished, they may simply move on. But it is also common for contributors to start with good intentions and simply run out of time; "life happens," she reminded the audience. Drive-through contributors also sometimes move on because they find another project that suits them better. That, too, comes with the territory. Yet there are a few reasons for a drive-through contributor's departure that should worry the project: when contributors find it too difficult to work with the project, when they feel like their contribution was not appreciated, and when some project member treated them poorly.

The latter case is the "asshole problem," she said; it is a common criticism of open-source projects, but it is even more pointed when drive-through contributors are involved. Too many developers treat drive-through contributors with hostility, calling them a "waste of time" or words to that effect. These developers tend to claim that drive-through contributors are time sinks and that they are not "part [Project pyramids] of the community and never will be."

But that represents a misunderstanding, Brasseur said, of how "community" and "contributors" relate. Often, projects talk about community as the base of a pyramid, with contributors a smaller level above that and "core" developers at the top. In reality, she said, the contributor base (including drive-through contributors) is larger than the project community; it is the foundation of the project pyramid—as illustrated in the diagram to the left. "You can't build a community with no contributors—they come first."

Consequently, she said, an increasing number of drive-through contributors should be seen by the project as a positive sign. Conversely, a project with few drive-through contributions may not be as healthy as it thinks it is. Lots of drive-throughs means more people are seeing the project, more people are using the software, and that the process for making a contribution is easy and working well. Therefore, more people will make contributions (of every type) and the community can develop. Improving the number of drive-through contributions means more bugs are located and fixed, more documentation is written, test coverage is expanded, and releases can be faster. Furthermore, the project's reputation is likely to improve as well, with it being seen as friendlier and more accessible. Thus, while there are a lot of ways to measure "project health," she said, growing the number of drive-through contributions improves almost every metric.

She then turned to providing some advice on how to make drive-through contributions easier. About half of the methods revolved around documentation, she said. Better documentation cuts down on questions by providing potential contributors with the necessary information up front, and it standardizes processes across the project.

In particular, Brasseur recommended writing a "quick start" guide that offers a high-level summary of the contribution process, plus an in-depth "how to contribute" document that addresses the steps in detail: how to format patches, how to submit any contributor agreements required, how merges are approved, and so on. These documents minimize the number of "how do I start" and "what do I do next" questions that project members will have to field. She also recommended documenting the project's communication routes (i.e., who to contact on various topics) and a code of conduct. "Writing one won't kill you," she said about the latter. "It just shows people that you give a damn about them."

A few other documents worth creating include a "who's who" that explains leadership roles, subject-matter experts, and any sub-teams within the project, a "rules and processes" document, a jargon file, and a project roadmap. The "rules and processes" document should explain how someone becomes a core contributor, which can be quite inspirational for new contributors to see, as well as various bylaws and governance structures. The project roadmap helps new contributors by explaining the release schedule, the planned features, and what it will take to get a patch into a particular release.

Beyond documentation, she outlined several other methods for improving the contribution experience. Project members can mentor new contributors by doing code reviews, holding IRC "office hours" to answer questions, and by holding hackfests open to the public (perhaps even hackfests specifically geared toward new contributors). Projects can do things to improve their processes as well, she said. Suggestions include tagging "starter" bugs, providing pre-built containers or virtual-machine images of the development environment, and having a public "service level agreement" (SLA) for contributions. The SLA, she explained, means making a pledge that (for example) "we will look at each patch and respond to it within five days." That encourages newcomers by telling them that their effort will not be overlooked, and it sets expectations.

On a larger scale, she said, projects would be wise to cultivate a culture that values contributions and contributors. They can make sure that all contributions are credited in the release notes and Contributors file, they can "default to assistance" when they encounter a new contributor, and they can place a high value on documentation. "It is much easier to document as-you-go than it is to tackle a long list of documentation all at once."

Projects also need to create and enforce a "no assholes" rule, she said. "There's talk in the world about the unicorn 10X developer," she said. "But I don't care how many X's they have; if they act like an asshole they're bringing everybody down." Fortunately, she said, the majority of the time, people who treat others poorly and with hostility are not doing so intentionally—they only know that the rest of the project lets them continue acting the way they do. Most of the time, telling them why there is a problem and what they are expected to do next time is sufficient.

Finally, Brasseur advised projects to engage in outreach to contributors. They should express gratitude for contributions (including drive-through contributions), recognize each contributor, and follow up after the fact. Follow-up may include asking the contributor how their experience was, if there is anything about the process that could be improved, and (in the case of drive-through contributors) why they left. To be certain, not every drive-through contributor will—or even can—be cultivated into a regular project member. But, Brasseur said in closing, "all of the steps you take to maximize drive-through contributions also lead to a healthier project overall."

The session ended with a few questions from the audience; one person asked for examples of large projects that do a good job at the sort of documentation discussed in the talk. Brasseur replied that OpenStack does well in this regard, as do many Apache projects and the Django project. Another audience member asked how to encourage the drive-through contributors who leave for lack of time to reconsider. Brasseur echoed what someone else in the audience offered as a reply: perhaps the best thing a project can do is feel grateful that the drive-through contributor, even when busy, took some of their time to stop and make a contribution.

Index entries for this article
ConferenceOSCON/2016


to post comments

The value of drive-through contributions

Posted May 27, 2016 9:30 UTC (Fri) by jezuch (subscriber, #52988) [Link] (10 responses)

Everything here's spot on. In fact, it's so obvious to me that I find it hard to believe that anyone would think of drive-through contributors as "waste of time". Maybe that's because I'm an occasional drive-through contributor myself :) See, I have to work with some Open Source projects in my $DAYJOB (who doesn't nowadays?). They invariably have bugs. I used to import the sources of the project in question into our repository and fix the bug there and maybe submit a bug report upstream - but it unnecessarily increases the size of our internal repository, it reduces the incentive to work with the upstream and is Just Wrong(TM). So now I immediately submit the fix upstream and endure the pain of waiting until it is included in a public release. And the most important thing is that *this is how it's supposed to work*. Open Source is supposed to be open to *everyone*, and *especially* those that just have an itch to scratch.

> "But I don't care how many X's they have; if they act like an asshole they're bringing everybody down."

OK, let's call it a "Brasseur Multiplier" or "Brasseur's Law": if a 10X developer detracts 20 1X developers, the 10X developer is in fact the -10X developer. And that's why we should not tolerate assholes just because they are good developers.

The value of drive-through contributions

Posted May 27, 2016 13:50 UTC (Fri) by lsl (subscriber, #86508) [Link] (1 responses)

It's not just you. Someone drops a patch at my doorstep and walks along. The patches tend to be simple bug fixes, not huge code dumps accompanied by future maintenance costs. What's not to like about it?

Of course, if someone requires days of hand-holding to submit a typo fix, that's something else. I wouldn't think of those cases as drive-through contributors, though.

The value of drive-through contributions

Posted Jun 1, 2016 12:58 UTC (Wed) by ballombe (subscriber, #9523) [Link]

> It's not just you. Someone drops a patch at my doorstep and walks along. The patches tend to be simple bug fixes, not huge code dumps accompanied by future maintenance costs. What's not to like about it?

What happens to me: the patch comes with no explanation of what it is supposed to improve, subtly breaks backward compatibility in corner case, and is slightly off the coding style.

So yes, I can try to guess what this is all about, fix it not to break compatibility, and still not be sure the result fills the submitter use-case.

A bug report with no patch is more useful than that.

The value of drive-through contributions

Posted May 27, 2016 15:33 UTC (Fri) by pm215 (subscriber, #98099) [Link]

I think it's easy for a project to fall into the grey area between "actively discouraging the drive-through contributor" and "making it always an easy and good experience for them", though. For instance, QEMU (which I'm involved with) gets some things right (we have a detailed "how to send us patches" document on the wiki), but some things not so right (we're nowhere near having any kind of "SLA", and if you're unlucky and your patch is in one of our unmaintained areas it's likely to go un-dealt-with unless you prod us several times and do a lot of the legwork in demonstrating that the patch is good). I think moving out of this grey area requires an active investment of time and effort from people in the core community, so it's not surprising if for many projects it gets starved of attention compared to the the work those core developers' employers are typically paying them to do... (I keep meaning to have another look at what we're doing here with QEMU, though, perhaps this article will be the nudge I need to actually do that.)

Conventional viewpoint?!

Posted May 27, 2016 20:13 UTC (Fri) by Nemo_bis (guest, #88187) [Link] (6 responses)

«The conventional viewpoint among open-source projects is that drive-through contributors are problematic», seriously? Most free software projects I know tend to boast about how many contributors they have and consider as many people as possible in the count, thereby giving value to the casual contributors as well. The fact that most software projects have a small base of (real) contributors is usually used as (misguided) argument by the enemies of free software.

As for a SLA approach, that's an important step to take, however it comes with issues: 1) it requires someone to be "forced" to do the work mandated by the policy, which usually means you must have employees working on it; 2) CVS and issue tracker software (let alone mailing lists) may be unable to answer the question "is there a question/report/patch which is still unattended after X days?" (for instance bugzilla is able to tell you such a thing, but less mature issue trackers aren't: https://phabricator.wikimedia.org/T76825 ).

The classification of the 4 main kinds of drive-through contributions was interesting, but also likely to be based on a small sample of projects. Can someone point to some research on the matter? I can find some research on Sourceforge or FLOSSmetric datasets (mostly ancient), something on the Eclipse and Mozilla bugzillas and something on i18n for a few hundreds projects, but little systematic and wide-ranging research on recent evolutions. Maybe http://doai.io/10.4018/ijossp.2012100101 , http://hdl.lib.byu.edu/1877/etd4996 , http://hdl.handle.net/10612/1796 are interesting but skimming didn't point to anything specific.

Conventional viewpoint?!

Posted May 30, 2016 19:46 UTC (Mon) by flussence (guest, #85566) [Link] (5 responses)

> «The conventional viewpoint among open-source projects is that drive-through contributors are problematic», seriously? Most free software projects I know tend to boast about how many contributors they have […]

Maybe that's simply another point in the distinction between “open source” and true free software projects? Compare Op*nOffice and LibreOffice for example - the latter group *chooses* to be open, the former is merely *obliged* to be by the license it inherited, and the atmosphere around each one couldn't be further apart.

Conventional viewpoint?!

Posted May 31, 2016 9:21 UTC (Tue) by micka (subscriber, #38720) [Link] (4 responses)

I don't know, I don't make a difference between 'free software' and 'open source'. I just see the second one as a way to not have to explain the 'free as in free beer v.s. free speech' thing (not a problem in my language, the confusion doesn't exist).

For open/libreoffice, if what you're thinking of is the license, libreoffice is actually under dual apache/MPL and openoffice is (I think) only apache. Would you care to detail what you mean here?

Conventional viewpoint?!

Posted May 31, 2016 15:27 UTC (Tue) by lgeorget (guest, #99972) [Link] (1 responses)

The difference is clear for someone who wants to reuse the code.

An open source license merely gives you the right to check out and audit the code, a free software (per the definition of the FSF license allows you to use the code, modify it, redistribute it (including in its modified form), etc. : https://www.gnu.org/philosophy/open-source-misses-the-poi...

Even if probably most open source software out there qualify as free (I guess), that's not quite the same thing.

Conventional viewpoint?!

Posted May 31, 2016 18:13 UTC (Tue) by micka (subscriber, #38720) [Link]

Not at all. The only formal definition of open source (the OSI one) give exactly the same rights and guarantees (apart maybe some minor nitpicks on either side of the useless argument).
The FSF is not a good reference either, one of their license (GDFL) is not free using either definition.

Conventional viewpoint?!

Posted Jun 4, 2016 18:12 UTC (Sat) by Wol (subscriber, #4433) [Link] (1 responses)

> libreoffice is actually under dual apache/MPL

Actually, no. LibreOffice is NOT Apache, which is why LO can take advantage of OOo code, but the reverse is NOT true.

LO is dual-licence LGPL/MPL

Cheers,
Wol

Conventional viewpoint?!

Posted Jun 4, 2016 22:15 UTC (Sat) by micka (subscriber, #38720) [Link]

Ah I though I'd read about the rebasing of Libreoffice over the ASL release of Apache OpenOffice.
I (incorrectly) assumed the work was done and finished but apparently it wasn't.
Another error I made: it wouldn't have allowed to make LO ASL as new contribution wouldn't have been included.

The value of drive-through contributions

Posted May 28, 2016 0:08 UTC (Sat) by dps (guest, #5725) [Link]

I have been partly responsible for two separate drive-through contributions to the linux kernel: both where critical bug fixes done in connection with my day job. An explanation of the bug was included in both cases. The actual fix was different in detail, but not in principle, from my original one in both instances.

My day job did permit any serious kernel development except for critical bug fixes, so doing more was unfortunately not possible. I like to think that some other people benefited from not experiencing the bugs :-) Both bugs only affected heavy server hardware which is too expensive for a personal box.

The ability to get the bug squashed and move on was valuable, and one of the nice things about open source was we could produce an interim fix, and upstream squashed be bug quickly.


Copyright © 2016, Eklektix, Inc.
This article may be redistributed under the terms of the Creative Commons CC BY-SA 4.0 license
Comments and public postings are copyrighted by their creators.
Linux is a registered trademark of Linus Torvalds