The Cathedral and the Bazaar, Eric S. Raymond [ebook reader below 3000 txt] 📗

The Cathedral and the Bazaar

Eric Steven Raymond

Thyrsus Enterprises

<esr@thyrsus.com>

This is version 3.0

Copyright © 2000 Eric S. Raymond

Copyright

Permission is granted to copy, distribute and/or modify this document under the terms of the Open Publication License, version 2.0.

$Date: 2002/08/02 09:02:14 $

Revision History

Revision 1.57

11 September 2000 esr

New major section “How Many Eyeballs Tame Complexity”.

Revision 1.52

28 August 2000 esr

MATLAB is a reinforcing parallel to Emacs. Corbato— & Vyssotsky got it in 1965.

Revision 1.51

24 August 2000 esr

First DocBook version. Minor updates to Fall 2000 on the time-sensitive material.

Revision 1.49

5 May 2000 esr

Added the HBS note on deadlines and scheduling.

Revision 1.51

31 August 1999 esr

This the version that O’Reilly printed in the first edition of the book.

Revision 1.45

8 August 1999 esr

Added the endnotes on the Snafu Principle, (pre)historical examples of bazaar development, and originality in the bazaar.

Revision 1.44

29 July 1999 esr

Added the “On Management and the Maginot Line” section, some insights about the usefulness of bazaars for exploring design space, and substantially improved the Epilog.

Revision 1.40

20 Nov 1998 esr

Added a correction of Brooks based on the Halloween Documents.

Revision 1.39

28 July 1998 esr

I removed Paul Eggert’s ‘graph on GPL vs. bazaar in response to cogent aguments from RMS on

Revision 1.31

February 10 1998

esr

Added “Epilog: Netscape Embraces the Bazaar!”

Revision 1.29

February 9 1998

esr

Changed “free software” to “open source”.

Revision 1.27

18 November 1997 esr

Added the Perl Conference anecdote.

Revision 1.20

7 July 1997 esr

Added the bibliography.

Revision 1.16

21 May 1997 esr

First official presentation at the Linux Kongress.

Abstract

I anatomize a successful open-source project, fetchmail, that was run as a deliberate test of the surprising theories about software engineering suggested by the history of Linux. I discuss these theories in terms of two fundamentally different development styles, the “cathedral” model of most of the commercial world versus the “bazaar” model of the Linux world. I show that these models derive from opposing assumptions about the nature of the software-debugging task. I then make a sustained argument from the Linux experience for the proposition that “Given enough eyeballs, all bugs are shallow”, suggest productive analogies with other self-correcting systems of selfish agents, and conclude with some exploration of the implications of this insight for the future of software.

Table of Contents

* The Cathedral and the Bazaar

* The Mail Must Get Through

* The Importance of Having Users

* Release Early, Release Often

* How Many Eyeballs Tame Complexity

* When Is a Rose Not a Rose?

* Popclient becomes Fetchmail

* Fetchmail Grows Up

* A Few More Lessons from Fetchmail

* Necessary Preconditions for the Bazaar Style

* The Social Context of Open-Source Software

* On Management and the Maginot Line

* Epilog: Netscape Embraces the Bazaar

* Notes

* Bibliography

* Acknowledgements

The Cathedral and the Bazaar

Linux is subversive. Who would have thought even five years ago (1991) that a world-class operating system could coalesce as if by magic out of part-time hacking by several thousand developers scattered all over the planet, connected only by the tenuous strands of the Internet?

Certainly not I. By the time Linux swam onto my radar screen in early 1993, I had already been involved in Unix and open-source development for ten years. I was one of the first GNU contributors in the mid-1980s. I had released a good deal of open-source software onto the net, developing or co-developing several programs (nethack, Emacs’s VC and GUD modes, xlife, and others) that are still in wide use today. I thought I knew how it was done.

Linux overturned much of what I thought I knew. I had been preaching the Unix gospel of small tools, rapid prototyping and evolutionary programming for years. But I also believed there was a certain critical complexity above which a more centralized, a priori approach was required. I believed that the most important software (operating systems and really large tools like the Emacs programming editor) needed to be built like cathedrals, carefully crafted by individual wizards or small bands of mages working in splendid isolation, with no beta to be released before its time.

Linus Torvalds’s style of development-release early and often, delegate everything you can, be open to the point of promiscuity-came as a surprise. No quiet, reverent cathedral-building here-rather, the Linux community seemed to resemble a great babbling bazaar of differing agendas and approaches (aptly symbolized by the Linux archive sites, who’d take submissions from anyone) out of which a coherent and stable system could seemingly emerge only by a succession of miracles.

The fact that this bazaar style seemed to work, and work well, came as a distinct shock. As I learned my way around, I worked hard not just at individual projects, but also at trying to understand why the Linux world not only didn’t fly apart in confusion but seemed to go from strength to strength at a speed barely imaginable to cathedral-builders.

By mid-1996 I thought I was beginning to understand. Chance handed me a perfect way to test my theory, in the form of an open-source project that I could consciously try to run in the bazaar style. So I did-and it was a significant success.

This is the story of that project. I’ll use it to propose some aphorisms about effective open-source development. Not all of these are things I first learned in the Linux world, but we’ll see how the Linux world gives them particular point. If I’m correct, they’ll help you understand exactly what it is that makes the Linux community such a fountain of good software-and, perhaps, they will help you become more productive yourself.

The Mail Must Get Through

Since 1993 I’d been running the technical side of a small free-access Internet service provider called Chester County InterLink (CCIL) in West Chester, Pennsylvania. I co-founded CCIL and wrote our unique multiuser bulletin-board software-you can check it out by telnetting to locke.ccil.org. Today it supports almost three thousand users on thirty lines. The job allowed me 24-hour-a-day access to the net through CCIL’s 56K line-in fact, the job practically demanded it!

I had gotten quite used to instant Internet email. I found having to periodically telnet over to locke to check my mail annoying. What I wanted was for my mail to be delivered on snark (my home system) so that I would be notified when it arrived and could handle it using all my local tools.

The Internet’s native mail forwarding protocol, SMTP (Simple Mail Transfer Protocol), wouldn’t suit, because it works best when machines are connected full-time, while my personal machine isn’t always on the Internet, and doesn’t have a static IP address. What I needed was a program that would reach out over my intermittent dialup connection and pull across my mail to be delivered locally. I knew such things existed, and that most of them used a simple application protocol called POP (Post Office Protocol). POP is now widely supported by most common mail clients, but at the time, it wasn’t built in to the mail reader I was using.

I needed a POP3 client. So I went out on the Internet and found one. Actually, I found three or four. I used one of them for a while, but it was missing what seemed an obvious feature, the ability to hack the addresses on fetched mail so replies would work properly.

The problem was this: suppose someone named `joe’ on locke sent me mail. If I fetched the mail to snark and then tried to reply to it, my mailer would cheerfully try to ship it to a nonexistent `joe’ on snark. Hand-editing reply addresses to tack on <@ccil.org> quickly got to be a serious pain.

This was clearly something the computer ought to be doing for me. But none of the existing POP clients knew how! And this brings us to the first lesson:

1. Every good work of software starts by scratching a developer’s personal itch.

Perhaps this should have been obvious (it’s long been proverbial that “Necessity is the mother of invention”) but too often software developers spend their days grinding away for pay at programs they neither need nor love. But not in the Linux world-which may explain why the average quality of software originated in the Linux community is so high.

So, did I immediately launch into a furious whirl of coding up a brand-new POP3 client to compete with the existing ones? Not on your life! I looked carefully at the POP utilities I had in hand, asking myself “Which one is closest to what I want?” Because:

2. Good programmers know what to write. Great ones know what to rewrite (and reuse).

While I don’t claim to be a great programmer, I try to imitate one. An important trait of the great ones is constructive laziness. They know that you get an A not for effort but for results, and that it’s almost always easier to start from a good partial solution than from nothing at all.

Linus Torvalds, for example, didn’t actually try to write Linux from scratch. Instead, he started by reusing code and ideas from Minix, a tiny Unix-like operating system for PC clones. Eventually all the Minix code went away or was completely rewritten-but while it was there, it provided scaffolding for the infant that would eventually become Linux.

In the same spirit, I went looking for an existing POP utility that was reasonably well coded, to use as a development base.

The source-sharing tradition of the Unix world has always been friendly to code reuse (this is why the GNU project chose Unix as a base OS, in spite of serious reservations about the OS itself). The Linux world has taken this tradition nearly to its technological limit; it has terabytes of open sources generally available. So spending time looking for some else’s almost-good-enough is more likely to give you good results in the Linux world than anywhere else.

And it did for me. With those I’d found earlier, my second search made up a total of nine candidates-fetchpop, PopTart, get-mail, gwpop, pimp, pop-perl, popc, popmail and upop. The one I first settled on was `fetchpop’ by Seung-Hong Oh. I put my header-rewrite feature in it, and made various other improvements which the author accepted into his 1.9 release.

A few weeks later, though, I stumbled across the code for popclient by Carl Harris, and found I had a problem. Though fetchpop had some good original ideas in it (such as its background-daemon mode), it could only handle POP3 and was rather amateurishly coded (Seung-Hong was at that time a bright but inexperienced programmer, and both traits showed). Carl’s code was better, quite professional and solid, but his program lacked several important and rather tricky-to-implement fetchpop features (including those I’d coded myself).

Stay or switch? If I switched, I’d be throwing away the coding I’d already done in exchange for a better development base.

A practical motive to switch was the presence of multiple-protocol support. POP3 is the most