Better Open Source Code with Just Volunteers?

Over at OLPC News, Wayan Vota asks: "Do you get better FOSS code ... if the developers are paid or unpaid?"

Interesting question, especially as considered in light of the OLPC code base.

As of about a year ago, virtually everybody I talked to was shocked and stunned at the poor quality of the OLPC code base. My personal encounters with the code left me frustrated at the poor Python style, angry at the simultaneously over- and under-engineered build process, livid at the poor quality control, and blue about the long-term prospects of the OLPC software. I was not alone, although most people were polite enough not to be a jerk about it like me. (Looking back, perhaps if more people had been jerks earlier, things could have improved. Or not.)

At the time I felt that the OLPC code, which might have been a triumph for the OLPC project, a gem of Python code, and a win for the open source community, had turned into a cesspool of code and a potentially infinite time sink for people working on it.

I haven't revisited the project since then, and I know that community enthusiasm has waned for the OLPC. I don't think the poor quality of the code was a huge factor in this decline, but it certainly decreased the interest that serious hackers had in getting involved in the project -- at least, it did for everyone I talked with.

So, let's get back to the original question: in an OSS project, is it better to let the community write your code for you, or should you have a core development team?

Let me rephrase that another way, actually: if your business practices drive you to write crappy, hurried code, with no attention to any form of reasonable software development processes (agile or otherwise), no automated testing, and very little QA of any kind, are you better off turning software development over to the community?

The answer becomes less difficult then: yes, if it's an option, you should jettison your software development efforts. If you can't do things competently, you should remove yourself from the responsibility of doing it. Abdicating responsibility is the responsible thing to do in these circumstances, if you can make it work.

But... what went wrong, anyway? I don't know. I'd guess that the OLPC software development team was overmatched from the beginning: responsibility of developing new software for a novel mix of hardware, together with a novel GUI interface, in an environment of much enthusiasm and relatively little funding, is hard. Add to this the enthusiastic but not very disciplined-sounding roadmap, as well as the unrealistic deadlines set due to PR and political considerations, and it's a recipe for disaster. When you also throw in an overwhelmed OLPC management team, I don't think you can expect anything but disaster.

So, looking back, I think the OLPC was probably headed into a mess from day 1, and while the fubar'ed software development process didn't help, it was at least partly driven by circumstances outside the control of the software developers. The software developers were hamstrung from the get go. And in that environment, turning the majority of your software development over to someone else -- someone not under your direct control -- may in fact be the best option.

I think that's actually a much more interesting question: at what point should an organization realize that they are so incompetent at managing and doing "in-house" software development that they should try to outsource it? What metrics should they look at, and how should the decision be made?


p.s. The general question of whether to go for paid or unpaid development is silly, of course. The answer is, "it depends." Duh. The interesting question is what questions you need to ask to figure it out!

p.p.s. Disclaimer: the individual OLPC people I know, up to and including lower management, are smart, enthusiastic, and good people. I place the majority of the blame squarely at the top.

Legacy Comments

Posted by Steve Holden on 2009-02-15 at 05:52.

"""Disclaimer: the individual OLPC people I know, up to and including
lower management, are smart, enthusiastic, and good people. I place
the majority of the blame squarely at the top."""    Hear, hear. This
disastrous proof that egotistical academics do not in general make
good managers or production engineers has cost the open source
community a lot in terms of credibility. Then, after all that, a
complete about-face will have the damned things running Windows XP.
Groan.    The OLPC project appears to have suffered from the naive
belief that goodwill and intellectual capacity alone are required to
make a project succeed. It was indeed a disastrous failure of senior
management, and wasted a lot of capable programmers' time. Great idea,
terrific cause, lousy execution.

Posted by Wayan @ OLPC News on 2009-02-15 at 06:25.

Titus,    This is a great answer to my question.  Might you mention it
in the comments on that post?  Or would you be up for a Guest Post
responding to my question on OLPC News?

Posted by Titus Brown on 2009-02-15 at 16:47.

Steve, please don't tar us egotistical academics with such a broad
brush ;)    Wayan, posted.

Posted by Rene Dudfield on 2009-02-15 at 21:19.

hi,    a few thoughts on this subject...    "Do you get better FOSS
code ... if the developers are paid or unpaid?"    Code quality is
very subjective.    If you need to get code out there at the start of
a project -- to meet a deadline -- then the code quality needs to be
worse.    However, code which is not working automatically is worse
when you have deadlines.  Deadlines are why crap code is often better
than quality code.      People not working to deadlines, and not
following a budget can make better quality code in some ways.  Since
it doesn't matter if they spend four months perfecting two functions.
However being paid to work on a FOSS project allows you to tackle
greater sized projects.  Some times you need to sit down for 3 months
full time to do some projects(or even 10 years!!!).  It can be
impossible to do some types of work at 1 hour a week spread between 10
people.    Without considering the goals of a project - you can not
judge the output.  It's a very common mistake people make when
critiquing design and art.  This is why I think your analysis of OLPC
code quality is wrong.  Since you judge it based on a different
criteria.  Their goal was not to make high quality code -- they had
other goals... like shipping a laptop(amongst many other changing
goals).        cheers,

Posted by Martin on 2009-02-22 at 15:18.

What code in particular did you think was bad.  I'm not an OLPC
developer, but I have hacked on plenty of the code.  I agree there're
non-pythonic code blocks around, but that's not the same as low-
quality.  I'm interested in what you found.

Posted by Titus Brown on 2009-02-24 at 20:41.

The build system was severely hacked and failed regularly.    The base
sugar code was spaghetti-ish.    None of the code was commented.

Comments !