Free For All - How Linux and the Free Software Movement Undercut the High Tech Titans, Peter Wayner

10. Freedom

The notion embodied by the word “free” is one of the great marketing devices of all time. Cereal manufacturers know that kids will slog through bowls of sugar to get a free prize. Stores know that people will gladly give them their names and addresses if they stand a chance of winning something for free. Car ads love to emphasize the freedom a new car will give to someone.

Of course, Microsoft knows this fact as well. One of their big advertising campaigns stresses the freedom to create new documents, write long novels, fiddle with photographs, and just do whatever you want with a computer. “Where do you want to go today?” the Microsoft ads ask.

Microsoft also recognizes the pure power of giving away something for free. When Bill Gates saw Netscape's browser emerging as a great competitive threat, he first bought a competing version and then wrote his own version of a web browser. Microsoft gave their versions away for free. This bold move shut down the revenue stream of Netscape, which had to cut its price to zero in order to compete. Of course, Netscape didn't have revenues from an operating system to pay the rent. Netscape cried foul and eventually the Department of Justice brought a lawsuit to decide whether the free software from Microsoft was just a plot to keep more people paying big bucks for their not-so-free Windows OS. The fact that Microsoft is now threatened by a group of people who are giving away a free OS has plenty of irony.

The word “free” has a much more complicated and nuanced meaning within the free software movement. In fact, many people who give away their software don't even like the word “free” and prefer to use “open” to describe the process of sharing. In the case of free software, it's not just an ad campaign to make people feel good about buying a product. It's also not a slick marketing sleight of hand to focus people's attention on a free gift while the magician charges full price for a product. The word “free” is more about a way of life. The folks who write the code throw around the word in much the same way the Founding Fathers of the United States used it. To many of them, the free software revolution was also conceived in liberty and dedicated to certain principles like the fact that all men and women have certain inalienable rights to change, modify, and do whatever they please with their software in the pursuit of happiness.

Tossing about the word “free” is easy to do. Defining what it means takes much longer. The Declaration of Independence was written in 1776, but the colonial governments fought and struggled with creating a free government through the ratification of the current United States Constitution in 1787. The Bill of Rights came soon afterward, and the Supreme Court is still continually struggling with defining the boundaries of freedom described by the document. Much of the political history of the United States might be said to be an extended argument about the meaning of the words “free country.”

The free software movement is no different. It's easy for one person to simply give their software away for free. It's much harder to attract and organize an army to take on Microsoft and dominate the world. That requires a proper definition of the word “free” so that everyone understands the rights and limitations behind the word. Everyone needs to be on the same page if the battle is to be won. Everyone needs to understand what is meant by “free software.”

The history of the free software world is also filled with long, extended arguments defining the freedom that comes bundled with the source code. Many wonder if it is more about giving the user something for nothing, or if is it about empowering him. Does this freedom come with any responsibilities? What should they be? How is the freedom enforced? Is freeloading a proper part of the freedom?

In the early years of computers, there were no real arguments. Software was free because people just shared it with each other. Magazines like Creative Computing and BYTE published the source code to programs because that was an easy way to share information.

People would even type in the data themselves. Computers cost money, and getting them to run was part of the challenge. Sharing software was just part of being neighborly. If someone needed to borrow your plow, you lent it to them when you weren't using it.

This changed as corporations recognized that they could copyright software and start charging money for it. Most people loved this arrangement because the competition brought new packages and tools to market and people were more than willing to pay for them. How else are the programmers and the manual writers going to eat?

A few people thought this was a disaster. Richard Stallman watched the world change from his office in the artificial intelligence labs of MIT. Stallman is the ultimate hacker, if you use the word in the classical sense. In the beginning, the word only described someone who knows how to program well and loves to poke around in the insides of computers. It only took on its more malicious tone later as the media managed to group all of those with the ability to wrangle computers into the same dangerous camp. Hackers often use the term “cracker” to refer to these people.

Stallman is a model of the hacker. He is strident, super intelligent, highly logical, and completely honest. Most corporations keep their hackers shut off in a back room because these traits seem to scare away customers and investors who just want sweet little lies in their ears. Stallman was never that kind of guy. He looked at the burgeoning corporate control of software and didn't like it one bit. His freedom was slowly being whittled away, and he wasn't the type to simply sit by and not say anything.

When Stallman left the AI lab in 1984, he didn't want to be controlled by its policies. Universities started adopting many of the same practices as the corporations in the 1980s, and Stallman couldn't be a special exception. If MIT was going to be paying him a salary, MIT would own his code and any patents that came from it. Even MIT, which is a much cooler place than most, couldn't accommodate him on staff. He didn't move far, however, because after he set up the Free Software Foundation, he kept an office at MIT, first unofficially and then officially. Once he wasn't “on the staff,” the rules became different.

Stallman turned to consulting for money, but it was consulting with a twist. He would only work for companies that wouldn't put any restrictions on the software he created. This wasn't an easy sell. He was insisting that any work he did for Corporation X could also be shared with Corporations Y and Z, even if they were direct competitors.

This wasn't how things were done in the 1980s. That was the decade when companies figured out how to lock up the source code to a program by only distributing a machine-readable version. They hoped this would control their product and let them restrain people who might try to steal their ideas and their intellectual property. Stallman thought it was shutting down his ability to poke around inside the computer and fix it. This secrecy blocked him from sharing his thoughts and ideas with other programmers.

Most programmers looked at the scheme of charging for locked-up binary versions of a program as a necessary evil. Sure, they couldn't play around with the guts of Microsoft Windows, but it also meant that no one could play around with the guts of the programs they wrote. The scheme locked doors and compartmentalized the world, but it also gave the creator of programs more power. Most programmers thought having power over their own creation was pretty neat, even if others had more power. Being disarmed is okay if everyone else is disarmed and locked in a cage.

Stallman thought this was a disaster for the world and set out to convince the world that he was right. In 1984, he wrote the GNU Manifesto, which started his GNU project and laid out the conditions for his revolution. This document stood out a bit in the middle of the era of Ronald Reagan because it laid out Stallman's plan for creating a virtual commune where people would be free to use the software. It is one of the first cases when someone tried to set down a definition of the word “free” for software users. Sure, software and ideas were quite free long ago, but no one noticed until the freedom was gone.

He wrote,

I consider that the golden rule requires that if I like a program I must share it with other people who like it. Software sellers want to divide the users and conquer them, making each user agree not to share with others. I refuse to break solidarity with other users in this way. . . . So that I can continue to use computers without dishonor, I have decided to put together a sufficient body of free software so that I will be able to get along without any software that is not free.

The document is a wonderful glimpse at the nascent free software world because it is as much a recruiting document as a tirade directed at corporate business practices. When the American colonies split off from England, Thomas Paine spelled out the problems with the English in the first paragraph of his pamphlet “Common Sense.” In his manifesto, Stallman didn't get started using words like “dishonor” until the sixth paragraph. The first several paragraphs spelled out the cool tools he had developed already: “an Emacs text editor with Lisp for writing editor commands, a source level debugger, a yacc-compatible parser generator, a linker, and around 35 utilities.” Then he pointed to the work he wanted to complete soon: “A new portable optimizing C compiler has compiled itself and may be released this year. An initial kernel exists but many more features are needed to emulate Unix.” He was saying, in effect, that he already had a few juicy peaches growing on the trees of his commune.

If this wasn't enough, he intended to do things a bit better than UNIX. His operating system was going to offer the latest, greatest ideas of computer science, circa 1984. “In particular, we plan to have longer file names, file version numbers, a crashproof file system, file name completion perhaps, terminal-independent display support, and perhaps eventually a Lisp-based window system through which several Lisp programs and ordinary Unix programs can share a screen.” The only thing that was missing from every computer nerd's wish list was a secret submarine docking site in the basement grotto.

The fifth paragraph even explained to everyone that the name of the project would be the acronym GNU, which stood for “GNU's Not UNIX,” and it should be pronounced with a hard G to make sure that no one would get it confused with the word “new.” Stallman has always cared about words, the way they're used and the way they're pronounced.

In 1984, UNIX became the focus of Stallman's animus because its original developer, AT&T, was pushing to try to make some money back after paying so many people at Bell Labs to create it. Most people were somewhat conflicted by the fight. They understood that AT&T had paid good money and supported many researchers with the company's beneficence. The company gave money, time, and spare computers. Sure, it was a pain to pay AT&T for something and get only a long license drafted by teams of lawyers. Yes, it would be nice if we could poke around under the hood of UNIX without signing a non-disclosure agreement. It would be nice if we could be free to do whatever we want, but certainly someone who pays for something deserves the right to decide how it is used. We've all got to eat.

Stallman wasn't confused at all. Licenses like AT&T's would constrict his freedom to share with others. To make matters worse, the software companies wanted him to pay for the privilege of getting software without the source code.

Stallman explains that his feelings weren't focused on AT&T per se. Software companies were springing up all over the place, and most of them were locking up their source code with proprietary licenses. It was the 1980s thing to do, like listening to music by Duran Duran and Boy George.

“When I decided to write a free operating system, I did not have AT&T in mind at all, because I had never had any dealings with them. I had never used a UNIX system. They were just one of many companies doing the same discreditable thing,” he told me recently. “I chose a Unix-like design just because I thought it was a good design for the job, not because I had any particular feelings about AT&T.”

When he wrote the GNU Manifesto, he made it clear to the world that his project was more about choosing the right moral path than saving money. He wrote then that the GNU project means “much more than just saving everyone the price of a UNIX license. It means that much wasteful duplication of system programming effort will be avoided. This effort can go instead into advancing the state of the art.”

This was a crucial point that kept Stallman from being dismissed as a quasi-communist crank who just wanted everyone to live happily on some nerd commune. The source code is a valuable tool for everyone because it is readable by humans, or at least humans who happen to be good at programming. Companies learned to keep source code proprietary, and it became almost a reflex. If people wanted to use it, they should pay to help defray the cost of creating it. This made sense to programmers who wanted to make a living or even get rich writing their own code. But it was awfully frustrating at times. Many programmers have pulled their hair out in grief when their work was stopped by some bug or undocumented feature buried deep in the proprietary, super-secret software made by Microsoft, IBM, Apple, or whomever. If they had the source code, they would be able to poke around and figure out what was really happening. Instead, they had to treat the software like a black box and keep probing it with test programs that might reveal the secrets hidden inside. Every programmer has had an experience like this, and every programmer knew that they could solve the problem much faster if they could only read the source code. They didn't want to steal anything, they just wanted to know what was going on so they could make their own code work.

Stallman's GNU project would be different, and he explained, “Complete system sources will be available to everyone. As a result, a user who needs changes in the system will always be free to make them himself, or hire any available programmer or company to make them for him. Users will no longer be at the mercy of one programmer or company which owns the sources and is in sole position to make changes.”

He was quick to mention that people would be “free to hire any available programmer” to ensure that people understood he wasn't against taking money for writing software. That was okay and something he did frequently himself. He was against people controlling the source with arbitrarily complex legal barriers that made it impossible for him or anyone else to get something done.

When people first heard of his ideas, they became fixated on the word “free.” These were the Reagan years. Saying that people should just give away their hard work was sounding mighty communist to everyone, and this was long before the Berlin Wall fell. Stallman reexamined the word “free” and all of its different meanings. He carefully considered all of the different connotations, examined the alternatives, and decided that “free” was still the best word. He began to try to explain the shades of meaning he was after. His revolution was about “free speech,” not “free beer.” This wasn't going to be a revolution in the sense that frequent flyer miles revolutionized air travel nor in the way that aluminum cans revolutionized beer drinking. No, this was going to be a revolution as Rousseau, Locke, and Paine used the word.

He later codified this into four main principles:

The freedom to run the program, for any purpose (freedom 0). 6

The freedom to study how the program works, and adapt it to your needs (freedom 1).

The freedom to redistribute copies so you can help your neighbor (freedom 2).

The freedom to improve the program, and release your improvements to the public, so that the whole community benefits (freedom 3).

10.1. Free Beer

While Stallman pushed people away from the notion of “free beer,” there's little question that this element turned out to be a very important part of the strategy and a foundation of its success. Stallman insisted that anyone could do what they wanted with the software, so he insisted that the source code must be freely distributed. That is, no one could put any restrictions on how you used the software. While this didn't make it free beer, it did mean that you could turn around and give a copy to your friends or your clients. It was pretty close.

The “free beer” nature of Stallman's software also attracted users. If some programmers wanted to check out a new tool, they could download it and try it out without paying for it. They didn't need to ask their boss for a budget, and they didn't need to figure out a way to deal with an invoice. Just one click and the software was there. Commercial software companies continue to imitate this feature by distributing trial versions that come with either a few crippled features or a time lock that shuts them down after a few days.

Of course, the “free beer” nature of the GNU project soon led to money problems. The GNU project took up his time and generated no real revenues at first. Stallman had always lived frugally. He says that he never made more than $20,000 a year at MIT, and still managed to save on that salary. But he was finding it harder and harder to get his assigned jobs done at MIT and write the cool GNU code. While Stallman always supported a programmer's right to make money for writing code, the GNU project wasn't generating any money.

Most folks saw this conflict coming from the beginning. Sure, Stallman would be able to rant and rave about corporate software development for a bit, but eventually he and his disciples would need to eat.

When the MIT support ended, Stallman soon stumbled upon a surprising fact: he could charge for the software he was giving away and make some money. People loved his software, but it was often hard to keep track of it. Getting the package delivered on computer tape or a CD-ROM gave people a hard copy that they could store for future reference or backup. Online manuals were also nice, but the printed book is still a very popular and easy-to-use way of storing information. Stallman's Free Software Foundation began selling printed manuals, tapes, and then CD-ROMs filled with software to make money. Surprisingly, people started paying money for these versions despite the fact that they could download the same versions for free.

Some folks enjoyed pointing out the hypocrisy in Stallman's move. Stallman had run his mouth for so long that many programming “sellouts” who worked for corporations savored the irony. At last that weenie had gotten the picture. He was forced to make money to support himself, and he was selling out, too. These cynics didn't get what Stallman was trying to do.

Most of us would have given up at this time. The free software thing seemed like a good idea, but now that the money was running out it was time to get a real job. In writing this book and interviewing some of the famous and not-so-famous free software developers, I found that some were involved in for-profit, not-so-free software development now. Stallman, though, wasn't going to give up his ideals, and his mind started shifting to accommodate this new measure of reality. He decided that it wouldn't be wrong to sell copies of software or even software services as long as you didn't withhold the source code and stomp on anyone's freedom to use the source code as they wished.

Stallman has always been great at splitting hairs and creating Jesuitical distinctions, and this insight was one of his best. At first glance, it looked slightly nutty. If people were free to do anything they wanted with software, they could just give a copy to their friend and their friend would never send money back to Stallman's Free Software Foundation. In fact, someone could buy a copy from Stallman and then start reselling copies to others to undercut Stallman. The Free Software Foundation and the GNU GPL gave them the freedom to do so. It was as if a movie theater sold tickets to a movie, but also posted a big sign near the exit door that said “Hey, it's absolutely okay for you to prop this open so your friends can sneak in without paying.”

While this total freedom befuddled most people, it didn't fail. Many paid for tapes or CD-ROM versions because they wanted the convenience. Stallman's versions came with the latest bug fixes and new features. They were the quasi-official versions. Others felt that paying helped support the work so they didn't feel bad about doing it. They liked the FSF and wanted it to produce more code. Others just liked printed books better than electronic documentation. Buying them from Stallman was cheaper than printing them out. Still others paid for the CD-ROMs because they just wanted to support the Free Software Foundation.

Stallman also found other support. The MacArthur Foundation gave him one of their genius grants that paid him a nice salary for five years to do whatever he wanted. Companies like Intel hired him as a consultant and asked him to make sure that some of his software ran on Intel chips. People were quite willing to pay for convenience because even free software didn't do everything that it should.

Stallman also recognized that this freedom introduced a measure of competition. If he could charge for copies, then so could others. The source code would be a vast commonweal, but the means of delivering it would be filled with people struggling to do the best job of distributing the software. It was a pretty hard-core Reaganaut notion for a reputed communist. At the beginning, few bothered to compete with him, but in time all of the GNU code began to be included with computer operating systems. By the time Linus Torvalds wrote his OS, the GNU code was ready to be included.

10.2. Copyleft

If Stallman's first great insight was that the world did not need to put up with proprietary source code, then his second was that he could strictly control the use of GNU software with an innovative legal document entitled GNU General Public License, or GPL. To illustrate the difference, he called the agreement a “copyleft” and set about creating a legal document defining what it meant for software to be “free.” Well, defining what he thought it should mean.

The GPL was a carefully crafted legal document that didn't put the software into the “public domain,” a designation that would have allowed people to truly do anything they wanted with the software. The license, in fact, copyrighted the software and then extended users very liberal rights for making innumerable copies as long as the users didn't hurt other people's rights to use the software.

The definition of stepping on other people's rights is one that keeps political science departments at universities in business. There are many constituencies that all frame their arguments in terms of protecting someone's rights. Stallman saw protecting the rights of other users in very strong terms and strengthened his grip a bit by inserting a controversial clause. He insisted that a person who distributes an improved version of the program must also share the source code. That meant that some greedy company couldn't download his GNU Emacs editor, slap on a few new features, and then sell the whole package without including all of the source code they created. If people were going to benefit from the GNU sharing, they were going to have to share back. It was freedom with a price.

This strong compact was ready-built for some ironic moments. When Apple began trying to expand the scope of intellectual property laws by suing companies like Microsoft for stealing their “look and feel,” Stallman became incensed and decided that he wouldn't develop software for Apple machines as a form of protest and spite. If Apple was going to pollute the legal landscape with terrible impediments to sharing ideas, then Stallman wasn't going to help them sell machines by writing software for the machines. But the GNU copyleft license specifically allowed anyone to freely distribute the source code and use it as they wanted. That meant that others could use the GNU code and convert it to run on the Apple if they wanted to do so. Many did port much of the GNU software to the Mac and distributed the source code with it in order to comply with the license. Stallman couldn't do anything about it. Sure, he was the great leader of the FSF and the author of some of its code, but he had given away his power with the license. The only thing he could do was refuse to help the folks moving the software to the Mac. When it came to principles, he placed freedom to use the source code at the top of the hierarchy.

10.3. The GNU Virus

Some programmers soon started referring to the sticky nature of the license as the “GNU virus” because it infected software projects with its freedom bug. If a developer wanted to save time and grab some of the neat GNU software, he was stuck making the rest of his work just as free. These golden handcuffs often scared away programmers who wanted to make money by charging for their work.

Stallman hates that characterization. “To call anything 'like a virus' is a very vicious thing. People who say things like that are trying to find ways to make the GPL look bad,” he says.

Stallman did try to work around this problem by creating what he at first called the “Library General Public License” and now refers to as the “Lesser General Public License,” a document that allowed software developers to share small chunks of code with each other under less restrictive circumstances. A programmer can use the LGPL to bind chunks of code known as libraries. Others can share the libraries and use them with their source code as long as they don't fully integrate them. Any changes they make to the library itself must be made public, but there is no requirement to release the source code for the main program that uses the library.

This license is essentially a concession to some rough edges at the corners where the world of programming joins the world of law. While Stallman was dead set on creating a perfect collection of free programs that would solve everyone's needs, he was far from finished. If people were going to use his software, they were going to have to use it on machines made by Sun, AT&T, IBM, or someone else who sold a proprietary operating system along with it. He understood that he needed to compromise, at least for system libraries.

The problem is drawing boundaries around what is one pile of software owned by one person and what is another pile owned by someone else. The GPL guaranteed that GNU software would “infect” other packages and force people who used his code to join the party and release theirs as well. So he had to come up with a definition that spelled out what it meant for people to use his code and “incorporate” it with others.

This is often easier said than done. The marketplace has developed ways to sell software as big chunks to people, but these are fictions that camouflage software integration. In modern practice, programmers don't just create one easily distinguished chunk of software known as Microsoft Word or Adobe Photoshop. They build up a variety of smaller chunks known as libraries and link these together. Microsoft Windows, in fact, includes a large collection of libraries for creating the menus, forms, click boxes, and what-not that make the graphical user interfaces. Programmers don't need to write their own instructions for drawing these on the screen and interacting with them. This saves plenty of time and practice for the programmers, and it is a large part of what Microsoft is selling when it sells someone a box with Windows on it.

Stallman recognized that programmers sometimes wrote libraries that they wanted others to use. After all, that was the point of GNU: creating tools that others would be free to use. So Stallman relented and created the Lesser Public License, which would allow people to create libraries that might be incorporated into other programs that weren't fully GNU. The library itself still came with source code, and the user would need to distribute all changes made to the library, but there was no limitation on the larger package.

This new license was also something of a concession to reality. In the most abstract sense, programs are just black boxes that take some input and produce some output. There's no limit to the hierarchies that can be created by plugging these boxes together so that the output for one is the input for another. Eventually, the forest of connections grows so thick that it is difficult to draw a line and label one collection of boxes “ProprietarySoft's SUX-2000” and another collection “GNUSoft's Wombat 3.14.15.” The connections are so numerous in well-written, effective software that line-drawing is difficult.

The problem is similar to the one encountered by biologists as they try to define ecosystems and species. Some say there are two different groups of tuna that swim in the Atlantic. Others say there is only one. The distinction would be left to academics if it didn't affect the international laws on fishing. Some groups pushing the vision of one school are worried that others on the other side of the ocean are catching their fish. Others push the two-school theory to minimize the meddling of the other side's bureaucracy. No one knows, though, how to draw a good line.

Stallman's LGPL was a concession to the fact that sometimes programs can be used like libraries and sometimes libraries can be used like programs. In the end, the programmer can draw a strong line around one set of boxes and say that the GPL covers these functions without leaking out to infect the software that links up with the black boxes.

10.4. Is the Free Software Foundation Anti-Freedom?

Still, these concessions aren't enough for some people. Many continue to rail against Stallman's definition of freedom and characterize the GPL as a fascist document that steals the rights of any programmer who comes along afterward. Being free means having the right to do anything you want with the code, including keeping all your modifications private.

To be fair, the GPL never forces you to give away your changes to the source code. It just forces you to release your modifications if you redistribute it. If you just run your own version in your home, then you don't need to share anything. When you start sharing binary versions of the software, however, you need to ship the source code, too.

Some argue that corporations have the potential to work around this loophole because they act like one person. A company could revise software and “ship it” by simply hiring anyone who wanted to buy it. The new employees or members of the corporation would get access to the software without shipping the source. The source code would never be distributed because it was not publicly shipped. No one seriously believes that anyone would try to exploit this provision with such an extreme interpretation, but it does open the question of whether an airtight license can ever be created.

These fine distinctions didn't satisfy many programmers who weren't so taken with Stallman's doctrinaire version of freedom. They wanted to create free software and have the freedom to make some money off of it. This tradition dates back many years before Stallman and is a firm part of academic life. Many professors and students developed software and published a free version before starting up a company that would commercialize the work. They used their professor's salary or student stipend to support the work, and the free software they contributed to the world was meant as an exchange. In many cases, the U.S. government paid for the creation of the software through a grant, and the free release was a gift to the taxpayers who ultimately funded it. In other cases, corporations paid for parts of the research and the free release was seen as a way to give something back to the sponsoring corporation without turning the university into a home for the corporation's lowpaid slave programmers who were students in name only.

In many cases, the free distribution was an honest gift made by researchers who wanted to give their work the greatest possible distribution. They would be repaid in fame and academic prestige, which can be more lucrative than everything but a good start-up's IPO. Sharing knowledge and creating more of it was what universities were all about. Stallman tapped into that tradition.

But many others were fairly cynical. They would work long enough to generate a version that worked well enough to convince people of its value. Then, when the funding showed up, they would release this buggy version into the “public domain,” move across the street into their own new start-up, and resume development. The public domain version satisfied the university's rules and placated any granting agencies, but it was often close to unusable. The bugs were too numerous and too hidden in the cruft to make it worth someone's time. Of course, the original authors knew where the problems lurked, and they would fix them before releasing the commercial version.

The leader of this academic branch of the free software world became the Computer Systems Research Group at the University of California at Berkeley. The published Berkeley Software Distribution (BSD) versions of UNIX started emerging from Berkeley in the late 1970s. Their work emerged with a free license that gave everyone the right to do what they wanted with the software, including start up a company, add some neat features, and start reselling the whole package. The only catch was that the user must keep the copyright message intact and give the university some credit in the manual and in advertisements. This requirement was loosened in 1999 when the list of people who needed credit on software projects grew too long. Many groups were taking the BSD license and simply replacing the words “University of California” with their name. The list of people who needed to be publicly acknowledged grew with each new project. As the distributions grew larger to include all of these new projects, the process of listing all the names and projects became onerous. The University of California struck the clause requiring advertising credit in the hopes of setting an example that others would follow.

Today, many free software projects begin with a debate of “GNU versus BSD” as the initial founders argue whether it is a good idea to restrict what users can do with the code. The GNU side always believes that programmers should be forced to donate the code they develop back to the world, while the BSD side pushes for practically unlimited freedom.

Rick Rashid is one of the major forces behind the development of Microsoft's Windows NT and also a major contributor to our knowledge of how to build a computer operating system. Before he went to Microsoft, he was a professor at Carnegie-Mellon. While he was there, he spearheaded the team responsible for developing Mach, an operating system that offered relatively easy-to-use multitasking built upon a very tiny kernel. Mach let programmers break their software into multiple “threads” that could run independently of each other while sharing the same access to data.

When asked recently about Mach and the Mach license, he explained that he deliberately wrote the license to be as free as possible.

The GNU GPL, he felt, wasn't appropriate for technology that was developed largely with government grants. The work should be as free as possible and shouldn't force “other people to do things (e.g., give away their personal work) in order to get access to what you had done.”

He said, in an e-mail interview, “It was my intent to encourage use of the system both for academic and commercial use and it was used heavily in both environments. Accent, the predecessor to Mach, had already been commercialized and used by a variety of companies. Mach continues to be heavily used today--both as the basis for Apple's new MacOS and as the basis for variants of Unix in the marketplace (e.g., Compaq's 64-bit Unix for the Alpha).”

10.5. The Evolution of BSD

The BSD license evolved along a strange legal path that was more like the meandering of a drunken cow than the laser-like devotion of Stallman.

Many professors and students cut their teeth experimenting with UNIX on DEC Vaxes that communicated with old teletypes and dumb terminals. AT&T gave Berkeley the source code to UNIX, and this allowed the students and professors to add their instructions and features to the software. Much of their insight into operating system design and many of their bug fixes made their way back to AT&T, where they were incorporated in the next versions of UNIX. No one really thought twice about the source code being available because the shrink-wrapped software market was still in its infancy. The personal computer market wasn't even born until the latter half of the 1970s, and it took some time for people to believe that source code was something for a company to withhold and protect. In fact, many of the programs still weren't being written in higher-level languages. The programmers would write instructions directly for the computer, and while these often would include some instructions for humans, there was little difference between what the humans wrote and the machine read.

After Bill Joy and others at Berkeley started coming up with several good pieces of software, other universities started asking for copies. At the time, Joy remembers, it was considered a bit shabby for computer science researchers to actually write software and share it with others. The academic departments were filled with many professors who received their formal training in mathematics, and they held the attitude that rigorous formal proofs and analysis were the ideal form of research. Joy and several other students began rebelling by arguing that creating working operating systems was essential experimental research. The physics departments supported experimentalists and theorists.

So Joy began to “publish” his code by sending out copies to other researchers who wanted it. Although many professors and students at Berkeley added bits and pieces to the software running on the DEC Vaxes, Joy was the one who bundled it all together and gave it the name. Kirk McKusick says in his history of Berkeley UNIX, “. . . interest in the error recovery work in the Pascal compiler brought in requests for copies of the system. Early in 1977, Joy put together the 'Berkeley Software Distribution.' This first distribution included the Pascal system, and, in an obscure subdirectory of the Pascal source, the editor vi. Over the next year, Joy, acting in the capacity of the distribution secretary, sent out about 30 free copies of the system.”

Today, Joy tells the story with a bit of bemused distraction. He explains that he just copied over a license from the University of Toronto and“whited out”“University ofToronto” and replaced it with “University of California.” He simply wanted to get the source code out the door. In the beginning, the Berkeley Software Distribution included a few utilities, but by 1979 the code became tightly integrated with AT&T's basic UNIX code. Berkeley gave away the collection of software in BSD, but only AT&T license holders could use it. Many universities were attracted to the package, in part because the Pascal system was easy for its students to use. The personal computer world, however, was focusing on a simpler language known as Basic. Bill Gates would make Microsoft Basic one of his first products.

Joy says that he wrote a letter to AT&T inquiring about the legal status of the source code from AT&T that was rolled together with the BSD code. After a year, he says, “They wrote back saying, 'We take no position' on the matter.” Kirk McKusick, who later ran the BSD project through the years of the AT&T lawsuit, explained dryly, “Later they wrote a different letter.”

Joy was just one of a large number of people who worked heavily on the BSD project from 1977 through the early 1980s. The work was low-level and grungy by today's standards. The students and professors scrambled just to move UNIX to the new machines they bought. Often, large parts of the guts of the operating system needed to be modified or upgraded to deal with a new type of disk drive or file system. As they did this more and more often, they began to develop more and more higher-level abstractions to ease the task. One of the earliest examples was Joy's screen editor known as vi, a simple package that could be used to edit text files and reprogram the system. The “battle” between Joy's vi and Stallman's Emacs is another example of the schism between MIT and Berkeley. This was just one of the new tools included in version 2 of BSD, a collection that was shipped to 75 different people and institutions.

By the end of the 1970s, Bell Labs and Berkeley began to split as AT&T started to commercialize UNIX and Berkeley stuck to its job of education. Berkeley professor Bob Fabry was able to interest the Pentagon's Defense Advanced Research Projects Agency (DARPA) into signing up to support more development at Berkeley. Fabry sold the agency on a software package that would be usable on many of the new machines being installed in research labs throughout the country. It would be more easily portable so that research would not need to stop every time a new computer arrived. The work on this project became versions 3 and 4 of BSD.

During this time, the relationship between AT&T and the universities was cordial. AT&T owned the commercial market for UNIX and Berkeley supplied many of the versions used in universities. While the universities got BSD for free, they still needed to negotiate a license with AT&T, and companies paid a fortune. This wasn't too much of a problem because universities are often terribly myopic. If they share their work with other universities and professors, they usually consider their sharing done. There may be folks out there without university appointments, but those folks are usually viewed as cranks who can be safely ignored. Occasionally, those cranks write their own OS that grows up to be Linux. The BSD version of freedom was still a far cry from Stallman's, but then Stallman hadn't articulated it yet. His manifesto was still a few years off.

The intellectual tension between Stallman and Berkeley grew during the 1980s. While Stallman began what many thought was a quixotic journey to build a completely free OS, Berkeley students and professors continued to layer their improvements to UNIX on top of AT&T's code. The AT&T code was good, it was available, and many of the folks at Berkeley had either directly or indirectly helped influence it. They were generally happy keeping AT&T code at the core despite the fact that all of the BSD users needed to negotiate with AT&T. This process grew more and more expensive as AT&T tried to make more and more money off of UNIX.

Of course, Stallman didn't like the freedom of the BSD-style license. To him, it meant that companies could run off with the hard work and shared source code of another, make a pile of money, and give nothing back. The companies and individuals who were getting the BSD network release were getting the cumulative hard work of many students and professors at Berkeley (and other places) who donated their time and effort to building a decent OS. The least these companies owed the students were the bug fixes, the extensions, and the enhancements they created when they were playing with the source code and gluing it into their products.

Stallman had a point. Many of these companies “shared” by selling the software back to these students and the taxpayers who had paid for their work. While it is impossible to go back and audit the motives of everyone who used the code, there have been many who've used BSDstyle code for their personal gain.

Bill Joy, for instance, went to work at Sun Microsystems in 1982 and brought with him all the knowledge he had gained in developing BSD. Sun was always a very BSD-centered shop, and many of the people who bought Sun workstations ran BSD. At that time, AT&T still controlled much of the kernel and many of the small extra programs that made UNIX a usable system.

But there are counter arguments as well. Joy certainly contributed a lot to the different versions of BSD. If anyone deserves to go off and get rich at a company like Sun, it's he.

Also, the BSD source code was freely available to all comers, and all companies started with the same advantages. The software business is often considered to be one of the most free marketplaces around because of the low barriers to entry. This means that companies should only be able to charge for the value they add to the BSD code. Sure, all of the Internet was influenced by the TCP/IP code, but now Microsoft, Apple, IBM, Be, and everyone else compete on the quality of their interface.

10.6. The Price of Total Freedom

The debate between BSD-style freedom and GNU-style freedom is one of the greatest in the free programming world and is bound to continue for a long time as programmers join sides and experiment.

John Gilmore is one programmer who has worked with software developed under both types of licenses. He was employee number five at Sun Microsystems, a cofounder of the software development tool company Cygnus Solutions, and one of the board members of the Electronic Frontier Foundation. His early work at Sun gave him the wealth to pursue many independent projects, and he has spent the last 10 years devoting himself to making it easy for people around the world to use encryption software. He feels that privacy is a fundamental right and an important crime deterrent, and he has funded a number of different projects to advance this right.

Gilmore also runs the cypherpunks mailing list on a computer in his house named Toad Hall near Haight Street in San Francisco. The mailing list is devoted to exploring how to create strong encryption tools that will protect people's privacy and is well known for the strong libertarian tone of the deliberations. Practically the whole list believes (and frequently reiterates) that people need the right to protect their privacy against both the government and private eavesdropping. Wired magazine featured Gilmore on the cover, along with fellow travelers Eric Hughes and Tim May.

One of his recent tasks was creating a package of free encryption utilities that worked at the lowest level of the network operating system. These tools, known as Free/SWAN, would allow two computers that meet on the Internet to automatically begin encoding the data they swap with some of the best and most secure codes available. He imagines that banks, scientific laboratories, and home workers everywhere will want to use the toolkit. In fact, AT&T is currently examining how to incorporate the toolkit into products it is building to sell more highspeed services to workers staying at home to avoid the commute.

Gilmore decided to use the GNU license to protect the Free/SWAN software, in part because he has had bad experiences in the past with totally free software. He once wrote a little program called PDTar that was an improvement over the standard version of Tar used on the Internet to bundle together a group of files into one big, easy-tomanage bag of bits often known affectionately as “tarballs.” He decided he wasn't going to mess around with Stallman's GNU license or impose any restrictions on the source code at all. He was just going to release it into the public domain and give everyone total freedom.

This good deed did not go unpunished, although the punishment was relatively minor. He recalls, “I never made PDTar work for DOS, but six or eight people did. For years after the release, I would get mail saying, 'I've got this binary for the DOS release and it doesn't work.' They often didn't even have the sources that went with the version so I couldn't help them if I tried.“ Total freedom, it turned out, brought a certain amount of anarchy that made it difficult for him to manage the project. While the total freedom may have encouraged others to build their own versions of PDTar, it didn't force them to release the source code that went with their versions so others could learn from or fix their mistakes Hugh Daniel, one of the testers for the Free/SWAN project, says that he thinks the GNU General Public License will help keep some coherency to the project. ”There's also a magic thing with GPL code that open source doesn't have,“ Daniel said. ”For some reason, projects don't bifurcate in GPL space. People don't grab a copy of the code and call it their own. For some reason there's a sense of community in GPL code. There seems to be one version. There's one GPL kernel and there's umpty-ump BSD branches.”

Daniel is basically correct. The BSD code has evolved, or forked, into many different versions with names like FreeBSD, OpenBSD, and NetBSD while the Linux UNIX kernel released under Stallman's GPL is limited to one fairly coherent package. Still, there is plenty of crosspollination between the different versions of BSD UNIX. Both NetBSD 1.0 and FreeBSD 2.0, for instance, borrowed code from 4.4 BSD-Lite. Also, many versions of Linux come with tools and utilities that came from the BSD project.

But Daniel's point is also clouded with semantics. There are dozens if not hundreds of different Linux distributions available from different vendors. Many differ in subtle points, but some are markedly different. While these differences are often as great as the ones between the various flavors of BSD, the groups do not consider them psychologically separate. They haven't forked politically even though they've split off their code.

While different versions may be good for some projects, it may be a problem for packages like Free/SWAN that depend upon interoperability. If competing versions of Free/SWAN emerge, then all begin to suffer because the product was designed to let people communicate with each other. If the software can't negotiate secure codes because of differences, then it begins to fail.

But it's not clear that the extra freedom is responsible for the fragmentation. In reality, the different BSD groups emerged because they had different needs. The NetBSD group, for instance, wanted to emphasize multiplatform support and interoperability. Their website brags that the NetBSD release works well on 21 different hardware platforms and also points out that some of these hardware platforms themselves are quite diverse. There are 93 different versions of the Macintosh running on Motorola's 68k chips, including the very first Mac. Eighty-nine of them run some part of NetBSD and 37 of them run all of it. That's why they say their motto is “Of course it runs NetBSD.”

The OpenBSD group, on the other hand, is emphasizing security without compromising portability and interoperability. They want to fix all security bugs immediately and be the most secure OS on the marketplace.

There are also deep personal differences in the way Theo de Raadt, the founder of OpenBSD, started the project after the NetBSD group kicked him out of their core group.

For all of these reasons, it may be hard to argue that the freedoms provided by the BSD-style license were largely responsible for the splintering. The GNU software users are just as free to make new versions as long as they kick back the source code into free circulation. In fact, it may be possible to argue that the Macintosh versions of some of the GNU code comprise a splinter group because it occurred despite the ill will Stallman felt for the Mac.

10.7. The Synthesis of “Open Source”

The tension between the BSD licenses and the GNU has always festered like the abortion debate. Everyone picked sides and rarely moved from them.

In 1998, a group of people in the free software community tried to unify the two camps by creating a new term, “open source.” To make sure everyone knew they were serious, they started an unincorporated organization, registered a trademark, and set up a website (www.opensource.org). Anyone who wanted to label their project “open source” would have to answer to them because they would control the trademark on the name.

Sam Ockman, a Linux enthusiast and the founder of Penguin Computing, remembers the day of the meeting just before Netscape announced it was freeing its source code. “Eric Raymond came into town because of the Netscape thing. Netscape was going to free their software, so we drove down to Transmeta and had a meeting so we could advise Netscape,” he said.

He explained that the group considered a number of different options about the structure. Some wanted to choose a leader now. Others wanted to emulate an open source project and let a leader emerge through the display of talent and, well, leadership. Others wanted elections.

The definition of what was open source grew out of the Debian project, one of the different groups that banded together to press CDROMs of stable Linux releases. Groups like these often get into debates about what software to include on the disks. Some wanted to be very pure and only include GPL'ed software. In a small way, that would force others to contribute back to the project because they wouldn't get their software distributed by the group unless it was GPL'ed. Others wanted less stringent requirements that might include quasi-commercial projects that still came with their source code. There were some cool projects out there that weren't protected by GPL, and it could be awfully hard to pass up the chance to integrate them into a package.

Over time, one of the leaders of the Debian group, Bruce Perens, came to create a definition of what was acceptable and what wasn't. This definition would be large enough to include the GNU General Public License, the BSD-style licenses, and a few others like MIT's X Consortium license and the Artistic license. The X-windows license covers a graphical windowing interface that began at MIT and was also freely distributed with BSD-like freedom. The Artistic license applies to the Perl programming language, a tool that is frequently used to transform files. The Debian meta-definition would embrace all of these.

The official definition of what was acceptable to Debian leaned toward more freedom and fewer restrictions on the use of software. Of course, that's the only way that anyone could come up with a definition that included both GNU and the much less restrictive BSD. But this was also the intent of the open source group. Perens and Eric Raymond felt that Stallman still sounded too quasi-communist for “conservative businessmen,” and they wanted the open source definition to avoid insisting upon the sort of forced sharing that Stallman's GNU virus provided.

Still, the definition borrowed heavily from Stallman's concept of GNU, and Perens credits him by saying that many of the Debian guidelines are derived from the GPL. An official open source license for a product must provide the programmer with source code that is human-readable. It can't restrict what modifications are made to the software or how it is sold or given away.

The definition glossed over the difference between BSD and GPU by stating, “The license must allow modifications and derived works, and must allow them to be distributed under the same terms as the license of the original software.”

The definition proved to be the model for more commercial offerings like the Netscape Public License. In 1998, Netscape started distributing the source code to its popular browser in hopes of collecting help from the Internet and stopping Microsoft's gradual erosion of its turf. The license gave users wide opportunities to make changes and tinker with the software, but it also allowed Netscape to use the changes internally and refuse to share what they did with them. This special privilege offended some users who didn't like the imbalance, but it didn't bother many others who thought it was a reasonable compromise for a chance to tinker with commercial code. Netscape, of course, returned some of the favor by allowing people to keep their modifications private in much the same way that the BSD-style license provided.

In June 1999, the Open Source Initiative revealed a startling fact. They were close to failing in their attempts to register the term “open source” as a trademark. The phrase was too common to be registered. Instead, they backed away and offered to check out licenses and classify them officially as “OSI Certified” if they met the terms of the OSI's definition of freedom.

Some reacted negatively. Richard Stallman decided that he didn't like the word “open” as much as “free.” Open doesn't capture the essence of freedom. Ockman says, “I don't think it's very fair. For ages, he's always said that the term 'free software' is problematic because people think of 'free beer' when they should be thinking of 'free speech.' We were attempting to solve that term. If the masses are confused, then corporate America is confused even more.”

The debate has even produced more terms. Some people now use the phrase “free source” to apply to the general conglomeration of the GPL and the open source world. Using “free software” implies that someone is aligned with Stallman's Free Software Foundation. Using “open source” implies you're aligned with the more business-friendly Open Source Initiative. So “free source” and “open source” both work as a compromise. Others tweak the meaning of free and refer to GPL protected software as “GNUFree.”

Naturally, all of this debate about freedom can reach comic proportions. Programmers are almost better than lawyers at finding loopholes, if only because they have to live with a program that crashes. 7 Stallman, for instance, applies the GPL to everything coming out of the GNU project except the license itself. That can't be changed, although it can be freely reproduced. Some argue that if it were changeable, people would be able to insert and delete terms at will. Then they could apply the changed GPL to the new version of the software and do what they want. Stallman's original intent would not be changed. The GPL would still apply to all of the GNU software and its descendants, but it wouldn't be the same GPL.

 6. He numbered them starting at zero because that was what computer scientists did. Someone figured out that it was simpler to start numbering databases at zero because you didn't have to subtract 1 as often.

 7. Lawyers just watch their clients go to jail.