%% Copyright (c) 2002, 2010 Sam Williams
%% Copyright (c) 2010 Richard M. Stallman
%% Permission is granted to copy, distribute and/or modify this
%% document under the terms of the GNU Free Documentation License,
%% Version 1.3 or any later version published by the Free Software
%% Foundation; with no Invariant Sections, no Front-Cover Texts, and
%% no Back-Cover Texts. A copy of the license is included in the
%% file called ``gfdl.tex''.


\chapter{The GNU General Public License}

By the spring of 1985, Richard Stallman had produced the GNU Project's first useful result -- a Lisp-based version of Emacs for Unix-like operating systems. To make it available to others as free software, he had to develop the way to release it -- in effect, the follow-on for the Emacs Commune.

The tension between the freedom to modify and authorial privilege had been building before Gosmacs. The Copyright Act of 1976 had overhauled U.S. copyright law, extending the legal coverage of copyright to software programs. According to Section 102(b) of the Act, individuals and companies could copyright the ``expression'' of a software program but not the ``actual processes or methods embodied in the program.''\endnote{See Hal Abelson, Mike Fischer, and Joanne Costello, ``Software and Copyright Law,'' updated version (1997), \url{http://groups.csail.mit.edu/mac/classes/6.805/articles/int-prop/software-copyright.html}.}

Translated, this treated a program much like an algebra textbook: its author can claim copyright on the text but not on the mathematical ideas of algebra or the pedagogical technique employed to explain it.  Thus, regardless of what Stallman said about using the code of the original Emacs, other programmers were legally entitled to write their own implementations of the ideas and commands of Emacs, and they did.  Gosmacs was one of 30-odd imitations of the original Emacs developed for various computer systems.

The Emacs Commune applied only to the code of the original Emacs program written by Stallman himself.  Even if it had been legally enforced, it would not have applied to separately developed imitations such as Gosmacs.  Making Gosmacs nonfree was unethical according to the ethical ideas of the free software movement, because (as proprietary software) it did not respect its users' freedom, but this issue had nothing to do with where the ideas in Gosmacs came from.

Under copyright, programmers who wanted to copy code from an existing program (even with changes) had to obtain permission from the original developer. The new law applied copyright even in the absence of copyright notices -- though hackers generally did not know this -- and the copyright notices too began appearing.

Stallman saw these notices as the flags of an invading, occupying army. Rare was the program that didn't borrow source code from past programs, and yet, with a single stroke of the president's pen, the U.S. government had given programmers and companies the legal power to forbid such reuse.  Copyright also injected a dose of formality into what had otherwise been an informal system. Simply put, disputes that had once been settled hacker-to-hacker were now to be settled lawyer-to-lawyer. In such a system, companies, not hackers, held the automatic advantage.  Some saw placing one's name in a copyright notice as taking responsibility for the quality of the code, but the copyright notice usually has a company's name, and there are other ways for individuals to say what code they wrote.

However, Stallman also noticed, in the years leading up to the GNU Project, that copyright allowed an author to grant permission for certain activities covered by copyright, and place conditions on them too.  ``I had seen email messages with copyright notices plus simple `verbatim copying permitted' licenses,'' he recalls. ``Those definitely were [an] inspiration.''  These licenses carried the condition not to remove the license.  Stallman's idea was to take this a few steps further.  For example, a permission notice could allow users to redistribute even modified versions, with the condition that these versions carry the same permission.

Thus Stallman concluded that use of copyright was not necessarily unethical.  What was bad about software copyright was the way it was typically used, and designed to be used: to deny the user essential freedoms.  Most authors imagined no other way to use it.  But copyright could be used in a different way: to make a program free and assure its continued freedom.

By GNU Emacs 16, in early 1985, Stallman drafted a copyright-based license that gave users the right to make and distribute copies. It also gave users the right to make and distribute modified versions, but only under the same license.  They could not exercise the unlimited power of copyright over those modified versions, so they could not make their versions proprietary as Gosmacs was.  And they had to make the source code available.  Those conditions closed the legal gap that would otherwise allow restricted, nonfree versions of GNU Emacs to emerge.

Although helpful in codifying the social contract of the Emacs Commune, the early GNU Emacs license remained too ``informal'' for its purpose, Stallman says. Soon after forming the Free Software Foundation he began working on a more airtight version, consulting with the other directors and with the attorneys who had helped to set it up.

Mark Fischer, a Boston copyright attorney who initially provided Stallman's legal advice, recalls discussing the license with Stallman during this period. ``Richard had very strong views about how it should work,'' Fischer says, ``He had two principles. The first was to make the software absolutely as open as possible.'' (By the time he said this, Fischer seems to have been influenced by open source supporters; Stallman never sought to make software ``open.'') ``The second was to encourage others to adopt the same licensing practices.''  The requirements in the license were designed for the second goal.

The revolutionary nature of this final condition would take a while to sink in. At the time, Fischer says, he simply viewed the GNU Emacs license as a simple trade. It put a price tag on GNU Emacs' use. Instead of money, Stallman was charging users access to their own later modifications. That said, Fischer does remember the license terms as unique.

``I think asking other people to accept the price was, if not unique, highly unusual at that time,'' he says.

In fashioning the GNU Emacs license, Stallman made one major change to the informal tenets of the old Emacs Commune. Where he had once demanded that Commune members send him all the changes they wrote, Stallman now demanded only that they pass along source code and freedom whenever they chose to redistribute the program. In other words, programmers who simply modified Emacs for private use no longer needed to send the source-code changes back to Stallman. In a rare alteration of free software doctrine, Stallman slashed the ``price tag'' for free software. Users could innovate without Stallman looking over their shoulders, and distribute their versions only when they wished, just so long as all copies came with permission for their possessors to develop and redistribute them further.

Stallman says this change was fueled by his own dissatisfaction with the Big Brother aspect of the original Emacs Commune social contract. As much as he had found it useful for everyone to send him their changes, he came to feel that requiring this was unjust.

``It was wrong to require people to publish all changes,'' says Stallman. ``It was wrong to require them to be sent to one privileged developer. That kind of centralization and privilege for one was not consistent with a society in which all had equal rights.''

The GNU Emacs General Public License made its debut on a version of GNU Emacs in 1985. Following the release, Stallman welcomed input from the general hacker community on how to improve the license's language. One hacker to take up the offer was future software activist John Gilmore, then working as a consultant to Sun Microsystems. As part of his consulting work, Gilmore had ported Emacs over to SunOS, the company's in-house version of Unix. In the process of doing so, Gilmore had published the changed version under the GNU Emacs license. Instead of viewing the license as a liability, Gilmore saw it as clear and concise expression of the hacker ethos. ``Up until then, most licenses were very informal,'' Gilmore recalls.

As an example of this informality, Gilmore cites the mid-1980s copyright license of trn, a news reader program written by Larry Wall, a hacker who could go onto later fame as the creator of both the Unix ``patch'' utility and the Perl scripting language. In the hope of striking a balance between common hacker courtesy and an author's right to dictate the means of commercial publication, Wall used the program's accompanying copyright notice as an editorial sounding board.

\begin{quote}
Copyright (c) 1985, Larry Wall\\
You may copy the trn kit in whole or in part as long as you don't try to make money off it, or pretend that you wrote it.\endnote{See Trn Kit README, \url{http://stuff.mit.edu/afs/sipb/project/trn/src/trn-3.6/README}.}
\end{quote}

Such statements, while reflective of the hacker ethic, also reflected the difficulty of translating the loose, informal nature of that ethic into the rigid, legal language of copyright. In writing the GNU Emacs license, Stallman had done more than close up the escape hatch that permitted proprietary offshoots. He had expressed the hacker ethic in a manner understandable to both lawyer and hacker alike.

It wasn't long, Gilmore says, before other hackers began discussing ways to ``port'' the GNU Emacs license over to their own programs. Prompted by a conversation on Usenet, Gilmore sent an email to Stallman in November, 1986, suggesting modification:

\begin{quote}
You should probably remove ``EMACS'' from the license and replace it with ``SOFTWARE'' or something. Soon, we hope, Emacs will not be the biggest part of the GNU system, and the license applies to all of it.\endnote{See John Gilmore, quoted from email to author.}
\end{quote}

Gilmore wasn't the only person suggesting a more general approach. By the end of 1986, Stallman himself was at work with GNU Project's next major milestone, the source-code debugger GDB.  To release this, he had to modify the GNU Emacs license so it applied to GDB instead of GNU Emacs.  It was not a big job, but it was an opening for possible errors.  In 1989, Stallman figured out how to remove the specific references to Emacs, and express the connection between the program code and the license solely in the program's source files.  This way, any developer could apply the license to his program without changing the license. The GNU General Public License, GNU GPL for short, was born.  The GNU Project soon made it the official license of all existing GNU programs.

In publishing the GPL, Stallman followed the software convention of using decimal numbers to indicate versions with minor changes and whole numbers to indicate versions with major changes. The first version, in 1989, was labeled Version 1.0. The license contained a preamble spelling out its political intentions:

\begin{quote}
The General Public License is designed to make sure that you have the freedom to give away or sell copies of free software, that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.\endnote{See Richard Stallman, et al., ``GNU General Public License: Version 1,'' (February, 1989), \url{http://www.gnu.org/licenses/old-licenses/gpl-1.0.html}.}
\end{quote}

As hacks go, the GPL stands as one of Stallman's best. It created a system of communal ownership within the normally proprietary confines of copyright law. More importantly, it demonstrated the intellectual similarity between legal code and software code. Implicit within the GPL's preamble was a profound message: instead of viewing copyright law with suspicion, hackers should view it as a dangerous system that could be hacked.

``The GPL developed much like any piece of free software with a large community discussing its structure, its respect or the opposite in their observation, needs for tweaking and even to compromise it mildly for greater acceptance,'' says Jerry Cohen, another attorney who advised Stallman after Fischer departed. ``The process worked very well and GPL in its several versions has gone from widespread skeptical and at times hostile response to widespread acceptance.''

In a 1986 interview with \textit{BYTE} magazine, Stallman summed up the GPL in colorful terms. In addition to proclaiming hacker values, Stallman said, readers should also ``see it as a form of intellectual jujitsu, using the legal system that software hoarders have set up against them.''\endnote{See David Betz and Jon Edwards, ``Richard Stallman discusses his public-domain [\textit{sic}] Unix-compatible software system with \textit{BYTE} editors,'' \textit{BYTE} (July, 1986). (Reprinted on the GNU Project web site: \url{http://www.gnu.org/gnu/byte-interview.html}.)

This interview offers an interesting, not to mention candid, glimpse at Stallman's political attitudes during the earliest days of the GNU Project. It is also helpful in tracing the evolution of Stallman's rhetoric.

Describing the purpose of the GPL, Stallman says, ``I'm trying to change the way people approach knowledge and information in general. I think that to try to own knowledge, to try to control whether people are allowed to use it, or to try to stop other people from sharing it, is sabotage.''

Contrast this with a statement to the author in August 2000: ``I urge you not to use the term `intellectual property' in your thinking. It will lead you to misunderstand things, because that term generalizes about copyrights, patents, and trademarks. And those things are so different in their effects that it is entirely foolish to try to talk about them at once. If you hear somebody saying something 'about intellectual property,' without [putting it in] quotes, then he's not thinking very clearly and you shouldn't join.''

[RMS: The contrast it shows is that I've learned to be more cautious in generalizing.  I probably wouldn't talk about ``owning knowledge'' today, since it's a very broad concept.  But ``owning knowledge'' is not the same generalization as ``intellectual property,'' and the difference between those three laws is crucial to understanding any legal issue about owning knowledge.  Patents are direct monopolies over using specific knowledge; that really is one form of ``owning knowledge.'' Copyrights are one of the methods used to stop the sharing of works that embody or explain knowledge, which is a very different thing. Meanwhile, trademarks have very little to do with the subject of knowledge.]} Years later, Stallman would describe the GPL's creation in less hostile terms. ``I was thinking about issues that were in a sense ethical and in a sense political and in a sense legal,'' he says. ``I had to try to do what could be sustained by the legal system that we're in. In spirit the job was that of legislating the basis for a new society, but since I wasn't a government, I couldn't actually change any laws. I had to try to do this by building on top of the existing legal system, which had not been designed for anything like this.''

About the time Stallman was pondering the ethical, political, and legal issues associated with free software, a California hacker named Don Hopkins mailed him a manual for the 68000 microprocessor. Hopkins, a Unix hacker and fellow science-fiction buff, had borrowed the manual from Stallman a while earlier. As a display of gratitude, Hopkins decorated the return envelope with a number of stickers obtained at a local science-fiction convention. One sticker in particular caught Stallman's eye. It read, ``Copyleft (L), All Rights Reversed.''  Stallman, inspired by the sticker, nicknamed the legal technique employed in the GNU Emacs license (and later in the GNU GPL) ``Copyleft,'' jocularly symbolized by a backwards ``C'' in a circle. Over time, the nickname would become general Free Software Foundation terminology for any copyright license ``making a program free software and requiring all modified and extended versions of the program to be free software as well.''

The German sociologist Max Weber once proposed that all great religions are built upon the ``routinization'' or ``institutionalization'' of charisma. Every successful religion, Weber argued, converts the charisma or message of the original religious leader into a social, political, and ethical apparatus more easily translatable across cultures and time.

While not religious per se, the GNU GPL certainly qualifies as an interesting example of this ``routinization'' process at work in the modern, decentralized world of software development. Since its unveiling, programmers and companies who have otherwise expressed little loyalty or allegiance to Stallman have willingly accepted the GPL bargain at face value. Thousands have also accepted the GPL as a preemptive protective mechanism for their own software programs. Even those who reject the GPL conditions as too limiting still credit it as influential.

One hacker falling into this latter group was Keith Bostic, a University of California employee at the time of the GPL 1.0 release. Bostic's department, the Computer Systems Research Group (SRG), had been involved in Unix development since the late 1970s and was responsible for many key parts of Unix, including the TCP/IP networking protocol, the cornerstone of modern Internet communications. By the late 1980s, AT\&T, the original owner of the Unix software, began to focus on commercializing Unix and began looking to the Berkeley Software Distribution, or BSD, the academic version of Unix developed by Bostic and his Berkeley peers, as a key source of commercial technology.

The code written by Bostic and friends was off limits to nearly everyone, because it was intermixed with proprietary AT\&T code. Berkeley distributions were therefore available only to institutions that already had a Unix source license from AT\&T. As AT\&T raised its license fees, this arrangement, which had at first seemed innocuous (to those who thought only of academia) became increasingly burdensome even there.  To use Berkeley's code in GNU, Stallman would have to convince Berkeley to separate it from AT\&T's code and release it as free software.  In 1984 or 1985 he met with the leaders of the BSD effort, pointing out that AT\&T was not a charity and that for a university to donate its work (in effect) to AT\&T was not proper.  He asked them to separate out their code and release it as free software.

Hired in 1986, Bostic had taken on the personal project of porting the latest version of BSD to the PDP-11 computer. It was during this period, Bostic says, that he came into close interaction with Stallman during Stallman's occasional forays out to the west coast. ``I remember vividly arguing copyright with Stallman while he sat at borrowed workstations at CSRG,'' says Bostic. ``We'd go to dinner afterward and continue arguing about copyright over dinner.''

The arguments eventually took hold, although not in the way Stallman would have preferred. In June, 1989, Berkeley had separated its networking code from the rest of the AT\&T-owned operating system and began distributing it under a copyright-based free license. The license terms were liberal. All a licensee had to do was give credit to the university in advertisements touting derivative programs.\endnote{The University of California's ``obnoxious advertising clause'' would later prove to be a problem. Looking for a permissive alternative to the GPL, some hackers used the original BSD license, replacing ``University of California'' with their own names or the names of their institutions. The result: free software systems using many of these programs would have to cite dozens of names in advertisements. In 1999, after a few years of lobbying on Stallman's part, the University of California agreed to drop this clause. See ``The BSD License Problem'' at \url{http://www.gnu.org/philosophy/bsd.html}.} In contrast to the GPL, this license permitted proprietary offshoots.  One problem limited the use of the BSD Networking release: it wasn't a complete operating system, just the network-related parts of one.  While the code would be a major contribution to any free operating system, it could only be run at that time in conjunction with other, proprietary-licensed code.

Over the next few years, Bostic and other University of California employees worked to replace the missing components and turn BSD into a complete, freely redistributable operating system. Although delayed by a legal challenge from Unix Systems Laboratories -- the AT\&T spin-off that retained ownership of the Unix code -- the effort would finally bear fruit in the early 1990s. Even before then, however, many of the Berkeley network utilities would make their way into Stallman's GNU system.

``I think it's highly unlikely that we ever would have gone as strongly as we did without the GNU influence,'' says Bostic, looking back. ``It was clearly something where they were pushing hard and we liked the idea.''

By the end of the 1980s, the GPL was beginning to exert a gravitational effect on the free software community. A program didn't have to carry the GPL to qualify as free software -- witness the case of the BSD network utilities -- but putting a program under the GPL sent a definite message. ``I think the very existence of the GPL inspired people to think through whether they were making free software, and how they would license it,'' says Bruce Perens, creator of Electric Fence, a popular Unix utility, and future leader of the Debian GNU/Linux development team. A few years after the release of the GPL, Perens says he decided to discard Electric Fence's homegrown license in favor of Stallman's lawyer-vetted copyright. ``It was actually pretty easy to do,'' Perens recalls.

Rich Morin, the programmer who had viewed Stallman's initial GNU announcement with a degree of skepticism, recalls being impressed by the software that began to gather under the GPL umbrella. As the leader of a SunOS user group, one of Morin's primary duties during the 1980s had been to send out distribution tapes containing the best freeware or free software utilities. The job often mandated calling up original program authors to verify whether their programs were copyrighted or whether they had been consigned to the public domain. Around 1989, Morin says, he began to notice that the best software programs typically fell under the GPL license. ``As a software distributor, as soon as I saw the word GPL, I knew I was home free,'' recalls Morin.

To compensate for the prior hassles that went into compiling distribution tapes to the Sun User Group, Morin had charged recipients a convenience fee. Now, with programs moving over to the GPL, Morin was suddenly getting his tapes put together in half the time, turning a tidy profit in the process. Sensing a commercial opportunity, Morin rechristened his hobby as a business: Prime Time Freeware.

Such commercial exploitation was completely consistent with the free software agenda. ``When we speak of free software, we are referring to freedom, not price,'' advised Stallman in the GPL's preamble. By the late 1980s, Stallman had refined it to a more simple mnemonic: ``Don't think free as in free beer; think free as in free speech.''

For the most part, businesses ignored Stallman's entreaties. Still, for a few entrepreneurs, the freedom associated with free software was the same freedom associated with free markets. Take software ownership out of the commercial equation, and you had a situation where even the smallest software company was free to compete against the IBMs and DECs of the world.

One of the first entrepreneurs to grasp this concept was Michael Tiemann, a software programmer and graduate student at Stanford University. During the 1980s, Tiemann had followed the GNU Project like an aspiring jazz musician following a favorite artist. It wasn't until the release of the GNU C Compiler, or GCC, in 1987, however, that he began to grasp the full potential of free software. Dubbing GCC a ``bombshell,'' Tiemann says the program's own existence underlined Stallman's determination as a programmer.

``Just as every writer dreams of writing the great American novel, every programmer back in the 1980s talked about writing the great American compiler,'' Tiemman recalls. ``Suddenly Stallman had done it. It was very humbling.''

``You talk about single points of failure, GCC was it,'' echoes Bostic. ``Nobody had a compiler back then, until GCC came along.''

Rather than compete with Stallman, Tiemann decided to build on top of his work. The original version of GCC weighed in at 110,000 lines of code, but Tiemann recalls the program as surprisingly easy to understand. So easy in fact that Tiemann says it took less than five days to master and another week to port the software to a new hardware platform, National Semiconductor's 32032 microchip. Over the next year, Tiemann began playing around with the source code, creating the first ``native'' or direct compiler for the C++ programming language, by extending GCC to handle C++ as well as C. (The existing, proprietary implementation of the C++ language worked by converting the code to the C language, then feeding the result to a C compiler.) One day, while delivering a lecture on the program at Bell Labs, Tiemann ran into some AT\&T developers struggling to pull off the same thing.

``There were about 40 or 50 people in the room, and I asked how many people were working on the native code compiler,'' Tiemann recalls. ``My host said the information was confidential but added that if I took a look around the room I might get a good general idea.''

It wasn't long after, Tiemann says, that the light bulb went off in his head. ``I had been working on that project for six months,'' Tiemann says. I just thought to myself, whether it's me or the code, this is a level of efficiency that the free market should be ready to reward.''

Tiemann found added inspiration in the \textit{GNU Manifesto}: while excoriating the greed of proprietary software vendors, it also encourages companies, as long as they respect users freedom, to use and redistribute free software in their commercial activities. By removing the power of monopoly from the commercial software question, the GPL makes it possible for even small companies to compete on the basis of service, which extends from simple tech support to training to extending free programs for specific clients' needs.

In a 1999 essay, Tiemann recalls the impact of Stallman's \textit{Manifesto}. ``It read like a socialist polemic, but I saw something different. I saw a business plan in disguise.''\endnote{See Michael Tiemann, ``Future of Cygnus Solutions: An Entrepreneur's Account,'' \textit{Open Sources} (O'Reilly \& Associates, Inc., 1999): 139, \url{http://www.oreilly.com/catalog/opensources/book/tiemans.html}.}

This business plan was not new; Stallman supported himself in the late 80s by doing this on a small scale.  But Tiemann intended to take it to a new level.
Teaming up with John Gilmore and David Vinayak Wallace, Tiemann launched a software consulting service dedicated to customizing GNU programs. Dubbed Cygnus Support (informally, ``Cygnus'' was a recursive acronym for ``Cygnus, Your GNU Support''), the company signed its first development contract in February, 1990. By the end of the year, the company had \$725,000 worth of support and development contracts.

The complete GNU operating system Stallman envisioned required more than software development tools.  In the 1990s, GNU also developed a command line interpreter or ``shell,'' which was an extended replacement for the Bourne Shell (written by FSF employee Brian Fox, and christened by Stallman the Bourne Again Shell, or BASH), as well as the PostScript interpreter Ghostscript, the documentation browser platform Texinfo, the C Library which C programs need in order to run and talk to the system's kernel, the spreadsheet Oleo (``better for you than the more expensive spreadsheet''), and even a fairly good chess game.  However, programmers were typically most interested in the GNU programming tools.

GNU Emacs, GDB, and GCC were the ``big three'' of developer-oriented tools, but they weren't the only ones developed by the GNU Project in the 80s. By 1990, GNU had also generated GNU versions of the build-controller Make, the parser-generator YACC (rechristened Bison), and awk (rechristened gawk); as well as dozens more. Like GCC, GNU programs were usually designed to run on multiple systems, not just a single vendor's platform. In the process of making programs more flexible, Stallman and his collaborators often made them more useful as well.

Recalling the GNU universalist approach, Prime Time Freeware's Morin points to a useless but vitally important software package called GNU Hello, which serves as an example to show programmers how to properly package a program for GNU. ``It's the hello world program which is five lines of C, packaged up as if it were a GNU distribution,'' Morin says. ``And so it's got the Texinfo stuff and the configure stuff. It's got all the other software engineering goo that the GNU Project has come up with to allow packages to port to all these different environments smoothly. That's tremendously important work, and it affects not only all of [Stallman's] software, but also all of the other GNU Project software.''

According to Stallman, improving technically on the components of Unix was secondary to replacing them with free software. ``With each piece I may or may not find a way to improve it,'' said Stallman to \textit{BYTE}. ``To some extent I am getting the benefit of reimplementation, which makes many systems much better. To some extent it's because I have been in the field a long time and worked on many other systems. I therefore have many ideas [which I learned from them] to bring to bear.''\endnote{See Richard Stallman, \textit{BYTE} (1986).}

Nevertheless, as GNU tools made their mark in the late 1980s, Stallman's AI Lab-honed reputation for design fastidiousness soon became legendary throughout the entire software-development community.

Jeremy Allison, a Sun user during the late 1980s and programmer destined to run his own free software project, Samba, in the 1990s, recalls that reputation with a laugh. During the late 1980s, Allison began using Emacs. Inspired by the program's community-development model, Allison says he sent in a snippet of source code only to have it rejected by Stallman.

``It was like the \textit{Onion} headline,'' Allison says. ``\hspace{0.01in}`Child's prayers to God answered: No.'\hspace{0.01in}''

As the GNU Project moved from success to success in creation of user-level programs and libraries, it postponed development of the kernel, the central ``traffic cop'' program that controls other programs' access to the processor and all machine resources.

As with several other major system components, Stallman sought a head-start on kernel development by looking for an existing program to adapt. A review of GNU Project ``GNUsletters'' of the late 1980s reveals that this approach, like the initial attempt to build GCC out of Pastel, had its problems. A January, 1987 GNUsletter reported the GNU Project's intention to overhaul TRIX, a kernel developed at MIT. However, Stallman never actually tried to do this, since he was working on GCC at the time; later he concluded that TRIX would require too much change to be a good starting point. By February of 1988, according to a newsletter published that month, the GNU Project had shifted its kernel plans to Mach, a lightweight ``micro-kernel'' developed at Carnegie Mellon. Mach was not then free software, but its developers privately said they would liberate it; when this occurred, in 1990, GNU Project kernel development could really commence.\endnote{See ``Hurd History,'' \url{http://www.gnu.org/software/hurd/history.html}.}

The delays in kernel development were just one of many concerns weighing on Stallman during this period. In 1989, Lotus Development Corporation filed suit against rival software companies, Paperback Software International and Borland, for copying menu commands from Lotus' popular 1-2-3 Spreadsheet program. Lotus' suit, coupled with the Apple-Microsoft ``look and feel'' battle, endangered the future of the GNU system. Although neither suit directly attacked the GNU Project, both threatened the right to develop software compatible with existing programs, as many GNU programs were.  These lawsuits could impose a chilling effect on the entire culture of software development. Determined to do something, Stallman and a few professors put an ad in \textit{The Tech} (the MIT student newspaper) blasting the lawsuits and calling for a boycott of both Lotus and Apple. He then followed up the ad by helping to organize a group to protest the corporations filing the suit. Calling itself the League for Programming Freedom, the group held protests outside the offices of Lotus, Inc.

The protests were notable.\endnote{According to a League for Programming Freedom press release at \url{http://progfree.org/Links/prep.ai.mit.edu/demo.final.release}, the protests were notable for featuring the first hexadecimal protest chant:

\begin{verse}
1-2-3-4, toss the lawyers out the door\\
5-6-7-8, innovate don't litigate\\
9-A-B-C, 1-2-3 is not for me\\
D-E-F-O, look and feel have got to go\\
\end{verse}}

They document the evolving nature of the software industry. Applications had quietly replaced operating systems as the primary corporate battleground. In its unfinished quest to build a free software operating system, the GNU Project seemed hopelessly behind the times to those whose primary values were fashion and success. Indeed, the very fact that Stallman had felt it necessary to put together an entirely new group dedicated to battling the ``look and feel'' lawsuits led some observers to think that the FSF was obsolete.

However, Stallman had a strategic reason to start a separate organization to fight the imposition of new monopolies on software development: so that proprietary software developers would join it too.  Extending copyright to cover interfaces would threaten many proprietary software developers as well as many free software developers.  These proprietary developers were unlikely to endorse the Free Software Foundation, but there was, intentionally, nothing in the League for Programming Freedom to drive them away.  For the same reason, Stallman handed over leadership of LPF to others as soon as it was feasible.

In 1990, the John D. and Catherine T. MacArthur Foundation certified Stallman's genius status when it granted Stallman a MacArthur fellowship, the so-called ``genius grant,'' amounting in this case to \$240,000 over 5 years. Although the Foundation does not state a reason for its grants, this one was seen as an award for launching the GNU Project and giving voice to the free software philosophy.  The grant relieved a number of short-term concerns for Stallman.  For instance, it enabled him to cease the consulting work through which he had obtained his income in the 80s and devote more time to the free software cause.

The award also made it possible for Stallman to register normally to vote. In 1985 a fire in the house where Stallman lived left him without an official domicile.  It also covered most of his books with ash, and cleaning these ``dirty books'' did not yield satisfying results. From that time he lived as a ``squatter'' at 545 Technology Square, and had to vote as a ``homeless person.''\endnote{See Reuven Lerner, ``Stallman wins \$240,000 MacArthur award,'' MIT, \textit{The Tech} (July 18, 1990), \url{http://the-tech.mit.edu/V110/N30/rms.30n.html}.} ``[The Cambridge Election Commission] didn't want to accept that as my address,'' Stallman would later recall. ``A newspaper article about the MacArthur grant said that, and then they let me register.''\endnote{See Michael Gross, ``Richard Stallman: High School Misfit, Symbol of Free Software, MacArthur-certified Genius'' (1999).}

Most importantly, the MacArthur fellowship gave Stallman press attention and speaking invitations, which he used to spread the word about GNU, free software, and dangers such as ``look and feel'' lawsuits and software patents.

Interestingly, the GNU system's completion would stem from one of these trips. In April 1991, Stallman paid a visit to the Polytechnic University in Helsinki, Finland. Among the audience members was 21-year-old Linus Torvalds, who was just beginning to develop the Linux kernel -- the free software kernel destined to fill the GNU system's main remaining gap.

A student at the nearby University of Helsinki at the time, Torvalds regarded Stallman with bemusement. ``I saw, for the first time in my life, the stereotypical long-haired, bearded hacker type,'' recalls Torvalds in his 2001 autobiography \textit{Just for Fun}. ``We don't have much of them in Helsinki.''\endnote{See Linus Torvalds and David Diamond, \textit{Just For Fun: The Story of an Accidentaly Revolutionary} (HarperCollins Publishers, Inc., 2001): 58-59. Although presumably accurate in regard to Torvalds' life, what the book says about Stallman is sometimes wrong.  For instance, it says that Stallman ``wants to make everything open source,'' and that he ``complains about other people not using the GPL.''  In fact, Stallman advocates free software, not open source.  He urges authors to choose the GNU GPL, in most circumstances, but says that all free software licenses are ethical.}

While not exactly attuned to the ``sociopolitical'' side of the Stallman agenda, Torvalds nevertheless appreciated one aspect of the agenda's underlying logic: no programmer writes error-free code. Even when users have no wish to adapt a program to their specific preferences, any program can use improvement. By sharing software, hackers put a program's improvement ahead of individual motivations such as greed or ego protection.

Like many programmers of his generation, Torvalds had cut his teeth not on mainframe computers like the IBM 7094, but on a motley assortment of home-built computer systems. As a university student, Torvalds had made the step up from PC programming to Unix, using the university's MicroVAX. This ladder-like progression had given Torvalds a different perspective on the barriers to machine access. For Stallman, the chief barriers were bureaucracy and privilege. For Torvalds, the chief barriers were geography and the harsh Helsinki winter. Forced to trek across the University of Helsinki just to log in to his Unix account, Torvalds quickly began looking for a way to log in from the warm confines of his off-campus apartment.

Torvalds was using Minix, a lightweight nonfree system developed as an instructional example by Dutch university professor Andrew Tanenbaum.\endnote{It was non-free in 1991.  Minix is free software now.} It included the non-free Free University Compiler Kit, plus utilities of the sort that Tanenbaum had contemptuously invited Stallman in 1983 to write.\endnote{Tanenbaum describes Minix as an ``operating system'' in his book, \textit{Operating System Design and Implementation}, but what the book discusses is only the part of the system that corresponds to the kernel of Unix.  There are two customary usages of the term ``operating system,'' and one of them is what is called the ``kernel'' in Unix terminology.  But that's not the only terminological complication in the subject.  That part of Minix consists of a microkernel plus servers that run on it, a design of the same kind as the GNU Hurd plus Mach.  The microkernel plus servers are comparable to the kernel of Unix. but when that book says ``the kernel,'' it refers to the microkernel only.  See Andrew Tanenbaum, \textit{Operating System Design and Implementation}, 1987.}

Minix fit within the memory confines of Torvalds' 386 PC, but it was intended more to be studied than used.  The Minix system also lacked the facility of terminal emulation, which would mimic a typical display terminal and thus enable Torvalds to log in to the MicroVAX from home.

Early in 1991, Torvalds began writing a terminal emulation program.  He used Minix to develop his emulator, but the emulator didn't run on Minix; it was a stand-alone program.  Then he gave it features to access disk files in Minix's file system.  Around then, Torvalds referred to his evolving work as the ``GNU/Emacs of terminal emulation programs.''\endnote{See Linus Torvalds and David Diamond, \textit{Just For Fun: The Story of an Accidentaly Revolutionary} (HarperCollins Publishers, Inc., 2001): 78.}

Since Minix lacked many important features. Torvalds began extending his terminal emulator into a kernel comparable to that of Minix, except that it was monolithic.  Feeling ambitious, he solicited a Minix newsgroup for copies of the POSIX standards, the specifications for a Unix-compatible kernel.\endnote{POSIX was subsequently extended to include specifications for many command line features, but that did not exist in 1991.} A few weeks later, having put his kernel together with some GNU programs and adapted them to work with it, Torvalds was posting a message reminiscent of Stallman's original 1983 GNU posting:

\begin{quote}
Hello everybody out there using minix-

I'm doing a (free) operating system (just a hobby, won't be big and professional like gnu) for 386 (486) AT clones. This has been brewing since April, and is starting to get ready. I'd like any feedback on things people like/dislike in minix, as my OS resembles it somewhat (same physical layout of the file-system (due to practical reasons) among other things).  I've currently ported bash (1.08) and gcc (1.40)\ldots\endnote{\textit{Ibid, p. 85.}}
\end{quote}

The posting drew a smattering of responses and within a month, Torvalds had posted a 0.01 version of his kernel -- i.e., the earliest possible version fit for outside review -- on an Internet FTP site. In the course of doing so, Torvalds had to come up with a name for the new kernel. On his own PC hard drive, Torvalds had saved the program as Linux, a name that paid its respects to the software convention of giving each Unix variant a name that ended with the letter X. Deeming the name too ``egotistical,'' Torvalds changed it to Freax, only to have the FTP site manager change it back.

Torvalds said he was writing a free operating system, and his comparing it with GNU shows he meant a complete system.  However, what he actually wrote was a kernel, pure and simple. Torvalds had no need to write more than the kernel because, as he knew, the other needed components were already available, thanks to the developers of GNU and other free software projects.  Since the GNU Project wanted to use them all in the GNU system, it had perforce made them work together.  While Torvalds continued developing the kernel, he (and later his collaborators) made those programs work with it too.

Initially, Linux was not free software: the license it carried did not qualify as free, because it did not allow commercial distribution. Torvalds was worried that some company would swoop in and take Linux away from him.  However, as the growing GNU/Linux combination gained popularity, Torvalds saw that sale of copies would be useful for the community, and began to feel less worried about a possible takeover.\endnote{\textit{Ibid, p. 94-95.}} This led him to reconsider the licensing of Linux.

Neither compiling Linux with GCC nor running GCC with Linux required him legally to release Linux under the GNU GPL, but Torvalds' use of GCC implied for him a certain obligation to let other users borrow back. As Torvalds would later put it: ``I had hoisted myself up on the shoulders of giants.''\endnote{\textit{Ibid, p. 95-97.}} Not surprisingly, he began to think about what would happen when other people looked to him for similar support. A decade after the decision, Torvalds echoes the Free Software Foundation's Robert Chassell when he sums up his thoughts at the time:

\begin{quote}
You put six months of your life into this thing and you want to make it available and you want to get something out of it, but you don't want people to take advantage of it. I wanted people to be able to see [Linux], and to make changes and improvements to their hearts' content. But I also wanted to make sure that what I got out of it was to see what they were doing. I wanted to always have access to the sources so that if they made improvements, I could make those improvements myself.\endnote{See Linus Torvalds and David Diamond, \textit{Just For Fun: The Story of an Accidentaly Revolutionary} (HarperCollins Publishers, Inc., 2001): 94-95.}
\end{quote}

When it was time to release the 0.12 version of Linux, the first to operate fully with GCC, Torvalds decided to throw his lot in with the free software movement. He discarded the old license of Linux and replaced it with the GPL. Within three years, Linux developers were offering release 1.0 of Linux, the kernel; it worked smoothly with the almost complete GNU system, composed of programs from the GNU Project and elsewhere.  In effect, they had completed the GNU operating system by adding Linux to it.  The resulting system was basically GNU plus Linux.  Torvalds and friends, however, referred to it confusingly as ``Linux.''

By 1994, the amalgamated system had earned enough respect in the hacker world to make some observers from the business world wonder if Torvalds hadn't given away the farm by switching to the GPL in the project's initial months. In the first issue of \textit{Linux Journal}, publisher Robert Young sat down with Torvalds for an interview. When Young asked the Finnish programmer if he felt regret at giving up private ownership of the Linux source code, Torvalds said no. ``Even with 20/20 hindsight,'' Torvalds said, he considered the GPL ``one of the very best design decisions'' made during the early stages of the Linux project.\endnote{See Robert Young, ``Interview with Linus, the Author of Linux,'' \textit{Linux Journal} (March 1, 1994), \url{http://www.linuxjournal.com/article/2736}.}

That the decision had been made with zero appeal or deference to Stallman and the Free Software Foundation speaks to the GPL's growing portability. Although it would take a couple of years to be recognized by Stallman, the explosiveness of Linux development conjured flashbacks of Emacs. This time around, however, the innovation triggering the explosion wasn't a software hack like Control-R but the novelty of running a Unix-like system on the PC architecture. The motives may have been different, but the end result certainly fit the ethical specifications: a fully functional operating system composed entirely of free software.

As his initial email message to the comp.os.minix newsgroup indicates, it would take a few months before Torvalds saw Linux as anything more than a holdover until the GNU developers delivered on the Hurd kernel. As far as Torvalds was concerned, he was simply the latest in a long line of kids taking apart and reassembling things just for fun. Nevertheless, when summing up the runaway success of a project that could have just as easily spent the rest of its days on an abandoned computer hard drive, Torvalds credits his younger self for having the wisdom to give up control and accept the GPL bargain.

``I may not have seen the light,'' writes Torvalds, reflecting on Stallman's 1991 Polytechnic University speech and his subsequent decision to switch to the GPL. ``But I guess something from his speech sunk in.''\endnote{See Linus Torvalds and David Diamond, \textit{Just For Fun: The Story of an Accidentaly Revolutionary} (HarperCollins Publishers, Inc., 2001): 59.}

\theendnotes
\setcounter{endnote}{0}
