The Cathedral and the Bazaar | Page 2

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