Slashdot Mirror
Open Source Developed by Individuals, Not Large Groups
AlainRoy writes "A new article was just published in First Monday, which suggests that most open source projects have rather few developers." He excerpts from the study, done by Sandeep Krishnamurthy: "Based on a study of the top 100 mature products on Sourceforge...most OSS programs are developed by individuals, rather than communities. The median number of developers in the 100 projects I looked at was 4 and the mode was 1."
I can see where a large OSS project could get unwieldy really quickly with 100's of hobby developers scattered across the globe. As the number of "free" developers involved goes up, I'm sure the number of problems skyrockets. If you hand a large project to 4 dedicated people it will probably get done faster than if you farm it to 100. It seems fairly obvious to me that as the number of people working on a project grows, the number of people flaking out/not delivering on the project increases as well.
They who would give up an essential liberty for temporary security, deserve neither liberty nor security
How many projects were BASED on other open source projects?
Isn't that more of the point?
Good quote, too many chars. Seriously, the slashdot 120 char limit sucks!
I tend to agree with this point somewhat. The benevolent dictatorship model has proven to be by far the most efficient model for open source programming (Linux kernel). Ideally the world would work in a similar way: one ultimate being dictates what should happen (and its good) and people do it (and the result is good).
--Kevin
One of the biggest arguments for Open Source Software has been the "More Eyeballs" argument. Granted, if I use OSS I can view/edit the source myself, however, my company doesn't have the time nor the human resources to wade through the source code of even the smallest app. The other side is that with apps like Linux there can easily be multiple companies "distributing" their own versions, however, in the long term we haven't seen if this is a viable business model, especially outside of Linux.
There is no longer anything that can be done with computers that is nontrivial and clearly legal. -- Paul Phillips
Except he selected the 100 "top mature" projects. So it was a select group of projects. I suppose it depends on what "top 100 mature projects" actually means. Though I suspect the largest projects aren't on that sucky sourcefourge site, since they usually have the resources to find another host.
What I would have liked to see is a carefully chosen selection of opensource projects. (XFree86, vim, kernel, koffice, ..... )
Is there anyone here that belives that sourceforge IS the OSS community? I just don't see how anyone can claim to have an accurate study when using only one source! The most widespread and well know OSS projects are not hosted on sourceforge at all! Don't get me wrong, I love SF personally, but since anyone can post somthing on there and call it a project, it's not a good representation of the whole community. I can't tell you how many projects I have seen that sound cool, so I go to them and they say somthing like "This is a dynamic webpage for C programmers, we are currently looking for a Dynamic web designer and a C programmer".
Sigs are out of style, so I'm not going to use one...oh wait..
This study apparently takes as its presumption that the developers listed in Sourceforge projects are the developers who have actually contributed. Most projects take code from a much wider base than those listed on SF, taking bug fixes from emails.
So a SF project with two developers listed might only have two dedicated people working on it all the time, but might include tidbits of code from 30 different people.
The study's basic conclusion is probably sound: OSS is usually developed by very small core groups. But they need better data before they try to quantify that.
So much for the wonderful idea of many eyes helping me out. Maybe with large projects (although I doubt it, tending to think that you only get a small number of people who actually contribute anything) but for the projects like mine it just doesn't happen.
I've got a crappy FAQ script which I'm rewriting and will also go under the GPL. At the moment it's under some wierdass restrictive job because at the time (1999) I didn't properly understand the GPL and how cool an idea it is - the rewrite will be GPL'ed but i don't expect to be inundated with patches, suggestions and code.
Recently I mooted my SMS application eGenie as going GPL in the next version. I got 1 person interested and 50 people emailing me demanding I give them the code - no, they weren't interested in helping out - they just wanted the code. Bah, sod that then.
I'm fully aware of the Cathedral and Bazar idealogy, but when there is no-one in the Cathedral and you're the only person giving in the Bazar, GPL suddenly doesn't seem to be this wonderful solution to bugs, features and support.
Avantslash - View Slashdot cleanly on your mobile phone.
Um, it's not about increasing efficiency?
It's about reducing risk. Take seven projects, have the group work on each, they'll all pretty much succeed equally. Assign each to an individual, and your risk of tanking at least one shoots up.
Nobody cares if a single-developer open source project tanks. Just have fun. But the approach does have the vices of its virtues...
"Consider yourself a member of a virtual corporation with Mr. Torvalds as your Chief Executive Officer." - Linux Advocac
If you look at the last table in the paper, it's clear that alpha projects have the most developers.
In fact, mature projects should have fewer developers since there's much less left to do. In many cases, it's likely that the one remaining developer can accept all the patches and fix all reported bugs themselves.
Furthermore, the most popular Open Source projects aren't even hosted on Sourceforge. Where's the data on Mozilla, OpenOffice.org, Apache, Bind, the Linux kernel?
Isn't sourceforge designed as an incubator for smaller projects?
Finally, suppose it's true that there are only a few developers on a list? That doesn't mean they're the only bug-finders, even. Where's the statistics on numbers of bugs found?
In short, is this just another example of sample-bias?
(emphasis mine)
Always? Why is it that when everyone says this they can only quote about 3 or 4 projects?
Just because Apache is better than IIS doesn't mean that every commercial product is inferior to the OSS version.
Please don't delude yourself. The majority of the time commercial stuff is better than OSS because they have the time and resources to get people working on it.
I still find OpenOffice poorer than MS Office, GIMP poorer than Photoshop and so on.
Yes there are exceptions (such as Apache) but generally OSS is of a slightly poorer quality than commercial - but more than makes up for it by the fact that it's free and doesn't come with restrictive licencing agreements.
Avantslash - View Slashdot cleanly on your mobile phone.
I am probably a developer on a dozen projects that use my open source Java libraries. Open source is just different than normal development.
What did we expect, that the Mongolian Hordes technique actually works, or that Brooke's Law is purely theoretical? Lean really is mean, especially for the RAD category that a lot of open source falls into.
Anyway, these figures are spurious: I occasionally submit bug reports, fixes and enhancements to dev team on sourceforge projects, but I don't join the teams, because I can't commit the effort. But I did review the code, there's just no metrics that capture it. In fact, everyone who downloads, compiles and runs the source is testing the code to some extent.
In any case, I think you'll find tacit agreement that on most software projects (especially once the sales guys panic and start telling you what the customers actually want, halfway through development) that creationism is indeed a false ideal, and that it's a few dedicated (obsesses/fanatical/insomniac) individuals that do the vast bulk of the actual code development, while unseen teams break the ground in terms of hardware, requirement capturing and high level design, and clean up squads follow on to fix and maintain the stable versions. There's a lot of scope to be an unsung hero in development; I recently caught a bunch of minor memory leaks in a piece of software that had already been written, reviewed, fixed, and reviewed twice more (i.e. we're still catching bugs on the sixth iteration). And yet, because it's a single file controlled by one developer, it looks like only one person really ever worked on it.
Frankly, I think that for every developer who leaves his fingerprints on the code, there's room for at least three unseen backup guys and gals who do nothing but pave the way, clean up afterwards, and interdict management before they can distract the one productive guy. You just can't let management know that's actually the way it works, because it looks - on paper - like an inefficient process. That's quite apart from the testers, the technical writers, the people who do small parts of any GUI, the IT guys who keep the machines and servers running, the sales, marketing and customer support people who tell you varying shades of truth, and even the receptionist fielding calls for you. Even commercial enterprises don't tend to count these people; my current team has nine developers, but there at least another two dozen non-technical people who we absolutely rely on who aren't counted as part of our team. Open source seems to be similar, only with fewer people, and with even some technical people (like testers and casual bug fixers) not being captured in the team size statistics.
If you were blocking sigs, you wouldn't have to read this.
First, why limit the study to the top 100 of the mature projects, since all the data is available, why not include as many projects as possible unless you've found a specific subset of the data that gives you the conclusion you want?
...
Second, does the study take into account that projects may move from one principle developer to another to another over their lifetime? There may be only one or two at a given time, but there may have been a dozen since its first inception. Perhaps the study took that into account...
Third, "...assistant professor of E-Commerce/Marketing..." I suppose this is the "new education" to go with the "new economy"
In addition to the "many submit patches, few apply them to the archive" argument, there's another systematic undercount:
A large project will often have a few people whose job is to integrate the code. Sometimes this means only these integration specialists will have write privileges on the archive. The bigger the project, the more likely this is to occur.
==========
That said, what's "small" about a median of four with write privileges? (The mode of one just means that there are more one-man projects hosted at source forge than N>1 man projects for any particular N.) Four active programmers is a moderately big project, and "median of four" (with mode of non-four) implies there's a bunch with more-than-four as well.
Four is a very good size for a large project. Going above that takes a lot of work and is inefficient on a per-programmer basis, unless you have administrative workers who don't program to do the organization. The "human as four-port" analysis shows why.
Consider a human as a "black box" with a number of "ports", representing equal divisions of his time and/or attention. Each port represents enough time per day to communicate with one co-worker or to do one unit of work. Assume also that this amount is such that the number of "ports" on a programmer is about four. (It's probably a bit larger, but four is close and easy to draw.)
In a given amount of time, with a single-committee project:
A one-man project does four units of work:
A two-man project does six units of work:
A three-man project also does six units of work:
A four-man project does FOUR units of work:
And a five-man project bogs down in talk and does no work at all:
With a different number of "ports" the maximum-work group size changes, but the shape of the curve is the same: Adding people first raises the amount of work done, then levels out, then DROPs it until the group paralyzes. For N ports the stall is at N+1 workers. N work about as well as 1 and (N+1)/2 get the maximum work out.(Ever wonder why you spend half your time in meetings? THAT's why! If the goal is to get the project done in the shortest time regardless of personnel cost, the most effective size for a group of peers has each worker spending about half his time interacting with other workers.)
Now there are a number of ways around that. For instance:
1 Keep the team small (or one-man) and push out the delivery date.
2 Reduce the "bandwidth" of the communication ports and expand that of the work ports by assigning work on natural modularity boundaries.
3 Build a hierarchical organization, with some people specializing in communication (and doing little or no "work" on the code) and others mostly doing "work" but only interacting with their comm specialist (administrator) and maybe coworkers on closely-associated modules.
4 Build a hierarchical organization with one or a core group making final inclusion decisions and the bulk of the organization doing actual coding in small snippets.
Taking 1 to the limit results in a bunch of one-man projects with long delivery schedules. One man is the most productive on a code-per-manhour basis. But if the project is too large he slows down asymptopically as he approaches his "boggle limit" - the largest codebase he can maintain single-handed but no logner expand. That was once estimated at about 10K-20K lines of code (about the size of the System 6 Unix kernel, through NO coincidence).
Taking 2 to the extreme is what you get if you conider the open-source movement as a whole as a single project: The developers on each project need little communication with the developers of the others, beyond standards promulgated by a few core developers. Within a project it's the natural way to go, but there are limits to how much it can help.
3 represents your typical industrial software operation. But open-source developers usually hate to become pointy-haired bosses and stop codiing themselves, and without paychecks to hand out they have a lot more trouble herding the cats. So a few big open-source projects are be run by one or a few notable developers with strong personalities who are able to bite that bullet on managing-over-coding and use reputation points in place of paychecks to motivate their workforces. And the rest are one-mans or small teams of friends, self-organizing in grand primate style along the lines of 4.
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way