Want to read Slashdot from your mobile device? Point it at m.slashdot.org and keep reading!


Forgot your password?
Programming IT Technology

Open Source Developed by Individuals, Not Large Groups 270

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."
This discussion has been archived. No new comments can be posted.

Open Source Developed by Individuals, Not Large Groups

Comments Filter:
  • first post (Score:3, Interesting)

    by hummassa ( 157160 ) on Wednesday June 05, 2002 @12:53PM (#3645874) Homepage Journal
    I think the problem with the study is the use of SourceForge as the source :) for the data.

    no pun intended?

    FP, anyway...?
    • It is, but for other reasons.....

      He took the number of registered developpers for a project. This is a very bad way of counting..
      I manage a few projects myself and if I take one as example namely motion it clearly shows:

      Motion is registered at sourceforge (I used their CVS for a while but it turned out not to be my prefered way of working) and the developpers list is VERY short.
      However on the motion mailinglist their are far more people participating. Some actually contributing code, some just helping testing and helping the newbies. They are the community, and it works. I also once in a while get a patch for a fix from and never hear again from that person... They are not listed as developpers for the project but they sure contribute.

      • Agree, this is what I sent to Sandeep:
        > only a small percent of all programs make it to the Mature stage

        > [...]. Therefore, choosing products in this category allows us to
        > focus on the products with the best chance to build a community
        > around them.

        Um, no?

        Try interpreting things this way `Products in this category are least in need of help'. Or this: `Project leaders for this category tend to have above-average regard for the maturity of their projects, a regard which is shared by fewer others than projects with less ambitious ratings' (or `, which correlates with other `lone wolf' practices').

        It would be interesting to shove a few other categories through the statistical mill and see how they compare. It would also be helpful to include mailing list numbers in the comparison, although quite a number of fixes tend to get emailed direct to developers.

        Cheers; Leon

        Assuming that everyone uses SourceForge according to the directions on the label is a bit naive.

        Three statisticians are out duck-hunting. Here comes a duck! BLAM! The first fires, the shot goes above the duck. BLAM! The second fires, the shot goes below the duck. Excitedly, the third leaps about yelling, `we got him! we got him!'
  • Not Surprising (Score:4, Insightful)

    by captain_craptacular ( 580116 ) on Wednesday June 05, 2002 @12:54PM (#3645877)
    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.
  • ...but... (Score:4, Interesting)

    by FortKnox ( 169099 ) on Wednesday June 05, 2002 @12:54PM (#3645878) Homepage Journal
    How many projects were BASED on other open source projects?

    Isn't that more of the point?
  • by kpansky ( 577361 ) on Wednesday June 05, 2002 @12:54PM (#3645882)
    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).
    • by SirSlud ( 67381 ) on Wednesday June 05, 2002 @01:05PM (#3645998) Homepage
      >one ultimate being dictates what should happen

      The trick is to to dictate what _should_ happen while not dictating _how_ it will happen. Giving underlings the freedom of choice with respect to implimentation leaves enough room for creativity (assuming you have the right dictator and underling army) to ensure that everyone is happy and benifits under said system.

      I'm sure I'll get flamed for this, but I'm imagining most people have a hero/dictator/guide they would listen to sans question, and be all to happy to exercise their creativity and intellegence in implementing the processes required to reach the dictated goal.

      Which is a long winded way of agreeing with you.
    • by anthony_dipierro ( 543308 ) on Wednesday June 05, 2002 @01:06PM (#3646017) Journal

      The benevolent dictatorship model has proven to be by far the most efficient model for open source programming (Linux kernel).

      And the great advantage of open source software is that the threat of forking forces the dictatorship to be benevolent. It's actually amazing how well the threat of forking is high enough to ensure that huge mistakes are not made, while still giving the dictator the freedom to make small decisions in the way s/he feels best. In other words, the cost of forking is high enough to maintain the dictatorship, as long as the dictator remains benevolent.

    • 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).

      Who are you - young Anakin?
    • "Ideally the world would work in a similar way"? The thing is, when it comes to Linux, you have free association. You can freely chose to use or not to use, contribute to or not contribute to, the Linux project. This is not the case with many things as they are now in the rest of the world, every nation has compulsory systems you cannot opt into, because you have no recognized choice in whether you take part. You cannot chose not to participate in the propping up of Enrons, the state funded perpetuation of the Microsoft monopoly, governmental propping up of failed businesses (S&L ect.). The world is not lacking in dicators, benevolent or otherwise, what it lacks is freedom of association.
  • by tshak ( 173364 ) on Wednesday June 05, 2002 @12:54PM (#3645883) Homepage
    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.
    • 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.

      Here's a free clue -- don't use software on sourceforge for security-critical functions (-; Seriously, the "many eyeballs" benefit is one that deserves scrutiny-- some packages, like the kernel, ssh, and core utilities really do have "many eyeballs" watching them. Others don't. To simply assert open source implies "many eyeballs" is clearly nonsensical, but on the other hand, it is true that a lot of important open source software does benefit from community scrutiny.

    • by DevNull Ogre ( 256715 ) on Wednesday June 05, 2002 @01:27PM (#3646222)

      Mockus and Herbsleb [opensource.ucc.ie] (PDF, from the 2nd Workshop on OSS Engineering) look at the way Apache is developed (and try to glean lessons that can be applied to distributed development in general). They point out that a small team of core developers produce most of the new features, a much larger group contributes patches to fix bugs, and a much larger group than that uses and tests the code. In my experience, that is how the most successful OSS projects work.

      The study in this article only counts the number of registered developers--the small core team. The people contributing patches are where the "More Eyeballs" argument comes in. I don't think that was reflected in this study.

    • You're not getting the full picture.

      More Eyeballs != More Programmers

      More Eyballs DOES equal, more beta testers, more users, more people 'eyeballing' the code and suggesting improvements.

      ONE person can't do everything, but he can write most of the code.
    • by Ungrounded Lightning ( 62228 ) on Wednesday June 05, 2002 @07:55PM (#3649378) Journal
      How does this [small number of registered developers on most open source projects] rationalize "More Eyeballs"

      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:

      W W
      | |
      | |
      W W

      A three-man project also does six units of work:

      W W
      | |
      | |

      A four-man project does FOUR units of work:

      | \/ |
      | /\ |

      And a five-man project bogs down in talk and does no work at all:

      | |
      | \/ | | |
      | /\ | | |
      [3]--[4]--+ |
      | |
      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.

      • Thank you for your reply. Do you have any references regarding claims such as "one developer can only maintain 10-20K lines of code"?
        The studies of software development and sizes of teams are of great interest to me. I've mainly worked in relatively small teams (no more then 4 devs on one project), and I've always faught against managers that wanted to add 2-3 more "temps" to a late project (as if it would increase time-to-market).
        • Thank you for your reply. Do you have any references regarding claims such as "one developer can only maintain 10-20K lines of code"?

          Sorry. That's something that stuck in my mind from 20 or more years ago. So from my standpoint the origin of the comment is long lost.

          I've mainly worked in relatively small teams (no more then 4 devs on one project), and I've always faught against managers that wanted to add 2-3 more "temps" to a late project (as if it would increase time-to-market).

          Actually, adding 2-3 more temps to a late project WILL increase time-to-market (i.e. make it deliver later).

          That one I do have a source for: _The Mythical Man-Month_. The formulation is "Adding personnel to a late project makes it later.", delivered as one of the central catch-phrases and then explored in detail.

          Basic idea is the people who are actually getting work done have to stop making progress to spin-up the newbies, and once they're spun up it takes a long time for them to make as much extra progress as was lost spinning them up. The closer to the end of the project, the less time there is to repay the investment.

          Of course the "man as four-port" argument says that, if the project is big enough (and not properly partitioned) you'll NEVER make it up, and may slip farther behind, because the ongoing communication load eats as much or more work from existing workers as the added workers put out.
    • I don't think the fact that only one developer does the work somehow invalidated the More Eyeballs notion. Development is very similar to composition. If you're writing a diary that you intend to be kept private for all times, you will use a style that may be totally unappealing or difficult for readers to understand or appreciate. If you're writing for an audiance, even if no audiance ever sees your work, you'll still write in a different manner. I think the imporatnce of the More Eyeballs notion is to maintain the notion of standards within the community that the individual should strive to attain. That's an unclear standard, but a standard of quality none the less.
    • The many eyeballs statement is false when it comes to security. Look at the security problems with ssh and other software with many eyeballs on them (sendmail, bind etc). They aren't designed properly for security. Yep ssh has some security design problems - which is I chose to use telnet over SSL+certs some time back.

      A single skilled/trained eyeball is worth more than a million ignorant eyeballs. Otherwise you could just let lots of battery hens vet your source code.

      The millions are useful for testing to see if the software works well enough for the same millions, and that's totally different from secure.

      I'm just one of the slightly less ignorant eyeballs.

      What you need are real experts and there aren't that many available - and they may have other things to do - they might be busy auditing closed source software and being paid lots for it.

  • no technical bits but:

    How many of the projects use opensource tools, "modules", and interact with other projects...

    Looking at the larger picture and seeing smaller projects are a part of larger projects...

    (I think that made sense)
  • by Niban ( 227391 ) on Wednesday June 05, 2002 @12:54PM (#3645888)
    the mode is merely the most common result, which just accounts for all the personal projects that are placed on ourgeforge and go nowhere for various reasons.

    A truer survery would take into account codebase size vs. contributers or some other measure. (Which I believe occured some time back, with similar results to this one, the majority of work was done by a small group of individuals)
    • by elflord ( 9269 ) on Wednesday June 05, 2002 @01:01PM (#3645954) Homepage
      he mode is merely the most common result, which just accounts for all the personal projects that are placed on ourgeforge and go nowhere for various reasons.

      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, ..... )

  • Even in my company, which uses eXtreme programming, we sometimes find ourselves engaged in solitary hacking. The code we write is an expression of the way our very thoughts are organized. It's difficult to get two people aligned in the way they decompose a problem. Even relatively well-defined and small subtasks can be approached from radically different angles.

    So it's no wonder that most projects have few developers. It takes like minds, or people who have extraordinary capacity for fruitful disagreement, to build software.

    Also, most programmers take pleasure in re-inventing wheels (I am not among them). It's the solving, and not the solution, that thrills them. That means that you'll see multiple solutions to the same problems, each sponsored by a small number of people.
  • But has the individual maintainer changed over time? This is one aspect of the open source development model(s) that their conclusion seems to be overlooking. Even though "mature" software seems to be mostly maintained by individuals, those maintainers tend to change over time.

    Further, isn't this somewhat self-selecting? In other words, is mature software generally software that requires the least active development?
  • by InterruptDescriptorT ( 531083 ) on Wednesday June 05, 2002 @12:57PM (#3645919) Homepage
    ...that the OSS always seems to turn out better than commercial software?

    I am a software developer for a video driver developer in a team of about 7. I'm disgruntled as hell--the process is overwhelming, the design is far too rigid and thus things take about ten times as long as they would be a smaller team. Yet, when I go home and work on my personal projects, I'm as happy as can be. No code standards, no review processes, no cumbersome integrating of six other peoples' changes into my code, nothing.

    If the success of small-team OSS projects is any indication, why do software managers think that throwing more people on a project will increase efficiency? It won't!
    • by Steve G Swine ( 49788 ) on Wednesday June 05, 2002 @01:04PM (#3645992) Journal
      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...
    • by Mr_Silver ( 213637 ) on Wednesday June 05, 2002 @01:08PM (#3646031)
      ...that the OSS always seems to turn out better than commercial software?

      (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.

      • I take on that MS Office comment. There is little that I HATE more that trying to deal with an app that's thinking for me. Word and that stupid fscking talking paper clip drive me nuts. It's one thing to have functionality, it's another to have that functionality forced on you.

        Example: "smart" tabbing and numbering for lists.

        I know that you can turn a LOT of that stuff off, but not all of it and it's unclear how to turn it off at times.

        generally OSS is of a slightly poorer quality than commercial

        Yeah, maybe, but just slightly. Gnome, KDE, Mozilla, Evolution and OpenOffice are quickly closing that gap. That's all I run at home!
      • Such discussions are really quite silly.

        Is a Civic Sedan better than a Civic Wagon?
        Is a Dodge Intrepid better than a Dodge RAM?
        Is a BMW 330i better than a 325i?

        Different products provide different definitions of better depending on the needs/wants/desires of the particular consumer. The parent poster thinks OSS is better than commercial because he probably only cares if it's free and comes with source. He likely could care less about features, functionality, ease of use and so forth.

        You think Apache is better than IIS, maybe because you only care about serving static content and don't care about the efficiency advantages of using Microsoft's development tools for creating dynamic web sites. You also don't think OpenOffice is better than MSOffice... But maybe for someone who had little money to spend and limited needs, they would disagree.

        The key really is to identify the advantages and disadvantages of any given product. If that set matches closely the requirements of the consumer, the product is probably better for their particular use.

        The original poster was being totally ridiculous when he used the word always because that really could never be true for all consumers. But I think it's important whenever you use the word better that you take the time to define the constraints.
      • I still find OpenOffice poorer than MS Office

        What specific features does the OpenOffice.org 1.0 suite lack? OpenOffice.org even has the "show codes" feature from WordPerfect, as its file format is simply a tarball of XML documents.

        GIMP poorer than Photoshop

        GIMP is as powerful as Adobe Photoshop Elements ($100). If GIMP were as powerful as the full version of Photoshop, the developers would have to charge $400 a copy to pay Pantone for the right to do CMYK conversion. What non-patented bitmap editing features are you looking for that GIMP doesn't provide?

  • It's nearly impossible to build software without someone being in charge. In traditional software development, that's your manager, or the CTO, or the CEO, etc. In linux, there's linus to guide the direction of the software the way he wants it to go.

    I bet you'll see that even with the major projects with 4 people working on it, there is a definitive one that stands out as the lead developer. Testing and bug fixing can be worked on by many people independently, but when it comes to developing the actual software, there needs to be a single person to make the ultimate large scale decisions.

  • Not startling (Score:2, Insightful)

    by fizban ( 58094 )
    This is absolutely not startling at all. Most projects are started with an idea. Ideas are generated by individuals. Therefore, most projects are the work of individuals. But the same can be said for "normal" closed-source businesses as well. They are started by individuals.

    The difference however, is that most open source projects are done in "spare" time while most closed source projects are done in "work" time. Work time is usually well-funded and allows for the creation and gathering of additional resources, while spare time work is in the same nature of hobbies and is self-funded, which makes it hard to justify adding additional resources. More resources means more to manage and the cost analysis tends to steer people away from wanting to do that. Open source projects are usually started as a way for someone to have fun with a topic they are interested in or to learn new skills. They are not started with the intention of creating more management headaches.

    If you really think about it, it's not that surprising that most open source projects are run by individuals.

    Open source is not really about communities coming together to contribute to a project. Open source is really about communities learning and growing from the shared knowledge of the individuals in that community.
    • This is absolutely not startling at all. Most projects are started with an idea. Ideas are generated by individuals.

      And are stewarded by individuals. Think of all the OSS projects and the "names" that go with them -- Sendmail, Eric Allman; Samba, Jeremy Allison; Linux, Linus Torvalds; Qmail, Dan Bernstein. Perl, Larry Wall; It goes on and on.

      It's actually kind of scary to me since I wonder how many driven-by-one-man projects like this will collapse (ie, stop development or otherwise rot) without the guy that made the magic originally.

      I'm encouraged by the fact that most large, popular projects are too big for one guy to actually do all the coding and usually there are people waiting in the wings who can at least add some legs to these projects.
  • Given the nature of open source development, a programmer would have to have an interest in the project itself if they wanted to contribute. For a few months, I was an active participant in the Quadra [sourceforge.net] project. My role was revising the documentation (available at Geocities [geocities.com]). I've played around with the source a little bit, but now, I just enjoy playing the game. There is one person who posted to the Quadra discussion list that he wants to revive the project. The lead developer replied to the discussion list that many of the key developers are busy with other things, but he is more than welcome to take Quadra in a new direction. At last count, Quardra had 18 people working on the project.
  • by RealisticWeb.com ( 557454 ) on Wednesday June 05, 2002 @01:02PM (#3645960) Homepage
    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".
  • by melquiades ( 314628 ) on Wednesday June 05, 2002 @01:02PM (#3645964) Homepage
    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.
    • Looking at the report, I agree 100%. The study is fatally flawed. The only way to really determine the core developers on a project is to lurk on the mailing list, or ask someone. No one keeps the developer lists on SourceForge up to date (if they're ever accurate at all).
    • I would tend to agree with you -- however it goes both ways. I am in the middle of developing a project on SourceForge [sourceforge.net], and I have found that I've recieved a couple of emails containing sources (additions rather than fixes, though) which I have added, or am adding to my project.

      If you follow my link, however, you'll notice that there are 4 developers for my project -- and yet I am the only person actively working on it. So the number of submissions I've received pretty much evens out with the number of people inactively listed as members of my project. I'm not saying this is the case for all projects, but it may be the case for many of them.

    • I agree, but I don't think you stressed enough that not all open source projects are written from scratch. People take what is already written, make their modifications to it and claim it as their own. (giving it a new name, etc) Whether or not this is a good or bad thing could be debateable.
    • This study apparently takes as its presumption that the developers listed in Sourceforge projects are the developers who have actually contributed.

      Furthermore, it would seem to presume (I haven't read it, I'm basing this on the headline) that open source projects on SourceForge are a representative sample of all open source projects. Who's to say that individual developers are more likely to use SourceForge and large groups are more likely to have their own servers (e.g., Mozilla.org)? This would explain the gathered data equally well, but it is a completely different conclusion, and I think the data is not complete enough to draw either conclusion. To paraphrase Homer Simpson, "you can prove anything with statistics - 85% of all people know that."

      • Hmm, I'm wondering whether "Mature" software is the right type to be examining. Doesn't mature generally mean "finished development", and that there is little that needs to be improved or expanded for the project?

        That would tend to decrease the likelyhood of a large developer base. What I'd like to know is if consistent results are seen when the Stable/Production category is used instead of the Mature category.
  • Not exactly, but that's the best title I could come up with

    Anyway, the point is that one key developer, within a structure like open source, means that others can read what he's done, and submit patches, etc.

    What makes a lot of good Open Source Software so good is that one developer has got something that works done, and then others finetune it until it becomes a formidable thing. And others still take it and make something new out of it.

    Of course there's just one developer per project. But then each project on it's own is not worth much without a mesh of other products. The Linux model - a loosely knit team of hackers - means exactly that. But it does work. And credit to those pioneers who have the dedication to actually code a working program alone, and then put up with criticism and limited praise for no reward.

  • Don't I know (Score:5, Insightful)

    by Mr_Silver ( 213637 ) on Wednesday June 05, 2002 @01:03PM (#3645974)
    I've got a couple of GPL'ed projects (Avantslash [fourteenminutes.com], Tellyguide [fourteenminutes.com], MovieGuide [fourteenminutes.com]) and whilst they have a reasonable amount of usage, when it breaks, everyone sits around and waits until I fix it.

    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 [wibble.org.uk] 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.

    • Re:Don't I know (Score:5, Insightful)

      by bcrowell ( 177657 ) on Wednesday June 05, 2002 @01:46PM (#3646412) Homepage
      when it breaks, everyone sits around and waits until I fix it.
      Looking at the three projects you refer to, they all seem to be aimed at end-users -- they're not libraries or development tools or something lke that, meant to be used by programmers. So what do you expect?

      For the sake of illustration, I'll make up some numbers. Don't take them too seriously. I'm just trying to make a point. Suppose you have 10,000 downloads. Maybe 1,000 of those people actually end up using the software on a regular basis. Out of those, maybe 10 are programmers. Out of those 10, a lot of them probably (a) don't encounter the bug, (b) don't have the specific skills and knowledge needed to work on your code, or (c) are hard at work on their own open-source projects, to which they can contribute more efficiently.

      Anyone who's tried to install any amount of open-source software knows that it can be a huge hassle just to compile things from source, even without modification. The original programmer tends to think it's easy to work on his code, because he's all set up. He has the right libraries, he's used to his own way of using autoconf, etc. etc.

      Just be thankful that people report bugs at all.

      • I think he was expecting the wonderful utopia portrayed in ESR's book.

        Maybe the point is that people ought to tone down some of the utopian rhetoric, because in the real world things are different.
    • 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.

      It depends on the amount of interest the project generates, how well you get the word out, etc. It sounds like people do report bugs and while, ideally, they would submit patches with the reports, the are reporting bugs you might never have known about and hence never been able to fix, so the quality of your software has benefited directly as a result (even if you have done all the work actually fixing it yourself).

      The kind folks at Blender misunderstood the entire software freedom paradigm, as well as the dynamics of free software and open source projects. People have to be interested and excited to spend their valuable (and ever shrinking) free time contributing. They GPLed a skeletal distributed rendering arbiter daemon, then sat back and waited for the community to finish writing the project. When that didn't happen (after all, it was usable in its current form to those of us who knew how to use it, so we used it, reported bugs, and submitted the occasional patch), they concluded that they would have had not gain had they GPLed Blender itself.

      Perhaps not, but there are other GPLed 3d modelling and rendering projects that suggest otherwise. It is much more exciting for a programmer/animator/film hobbiest to work on sexy new special effects modules and features for a project than a back-end, distributed rendering daemon that most people don't have the equipment (read: more than one computer) to use anyway.

      So they got bad data, made what IMHO was a very bad strategic decision as a result (to not GPL Blender and concentrate on business approaches to leverage that) and now Blender the product and NaN the company are dead, and the community of enthusiasts that grew around it is dying alongs side it. A loss to the animation community, to the Linux community, and quite probably a loss to NaN (the makers of Blender) as well.

      Another way they didn't understand software freedom was their insistence that "no one will ever have to pay to use blender" (a very kind goal, but NOT what free software is about). There were any number of approaches they could have used in giving out software gratis (charge for documentation, charge for the current version and keep the gratis/libre version a few months behind the pay-to-use version, etc.), that would have been obvious had they understood the philosophy, mindset, and implications of free software and the (software) freedom it represents.

      Hmm, I didn't really mean for this to become a requiem for Blender, but in any event I don't blame you at all for being put off by 50 greedy (and likely ungrateful) wretches demanding your code, but remember that this is about freedom, yours as much as those 50 ungrateful wretches (some of whome are, quite likely, deliberate trolls or perhaps even MS astroturf-style agent provoceteurs who want you to become disillusioned. The latter would sound utterly paranoid to me, had I not seen it firsthand in action in another context [unrelated to Microsoft]). The bottom line is do you benefit, and are the benefits worth it to you for you to free your code? If the bug reports and community that grows around your tool is beneficial to you, and the quality of your code, then perhaps it is. If not, then obviously it isn't (though perhaps being able to hand-off your code to someone else when you grow weary, or bored, with the project so that it can continue to develop and grow may make it worth your while anyway).

      In any event, its your code to do with as you please, and while effusive gratitude for your doing what many thousands of others think nothing of doing (freeing your code) may not be a realistic thing to expect, I sympathise greatly with your disgust at the ungratefulness many users of free software seem all to eager to display.

      BTW - If you're running GNU/Linux, X, KDE/gnome, etc. you aren't the only person going to the bizar and helping out ... you're just the only person who happens to be managing your stall in the bizar at the moment. :-)
    • Wow, I'm suprised that almost everyone in this thread agrees that their projects suffer from a lack of willing contributors. My project [kde.org] (which is definitely for end-users) has what I consider to be a healthy base of about 4 regular contributors. Each time, I got an email from out of the blue saying they liked my program and wanted to help out. While I would say I still write the majority of the code, the contributions from my co-devs have been significant and invaluable to the project, and they've been actively contributing for months.

      I also consider bug reports and feature requests to be a very important contribution. I'm always shocked to hear OSS devs say that this kind of feedback is essentially useless.

      Ah well, just wanted to throw in my $0.02. OSS does work like it's supposed to sometimes. I'm glad it did in my case, I think it would be much less fun if I was still the only one working on my project.
      • by dirk ( 87083 )
        I also consider bug reports and feature requests to be a very important contribution. I'm always shocked to hear OSS devs say that this kind of feedback is essentially useless.

        While these things are not useless by any stretch of the imagination, it certainly doesn't require an open source program to get them. They are useful to all programmers and are turned in by users on all programs. OSS has always been talked about with the idea that people will not only report bugs, but will also sumbit bug fixes. It's not the fact they they are only getting bug reports that is the problem, it's the fact that they aren't getting any of the benefits that are supposed to come with open source.
  • Count Accuracy (Score:2, Interesting)

    by fidget42 ( 538823 )
    I do some work on FlightGear and the number of people contributing to that Open Source project is greater than the number that SF shows. I know that when I submit changes, I send them to one of the people on the SF list and they commit the changes. I would venture a guess that many programs are like this.
  • Misleading........ (Score:3, Insightful)

    by _LORAX_ ( 4790 ) on Wednesday June 05, 2002 @01:04PM (#3645988) Homepage
    This "STUDY" does not take into account all of the various audits that have taken place in the distributions that use them ( RH, OBSD, ... ) nor does it take into account all of the smaller patches that have been sent in by dedicated users. What about those projects that are "obvious" but never make it into "mature" according to source forge. I would be much more interested in the study if it included "stable/production" projects as well.

    I would say this study does more to sterotype OSS developers as 1-man shows rather than a developer with LOTS of feedback from their users.
  • I'd have said this is completely obvious: the fast majority of projects are done by one or two people and highly successful projects are much more likely to have large developer communities.

    But there seems to be such a strong idea [slashdot.org] that as soon as you put a project on Freshmeat or Sourceforge, a pack of developers rushes in to join your team, while a vaster number reviews your code, finds bugs and seurity holes and submits patches. As long as Eric Raymond continues to insist that that's the rule and not the exception, it's valuable to have studies like this to demonstrate otherwise.

  • by marick ( 144920 ) on Wednesday June 05, 2002 @01:05PM (#3645997)
    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?
  • by mocm ( 141920 ) on Wednesday June 05, 2002 @01:06PM (#3646007)
    when they say that the open source community is not a community. Not only are many open source projects not that large that they need a whole bunch of developers, but even then most of them depend on feedback from the users who report bugs and send in small fixes and even suggestions for further development. Those people usually are not listed as developers, but are sometimes mentioned and thanked in the READMEs. They are nevertheless as much part of the development process as the ones that develop the program. And may even become developers themselves after some time. They form the community.

    Furthermore, I am not sure if sourceforge is an accurate representation of the OSS community.
  • The paper is only as good as the data from which it is derived.

    He used data from SourceForge, and (apparently, I couldn't read through the whole thing) did not contact the individual projects for specifics.

    Who is to say that just because a project is on sourceforge, that this is the only means being used to manage the development of the project.

    A project may only have one developer listed in sourceforge, but who's to say that the sole developer listed is only the maintainer, and the maintainer collects bugfixes, feature upgrades, etc. by some other means (for example a personal CVS server), then thakes the code fixes and publishes them to SourceForge for distribution?

    Add that to the countless small bigfixes that are sent into developers via email from random people, and it's easy to through this papers theories out the window.
  • I think the difference Open Source makes is not the amount of developers dedicated to the project, but the pool of developers from which these will be chosen.

    Basicly, there can only be a limited number of people in any reasonably sized project before they start stepping on each other's toes. Other people can only give very limited help (report bugs, mostly) without breaking their stuff, which is not too satisfying.

    The thing is that when these people disappear or lose interest, there is a greater pool of people aware of the project and with knowledge of the code who can step in and take their place.
  • Brats (Score:2, Flamebait)

    by litewoheat ( 179018 )
    This is because most OSS programmers are whiny little kids who don't work together well. Just look at the flame fests within the Linux community. Its only a matter of time before Linux forks dramatically with people (like JWZ (not JWZ, like JWZ)) taking their toys and going elsewhere. OSS was doomed from the start. This is not utopia. Everyone is not "in it" for the common good. OSS depends on that and that is its biggest weakness.
    • No. Most people are "in" OSS because they are scratching their own itch. I work on an OSS project because by building on a project that was already underway by another company, my company can save lots of money (and have the added security that people outside our company knows how the software works, so that we can hire external people if we need to, something that has already saved our butts once).

      Similarly, tons of people work on OSS projects because things they need are already there, and it is cheaper / simpler for them to add the feature they want instead of writing it from scratch.

      As for Linux forking, Linux has already been forked tons of times. Linus more or less encourages it, in fact, as it stops a lot of people that are filling weird niches that only a few people need from spending lots of his time to get their obscure stuff into the mainstream kernel.

      Forks aren't bad unless they detract effort from eachother. In the case of Linux it's the other way around: General purpose changes that Linus likes go in the mainstream kernel, while stuff he doesn't want to put in the mainstream kernel is developed outside the mainstream tree and thus doesn't take up the time of Linus or other vital core developers. They don't detract from eachother - they complement eachother.

  • Mythical Man Month (Score:2, Informative)

    by fisman ( 66079 )
    According to the Capability Maturity model [cmu.edu] the only way a company on level 1 - Initial (also called chaos) can be a success is if there are so-called super-programmers saving but most of the time.

    In my experience of working on open-source most projects are governed by chaos and judging them according to the CMM there cannot be a single open source project on anything above level 1.

    This leaves one to, by logical deduction, assume that open source projects can only be a success if there are a couple of super-human programmers involved.

    I think most of you guys will agree that this has been proven in practice over and over again.

    Unfortunately due to the eccentric nature of these extraordinary programmers it is very seldom that more than 2-3 of them can agree and co-exist without trying to prove themselves superior.

    If it was possible to move a opensource project to level 3 or 4 and get a team of say 100 programmers working on it we could tackele a large project in a small timeframe and thus speed up progress by a couple of orders in magnitude.

    According to F.P. Brooks in The Mythical Man Month this has been one of the major limitations in getting big projects done - they need big teams to be complete before they are obsolte - and this is the area where opensource needs some work.

    According to me that is - of course
    • In my experience the Capability Maturity Model is of more value to managers justifying their existence than a guide to creating a successful software development process. I understand that this may just reflect my personal bias. Has anyone here participated in successful software development organizations with a high CMM? Has any widely used software been developed by such an organization (I know Microsoft must score a 1, which isn't necessarily an argument against the CMM)?
      • by xphase ( 56482 )
        I currently work on a project that is CMM Level 4 rated, and we will be going for Level 5 next year. Our software is not what you would call widely used(not for consumers, but for Govt.). The main thing that using the CMM model does for us is in finding software defects.

        With the number of reviews and the incremental development lifecycle, we catch most of our bugs way before the software is shipped to the customer. This is a very good thing, because the software is not very easy to upgrade or patch once in the field.

        If our customer suddenly asks us to use an older version of the software to test certain features on hardware(An older version which has no extra code, so testing the hardware is easier), we can go and get the exact version that was shipped, apply any necessary fixes, and deliver in almost no time.

        The main thing that CMM forces you to use is a process. Everything is based on processes. How to build the software, how to report a defect, how to note the fix in the CM database, how to keep track of versions, how to ship, etc. Everytime you do anything you follow the process. It's annoying at times, but it allows everything to be repeated exactly. By optimizing the process we can "speed" up development time(our ship dates are known years in advance, so it just means that we make deadlines). It also means that when customers are looking for a company to provide them with a solution, they see that if we have created successful projects in the past, then we probably will be able to repeat the success on a new project.

        I think that some things in the CMM are very good, but I also don't see them as being able to apply very well to the open source world, primarily because it requires large amounts of time to make sure the processes are correct, time that developers don't want to spend(Thank goodness for managers).

  • by DeadSea ( 69598 ) on Wednesday June 05, 2002 @01:18PM (#3646107) Homepage Journal
    I doubt that this includes the developers of the open source libraries that a project uses. If a game uses the SDL libraries, do the SDL developers get counted? Probobly not.

    I am probably a developer on a dozen projects that use my open source Java libraries [ostermiller.org]. Open source is just different than normal development.

  • Bah. (Score:3, Informative)

    by cjpez ( 148000 ) on Wednesday June 05, 2002 @01:20PM (#3646142) Homepage Journal
    If he's only using Sourceforge as the primary data source, then things are obviously going to be skewed. How many times have you contributed to an Open-Source project by emailing a patch to a mailing list or an author? Let me guess how often that shows up on sourceforge. It's like Freshmeat's "Vitality Rating." Unless you do ALL of your project management stuff via Freshmeat, it considers you basically a dead project.
  • Testing (Score:2, Insightful)

    One thing that takes a lot of man hours to do is testing. If the software crashes, a OSS user is many times able to do a backtrace on the core file and give vital information to the developer. This is much harder to do in a commercial product because you usually have to remove any debugging information. Even more mature OSS projects usually go through a release candidate phase. The "release early, release often..." quotes heard with OSS implies we are using you as software testers. Also a user is more likely to submit bug reports if they know they will be heard and the quickly fixed. Another reason bugs are fixed quickly is because of the pride and ego associated with the software.
  • No surprise here (Score:5, Insightful)

    by Rogerborg ( 306625 ) on Wednesday June 05, 2002 @01:25PM (#3646204) Homepage

    What did we expect, that the Mongolian Hordes [tuxedo.org] technique actually works, or that Brooke's Law [tuxedo.org] 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 [tuxedo.org] 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.

    • 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.

      Damn straight. I think what the author wanted was a quick and easy way to get at some 'real' numbers. Unfortunately due to the nature of the 'community', that just doesn't exist. The author would have to spend months looking through mailing list logs to see who submitted what, and how much weight to give that 'code author', based on what his/her patch did for the project.

      Personally, I've done the same as a lot of people here. I've submitted patches to projects, though only one of those is on SF (photoseek), and that one is VERY inactive. The other projects are NOT on SF, and in some cases my patches havn't been accepted, or were overridden because the original author did it better. Motion - motion.technolust.cx, is what comes to mind. The authors implementation of muliple cameras is much better than my hack. (though it wasn't a patch to an app per-say, just an 'external' solution)

      Should I be counted because my 'fix', wasn't (rightly) accepted into the project, though it did solve some peoples problems? Or would my Photoseek submission only be accepted, though it was quite small, and the project is quite inactive?

      In fact, everyone who downloads, compiles and runs the source is testing the code to some extent.

      No kidding, how could the author include individual bug reports? He'd have to assign some kind of weight to them, and hope he could sort a project-bug mailing list by author :) I can't count the number of times I've seen a good bug report directly influence a patch on wine-devel. Does only one 'developer' get credit then?

      IMHO, it's definately a good idea to try and quantify things, but I think the author could make things worse by not spending the right amount of time on it.

      • 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.

        Damn straight. I think what the author wanted was a quick and easy way to get at some 'real' numbers. Unfortunately due to the nature of the 'community', that just doesn't exist. The author would have to spend months looking through mailing list logs to see who submitted what, and how much weight to give that 'code author', based on what his/her patch did for the project.

        Double damn straight. And even going through mailing list logs wouldn't be much of a help. 95% of the projects I've fixed bugs in it's been a quick email to the author to fix a segfault or an innapropriate strcpy call, something trivial like that for a project I'm not really involved with and just want to fix up so I can use it. No point even subscribing to a mailing list, just drop an email to the author.

  • I'm one of the maintainers of the epp-rtk project on SourceForge. The project has 9 registered developers. But most of the contribution from outside Tucows and the company I work for (GNR) has come from people that are NOT registered as developers for the project, but that are users of the software that has mailed us ideas, suggestions and patches.

    And this is for a piece of software with a very limited group of users (ICANN accredited registrars).

  • Involvement in open source projects is often a negative in my experience if only because it shows an inability to work in teams. Even if you're borderline the open source project is something your bosses will point to when layoff time comes. You don't want to give anyone something to point to and you don't want to get too cozy with open source projects.
  • This conclusion is probably bogus. In all the OS projects that I am involved in or use, most contributors submit patches and are not even registered to do any CVS check-ins.
  • A few individuals? (Score:2, Insightful)

    by phpdeb ( 563275 )
    The poster seems to suggest that a few individuals isn't a community. The open source community is a bunch of individuals. This is really not news. How programmers are working on Samba or Apache, not many. You don't need shitloads of programmers on it a project or want a shitload of programmers on project.

    I am not going reiterate stuff that has already been written down in books, but more programmers doesn't equal more program - usually the other way around.

    I work on a team of 3 and 2 or us are programmers and on is a ui designer/manager. It works well and we crank out some pretty fantastic stuff.
  • by Lucas Membrane ( 524640 ) on Wednesday June 05, 2002 @02:06PM (#3646591)
    It's the number of users, counting testers, that matters. Feedback is the main thing. Most bugs can be located quickly, if their existence is realized. The shops that do high quality either spend considerable time on reviews or considerable time on testing (like 3 testers per developer). Unfortunately, there are about 300 people who want to be a developer for everyone who wants to be a tester.

    Open source can get many users emailing in bug reports if it is easy to do so (please don't make me subscribe to an email list to send in a bug report). The interesting statistic that I'd like to see is the percentage of open source projects that are in beta. It seems like the 'good' version of open source projects, ie the one with the 'must have' features, is almost never done, but often in alpha or beta, and I can be a tester for free. I like to do that, but I can't afford to do it for every piece of software that I use, sorry.

  • While a single maintainer or developer wouldn't suprise me, I think that just by virtue of it being open many people submit bug reports more readily and or bugfixes where neccesary. This is where the "many eyes" come in.
  • By examining only those projects hosted by sourceforge, the author is biased against the most mature Open Source projects of all (none of which can be found there). Some of these being: the Linux kernel, Apache, bind, sendmail, Perl, Python, Mozilla, etc...

    All of these are developed by a community.

    So there...
  • I'm a maintainer for a project on sourceforge where we currently have about 15 members listed *on* the project page. However, we really have many more developers working on the project that don't have an account because they don't want/need cvs commit access, they work on other parts of the project that don't require them to have an account, and many other reasons. Plus there are many more people who aren't consistant developers, but they contribute from time to time.

    So, this is a poor way of tracking the number of developers working on projects and such a statement can't be made based only on this data.
  • Based on a study of the top 100 mature products on SourceForge
    Saying that open-source projects are small is not accurate. The largest open source projects aren't on SourceForge. Mozilla, linux kernel, KDE, GNOME, Apache... SourceForge is a home for small projects that can't afford to have their own CVS server, website, FTP server, etc.
    • Exactly!

      And the article also seems to go out of its way to make some unfounded slams too. Such as:

      "The median number of project administrators was 1. In fact, the largest number of developers in a project was 42 - a far cry from the high numbers reported previously."

      Previously to what? Where is the link to the previous report or findings?

      "Others have pointed out that Torvalds essentially did not have a life and spent considerable number of hours rewriting code submissions by others."

      If he enjoyed what he was doing, who are they to say he didn't have a life?

      I would personally say that my own meager involvement with Sourceforge has been to learn by experiencing at least some of the open-source collaboration. I'm glad it is there, regardless of this apparent negative press about open-source developers numbers.

  • by bobKali ( 240342 ) on Wednesday June 05, 2002 @02:20PM (#3646695) Homepage
    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" ...
  • Explains a lot (Score:2, Interesting)

    by Anonymous Coward
    This very nicely explains why OSS projects as a general rule aren't as usable and polished as most commercial programs. Whether the self-described "hackers" thorughout the OSS community like to admit it or not, making truly usable software is very difficult and very time consuming. Itty bitty projects just don't have enough people to add new functions, fix bugs, write docs (assuming they write any at all, that is), and also concentrate on usability.
  • by redelm ( 54142 ) on Wednesday June 05, 2002 @03:59PM (#3647691) Homepage
    Doh! Who's surprised by this finding? I'm a small open source developer [cpuburn], and I imagine that most open source is written by induhviduals who have real problems they have to solve as part of the job, school or hobby. One person. So they write a pgm to solve it. Then publish it as open source because doing so is cheap, easy and "The Right Thing" to do. Open-source is not written infor-profit software project houses made [in]famous by Microsoft. UNIX and other Linux-like OSes encourage small pgms because many small pgms can be built up into large functionality very easily [at least on the CLI].

    From a project management perspective, small is much better because there are fewer interprosonal interfaces and less communication time needed. Heirarchical layering is only partically effective at reducing communications overhead. Architectural isolation works better. On my own project, most of the open source input has been commentary on programs or bugs, plus one big orthogonal contribution [MS-Win32 GUI]. This works. Different people hacking on different parts of the same pgm wouldn't.

    Where open-source gets weak is large GUI projects like office suites. Here, more people seem required, and it's a bit harder to assemble and manage a team of people who all have developing GUI office apps as a goal. Plus there's alot of communication overhead. The best that could be done would be via architectural compartimentalization, or better yet, if a series of tools analogous to the CLI pipeline/script could be made for the GUI world.

  • I'm not surprised in the least, since a 'fearsome foursome' is the ideal median for many of the best brainstorming committees. In publications, in comedy teams, it's surprisingly frequent.

    I'm certsin it has a lot to do with being heard. Among more than four, you can easily feel as if your contributions go unheard. Fewer than four, you lack the same critical mass of stimulus from which to springboard ideas. Seven is often a maximum for a serious core group, and every dozen tends to have a Judas, just by numbers.
  • by werdna ( 39029 ) on Wednesday June 05, 2002 @06:14PM (#3648825) Journal
    Typically, the number of persons who are given authority to enter contributions for projects of any size is much smaller than the number of actual contributors. In "large scale" projects, it is common for a small community of "editors" to be "responsible" for a body of code, by taking the contributions of many individuals, vetting them and ultimately adding these contributions to the code tree.

    Thus, for some projects, merely counting the number of committers underestimates the actual number of contributers certainly by one, and perhaps two or more, orders of magnitude.
  • What a freaking flawed study

    I don't think you can tell anything from his "statistics." Even if they had any relevance.
  • Has anybody thought that projects hosted on sourceforge may be projects by individuals that don't have the time and resources to set up and maintain their own repository, home page, etc..?

    This would lead me to believe that sourceforge would be more targetted towards individuals or smaller groups of developers.

    I think larger projects might be difficult to shoehorn into sourceforge, and have their own sites. Look at apache (it's site has lots of project sites) or samba (which has not only it's own site, but mirrors all over).

    I think a more meaningful analysis would include the commonly used packages in a current linux distribution. I would guess that as a package becomes more "obscure", you'll find less people working on it. Not that all the projects on sourceforge are obscure, but they may not be a representative sample.

    I'm sure some statistician can explain this more precisely.
  • Did anybody notice if he posted his raw data on the 100 projects? I'd like to see the numbers on a few specific ones.
  • "The median number of developers in the 100 projects I looked at was 4 and the mode was 1

    Really, no offense meant here, but these sorts of figures illustrate why Microsoft will womp on an Open source widget all day long and well into the night. I'm betting the teams are smaller all across the board, and while I'm sure they're giving 110% (and a healthy dose of TLC), it's tough to beat an MS programming sweatshop that way. Any open source project that wants to compete in the OS arena is going to need the cash and a strong central core of leadership; Something I don't see much of out there (exceptions noted).

Money is better than poverty, if only for financial reasons.