The value of drive-through contributions
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
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
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 | |
---|---|
Conference | OSCON/2016 |
Posted May 27, 2016 9:30 UTC (Fri)
by jezuch (subscriber, #52988)
[Link] (10 responses)
> "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.
Posted May 27, 2016 13:50 UTC (Fri)
by lsl (subscriber, #86508)
[Link] (1 responses)
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.
Posted Jun 1, 2016 12:58 UTC (Wed)
by ballombe (subscriber, #9523)
[Link]
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.
Posted May 27, 2016 15:33 UTC (Fri)
by pm215 (subscriber, #98099)
[Link]
Posted May 27, 2016 20:13 UTC (Fri)
by Nemo_bis (guest, #88187)
[Link] (6 responses)
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.
Posted May 30, 2016 19:46 UTC (Mon)
by flussence (guest, #85566)
[Link] (5 responses)
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.
Posted May 31, 2016 9:21 UTC (Tue)
by micka (subscriber, #38720)
[Link] (4 responses)
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?
Posted May 31, 2016 15:27 UTC (Tue)
by lgeorget (guest, #99972)
[Link] (1 responses)
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.
Posted May 31, 2016 18:13 UTC (Tue)
by micka (subscriber, #38720)
[Link]
Posted Jun 4, 2016 18:12 UTC (Sat)
by Wol (subscriber, #4433)
[Link] (1 responses)
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,
Posted Jun 4, 2016 22:15 UTC (Sat)
by micka (subscriber, #38720)
[Link]
Posted May 28, 2016 0:08 UTC (Sat)
by dps (guest, #5725)
[Link]
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.
The value of drive-through contributions
The value of drive-through contributions
The value of drive-through contributions
The value of drive-through contributions
Conventional viewpoint?!
Conventional viewpoint?!
Conventional viewpoint?!
Conventional viewpoint?!
Conventional viewpoint?!
The FSF is not a good reference either, one of their license (GDFL) is not free using either definition.
Conventional viewpoint?!
Wol
Conventional viewpoint?!
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