Part II of Two Bits describes what Free Software is and where it came from, with each of its five chapters detailing the historical narrative of a particular kind of practice: creating a movement, sharing source code, conceptualizing openness or open systems, writing copyright (and copyleft) licenses, and coordinating collaborations. Taken together, the stories describe Free Software. The stories have their endpoint (or starting point, genealogically speaking) in the years 1998â€“99, when Free Software burst onto the scene: on the cover of Forbes magazine, as part of the dotcom boom, and in the boardrooms of venture-capital firms and corporations like IBM and Netscape. While the chapters that make up part II can be read discretely to understand the practices that are the sine qua non of Free Software, they can also be read continuously, as a meandering story of the history of software and networks stretching from the late 1950s to the present.
Rather than define what makes Free Software free or Open Source open, Two Bits treats the five practices as parts of a collective technical experimental system: each component has its own history, development, and temporality, but they come together as a package and emerge as a recognizable thing around 1998â€“99. As with any experimental system, changing the components changes the operation and outcomes of the whole. Free Software so conceived is a kind of experimental system: its practices can be adopted, adapted, and modulated in new contexts and new places, but it is one whose rules are collectively determined and frequently modified. It is possible to see in each of the five practices where choices about how to do Free Software reached, or surpassed, certain limits, but nonetheless remained part of a system whose identity finally firmed up in the period 1998â€“99 and after.
The first of these practicesâ€”the making of Free Software into a movementâ€”is both the most immediately obvious and the most difficult to grasp. By the term movement I refer to the practice, among geeks, of arguing about and discussing the structure and meaning of Free Software: what it consists of, what it is for, and whether or not it is a movement. Some geeks call Free Software a movement, and some donâ€™t; some talk about the ideology and goals of Free Software, and some donâ€™t; some call it Free Software, while others call it Open Source. Amid all this argument, however, Free Software geeks recognize that they are all doing the same thing: the practice of creating a movement is the practice of talking about the meaning and necessity of the other four practices. It was in 1998â€“99 that geeks came to recognize that they were all doing the same thing and, almost immediately, to argue about why.1
One way to understand the movement is through the story of Netscape and the Mozilla Web browser (now known as Firefox). Not only does this story provide some context for the stories of geeks presented in part Iâ€”and I move here from direct participant observation to historical and archival research on a phenomenon that was occurring at roughly the same timeâ€”but it also contains all the elements necessary to understand Free Software. It is full of discussion and argument about the practices that make up Free Software: sharing source code, conceiving of openness, writing licenses, and coordinating collaborations.
Forking Free Software, 1997â€“2000
Free Software forked in 1998 when the term Open Source suddenly appeared (a term previously used only by the CIA to refer to unclassified sources of intelligence). The two terms resulted in two separate kinds of narratives: the first, regarding Free Software, stretched back into the 1980s, promoting software freedom and resistance to proprietary software â€œhoarding,â€ as Richard Stallman, the head of the Free Software Foundation, refers to it; the second, regarding Open Source, was associated with the dotcom boom and the evangelism of the libertarian pro-business hacker Eric Raymond, who focused on the economic value and cost savings that Open Source Software represented, including the pragmatic (and polymathic) approach that governed the everyday use of Free Software in some of the largest online start-ups (Amazon, Yahoo!, HotWired, and others all â€œpromotedâ€ Free Software by using it to run their shops).
A critical point in the emergence of Free Software occurred in 1998â€“99: new names, new narratives, but also new wealth and new stakes. â€œOpen Sourceâ€ was premised on dotcom promises of cost-cutting and â€œdisintermediationâ€ and various other schemes to make money on it (Cygnus Solutions, an early Free Software company, playfully tagged itself as â€œMaking Free Software More Affordableâ€). VA Linux, for instance, which sold personal-computer systems pre-installed with Open Source operating systems, had the largest single initial public offering (IPO) of the stock-market bubble, seeing a 700 percent share-price increase in one day. â€œFree Softwareâ€ by contrast fanned kindling flames of worry over intellectual-property expansionism and hitched itself to a nascent legal resistance to the 1998 Digital Millennium Copyright Act and Sonny Bono Copyright Term Extension Act. Prior to 1998, Free Software referred either to the Free Software Foundation (and the watchful, micromanaging eye of Stallman) or to one of thousands of different commercial, avocational, or university-research projects, processes, licenses, and ideologies that had a variety of names: sourceware, freeware, shareware, open software, public domain software, and so on. The term Open Source, by contrast, sought to encompass them all in one movement.
The event that precipitated this attempted semantic coup dâ€™Ã©tat was the release of the source code for Netscapeâ€™s Communicator [PAGE 100] Web browser. Itâ€™s tough to overestimate the importance of Netscape to the fortunes of Free Software. Netscape is justly famous for its 1995 IPO and its decision to offer its core product, Netscape Navigator, for free (meaning a compiled, binary version could be downloaded and installed â€œfor zero dollarsâ€). But Netscape is far more famous among geeks for giving away something else, in 1998: the source code to Netscape Communicator (nÃ©e Navigator). Giving away the Navigator application endeared Netscape to customers and confused investors. Giving away the Communicator source code in 1998 endeared Netscape to geeks and confused investors; it was ignored by customers.
Netscape is important from a number of perspectives. Businesspeople and investors knew Netscape as the pet project of the successful businessman Jim Clarke, who had founded the specialty computer manufacturer, Silicon Graphics Incorporated (SGI). To computer scientists and engineers, especially in the small university town of Champaign-Urbana, Illinois, Netscape was known as the highest bidder for the WWW team at the National Center for Supercomputing Applications (NCSA) at the University of Illinois. That teamâ€”Marc Andreessen, Rob McCool, Eric Bina, Jon Mittelhauser, Aleks Totic, and Chris Houckâ€”had created Mosaic, the first and most fondly remembered â€œgraphical browserâ€ for surfing the World Wide Web. Netscape was thus first known as Mosaic Communications Corporation and switched its name only after legal threats from NCSA and a rival firm, Spyglass. Among geeks, Netscape was known as home to a number of Free Software hackers and advocates, most notably Jamie Zawinski, who had rather flamboyantly broken rank with the Free Software Foundation by forking the GNU EMACS code to create what was first known as Lucid Emacs and later as XEmacs. Zawinski would go on to lead the newly free Netscape browser project, now known as Mozilla.
Meanwhile, most regular computer users remember Netscape both as an emblem of the dotcom boomâ€™s venture-fed insanity and as yet another of Microsoftâ€™s victims. Although Netscape exploded onto the scene in 1995, offering a feature-rich browser that was an alternative to the bare-bones Mosaic browser, it soon began to lose ground to Microsoft, which relatively quickly adopted the strategy of giving away its browser, Internet Explorer, as if it were part of the Windows operating system; this was a practice that the U.S. Department of Justice eventually found to be in violation of [PAGE 101] antitrust laws and for which Microsoft was convicted, but never punished.
The nature of Netscapeâ€™s decision to release the source code differs based on which perspective it is seen from. It could appear to be a business plan modeled on the original success: give away your product and make money in the stock market. It could appear to be a strategic, last-gasp effort to outcompete Microsoft. It could also appear, and did appear to many geeks, to be an attempt to regain some of that â€œhacker-credâ€ it once had acquired by poaching the NCSA team, or even to be an attempt to â€œdo the right thingâ€ by making one of the worldâ€™s most useful tools into Free Software. But why would Netscape reach such a conclusion? By what reasoning would such a decision seem to be correct? The reasons for Netscapeâ€™s decision to â€œfree the sourceâ€ recapitulate the five core practices of Free Softwareâ€”and provided key momentum for the new movement.
Sharing Source CodeÂ Â Â Â Â Â Â Â Â Â Â Netscapeâ€™s decision to share its source code could only seem surprising in the context of the widespread practice of keeping source code secret; secrecy was a practice followed largely in order to prevent competitors from copying a program and competing with it, but also as a means to control the market itself. The World Wide Web that Andreessenâ€™s team at NCSA had cut their teeth on was itself designed to be â€œplatform independentâ€ and accessible by any device on the network. In practice, however, this meant that someone needed to create â€œbrowsersâ€ for each different computer or device. Mosaic was initially created for UNIX, using the Motif library of the X11 Window Systemâ€”in short, a very specific kind of access. Netscape, by contrast, prided itself on â€œportingâ€ Netscape Navigator to nearly all available computer architectures. Indeed, by 1997, plans were under way to create a version of the browserâ€”written in Java, the programming language created by Sun Microsystems to â€œwrite once, run anywhereâ€â€”that would be completely platform independent.
The Java-based Navigator (called Javagator, of course) created a problem, however, with respect to the practice of keeping source code secret. Whenever a program in Java was run, it created a set of â€œbytecodesâ€ that were easy to reverse-engineer because they had to be transmitted from the server to the machine that ran the program and were thus visible to anyone who might know how and where to look. Netscape engineers flirted with the idea of deliberately [PAGE 102] obfuscating these bytecodes to deter competitors from copying them. How can one compete, the logic goes, if anyone can copy your program and make their own ersatz version?
Zawinski, among others, suggested that this was a bad idea: why not just share the source code and get people to help make it better? As a longtime participant in Free Software, Zawinski understood the potential benefits of receiving help from a huge pool of potential contributors. He urged his peers at Netscape to see the light. However, although he told them stories and showed them successes, he could never make the case that this was an intelligent business plan, only that it was an efficient software-engineering plan. From the perspective of management and investors, such a move seemed tantamount to simply giving away the intellectual property of the company itself.
Frank Hecker, a sales manager, made the link between the developers and management: â€œIt was obvious to [developers] why it was important. It wasnâ€™t really clear from a senior management level why releasing the source code could be of use because nobody ever made the business case.â€2 Hecker penned a document called â€œNetscape Source Code as Netscape Productâ€ and circulated it to various people, including Andreessen and Netscape CEO Jim Barksdale. As the title suggests, the business case was that the source code could also be a product, and in the context of Netscape, whose business model was â€œgive it away and make it up on the stock market,â€ such a proposal seemed less insane than it otherwise might have: â€œWhen Netscape first made Navigator available for unrestricted download over the Internet, many saw this as flying in the face of conventional wisdom for the commercial software business, and questioned how we could possibly make money â€˜giving our software away.â€™ Now of course this strategy is seen in retrospect as a successful innovation that was a key factor in Netscapeâ€™s rapid growth, and rare is the software company today that does not emulate our strategy in one way or another. Among other things, this provokes the following question: What if we were to repeat this scenario, only this time with source code?â€3
Under the influence of Hecker, Zawinski, and CTO Eric Hahn (who had also written various internal â€œheresy documentsâ€ suggesting similar approaches), Netscape eventually made the decision to share their source code with the outside world, a decision that resulted in a famous January 1998 press release describing the aims [PAGE 103] and benefits of doing so. The decision, at that particular point in Netscapeâ€™s life, and in the midst of the dotcom boom, was certainly momentous, but it did not lead either to a financial windfall or to a suddenly superior product.4
Conceptualizing Open SystemsÂ Â Â Â Â Â Â Â Â Â Â Releasing the source code was, in a way, an attempt to regain the trust of the people who had first imagined the www. Tim Berners-Lee, the initial architect of the www, was always adamant that the protocol and all its implementations should be freely available (meaning either â€œin the public domainâ€ or â€œreleased as Free Softwareâ€). Indeed, Berners-Lee had done just that with his first bare-bones implementations of the www, proudly declaring them to be in the public domain.
Over the course of the 1990s, the â€œbrowser warsâ€ caused both Netscape and Microsoft to stray far from this vision: each had implemented its own extensions and â€œfeaturesâ€ to the browsers and servers, extensions not present in the protocol that Berners-Lee had created or in the subsequent standards created by the World Wide Web Consortium (W3C). Included in the implementations were various kinds of â€œevilâ€ that could make browsers fail to work on certain operating systems or with certain kinds of servers. The â€œbrowser warsâ€ repeated an open-systems battle from the 1980s, one in which the attempt to standardize a network operating system (UNIX) was stymied by competition and secrecy, at the same time that consortiums devoted to â€œopennessâ€ were forming in order to try to prevent the spread of evil. Despite the fact that both Microsoft and Netscape were members of the W3C, the noncompatibility of their browsers clearly represented the manipulation of the standards process in the name of competitive advantage.
Releasing the source code for Communicator was thus widely seen as perhaps the only way to bypass the poisoned well of competitively tangled, nonstandard browser implementations. An Open Source browser could be made to comply with the standardsâ€”if not by the immediate members involved with its creation, then by creating a â€œforkâ€ of the program that was standards compliantâ€”because of the rights of redistribution associated with an Open Source license. Open Source would be the solution to an open-systems problem that had never been solved because it had never confronted the issue of intellectual property directly. Free Software, by contrast, had a well-developed solution in the GNU General [PAGE 104] Public License, also known as copyleft license, that would allow the software to remain free and revive hope for maintaining open standards.
Writing LicensesÂ Â Â Â Â Â Â Â Â Â Â Herein lies the rub, however: Netscape was immediately embroiled in controversy among Free Software hackers because it chose to write its own bespoke licenses for distributing the source code. Rather than rely on one of the existing licenses, such as the GNU GPL or the Berkeley Systems Distribution (BSD) or MIT licenses, they created their own: the Netscape Public License (NPL) and the Mozilla Public License. The immediate concerns of Netscape had to do with their existing network of contracts and agreements with other, third-party developersâ€”both those who had in the past contributed parts of the existing source code that Netscape might not have the rights to redistribute as Free Software, and those who were expecting in the future to buy and redistribute a commercial version. Existing Free Software licenses were either too permissive, giving to third parties rights that Netscape itself might not have, or too restrictive, binding Netscape to make source code freely available (the GPL) when it had already signed contracts with buyers of the nonfree code.
It was a complex and specific business situationâ€”a network of existing contracts and licensed codeâ€”that created the need for Netscape to write its own license. The NPL thus contained a clause that allowed Netscape special permission to relicense any particular contribution to the source code as a proprietary product in order to appease its third-party contracts; it essentially gave Netscape special rights that no other licensee would have. While this did not necessarily undermine the Free Software licensesâ€”and it was certainly Netscapeâ€™s prerogativeâ€”it was contrary to the spirit of Free Software: it broke the â€œrecursive publicâ€ into two halves. In order to appease Free Software geeks, Netscape wrote one license for existing code (the NPL) and a different license for new contributions: the Mozilla Public License.
Neither Stallman nor any other Free Software hacker was entirely happy with this situation. Stallman pointed out three flaws: â€œOne flaw sends a bad philosophical message, another puts the free software community in a weak position, while the third creates a major practical problem within the free software community. Two of the flaws apply to the Mozilla Public License as well.â€ He urged people [PAGE 105] not to use the NPL. Similarly, Bruce Perens suggested, â€œMany companies have adopted a variation of the MPL [sic] for their own programs. This is unfortunate, because the NPL was designed for the specific business situation that Netscape was in at the time it was written, and is not necessarily appropriate for others to use. It should remain the license of Netscape and Mozilla, and others should use the GPL or the BSD or X licenses.â€5
Arguments about the fine details of licenses may seem scholastic, but the decision had a huge impact on the structure of the new product. As Steven Weber has pointed out, the choice of license tracks the organization of a product and can determine who and what kinds of contributions can be made to a project.6 It is not an idle choice; every new license is scrutinized with the same intensity or denounced with the same urgency.
Coordinating CollaborationsÂ Â Â Â Â Â Â Â Â Â Â One of the selling points of Free Software, and especially of its marketing as Open Source, is that it leverages the work of thousands or hundreds of thousands of volunteer contributors across the Internet. Such a claim almost inevitably leads to spurious talk of â€œself-organizingâ€ systems and emergent properties of distributed collaboration. The Netscape press release promised to â€œharness the creative power of thousands of programmers on the Internet by incorporating their best enhancements,â€ and it quoted CEO Jim Barksdale as saying, â€œBy giving away the source code for future versions, we can ignite the creative energies of the entire Net community and fuel unprecedented levels of innovation in the browser market.â€7 But as anyone who has ever tried to start or run a Free Software project knows, it never works out that way.
Software engineering is a notoriously hard problem.8 The halls of the software industry are lined with the warning corpses of dead software methodologies. Developing software in the dotcom boom was no different, except that the speed of release cycles and the velocity of funding (the â€œburn rateâ€) was faster than ever before. Netscapeâ€™s in-house development methodologies were designed to meet these pressures, and as many who work in this field will attest, that method is some version of a semistructured, deadline-driven, caffeine- and smart-drinkâ€“fueled race to â€œship.â€9
Releasing the Mozilla code, therefore, required a system of coordination that would differ from the normal practice of in-house [PAGE 106] software development by paid programmers. It needed to incorporate the contributions of outsidersâ€”developers who didnâ€™t work for Netscape. It also needed to entice people to contribute, since that was the bargain on which the decision to free the source was based, and to allow them to track their contributions, so they could verify that their contributions were included or rejected for legitimate reasons. In short, if any magical Open Source self-organization were to take place, it would require a thoroughly transparent, Internet-based coordination system.
At the outset, this meant practical things: obtaining the domain name mozilla.org; setting up (and in turn releasing the source code for) the version-control system (the Free Software standard cvs), the version-control interface (Bonsai), the â€œbuild systemâ€ that managed and displayed the various trees and (broken) branches of a complex software project (Tinderbox), and a bug-reporting system for tracking bugs submitted by users and developers (Bugzilla). It required an organizational system within the Mozilla project, in which paid developers would be assigned to check submissions from inside and outside, and maintainers or editors would be designated to look at and verify that these contributions should be used.
In the end, the release of the Mozilla source code was both a success and a failure. Its success was long in coming: by 2004, the Firefox Web browser, based on Mozilla, had started to creep up the charts of most popular browsers, and it has become one of the most visible and widely used Free Software applications. The failure, however, was more immediate: Mozilla failed to reap the massive benefits for Netscape that the 1995 give-away of Netscape Navigator had. Zawinski, in a public letter of resignation in April 1999 (one year after the release), expressed this sense of failure. He attributed Netscapeâ€™s decline after 1996 to the fact that it had â€œstopped innovatingâ€ and become too large to be creative, and described the decision to free the Mozilla source code as a return to this innovation: â€œ[The announcement] was a beacon of hope to me. . . . [I]t was so crazy, it just might work. I took my cue and ran with it, registering the domain that night, designing the structure of the organization, writing the first version of the web site, and, along with my co-conspirators, explaining to room after room of Netscape employees and managers how free software worked, and what we had to do to make it work.â€10 For Zawinski, the decision was both a chance for Netscape to return to its glory and an opportunity [PAGE 107] to prove the power of Free Software: â€œI saw it as a chance for the code to actually prosper. By making it not be a Netscape project, but rather, be a public project to which Netscape was merely a contributor, the fact that Netscape was no longer capable of building products wouldnâ€™t matter: the outsiders would show Netscape how itâ€™s done. By putting control of the web browser into the hands of anyone who cared to step up to the task, we would ensure that those people would keep it going, out of their own self-interest.â€11
But this promise didnâ€™t come trueâ€”or, at least, it didnâ€™t come true at the speed that Zawinski and others in the software world were used to. Zawinski offered various reasons: the project was primarily made up of Netscape employees and thus still appeared to be a Netscape thing; it was too large a project for outsiders to dive into and make small changes to; the code was too â€œcrufty,â€ that is, too complicated, overwritten, and unclean. Perhaps most important, though, the source code was not actually working: â€œWe never distributed the source code to a working web browser, more importantly, to the web browser that people were actually using.â€12
Netscape failed to entice. As Zawinski put it, â€œIf someone were running a web browser, then stopped, added a simple new command to the source, recompiled, and had that same web browser plus their addition, they would be motivated to do this again, and possibly to tackle even larger projects.â€13 For Zawinski, the failure to â€œshipâ€ a working browser was the biggest failure, and he took pains to suggest that this failure was not an indictment of Free Software as such: â€œLet me assure you that whatever problems the Mozilla project is having are not because open source doesnâ€™t work. Open source does work, but it is most definitely not a panacea. If thereâ€™s a cautionary tale here, it is that you canâ€™t take a dying project, sprinkle it with the magic pixie dust of â€˜open source,â€™ and have everything magically work out. Software is hard. The issues arenâ€™t that simple.â€14
Fomenting MovementsÂ Â Â Â Â Â Â Â Â Â Â The period from 1 April 1998, when the Mozilla source code was first released, to 1 April 1999, when Zawinski announced its failure, couldnâ€™t have been a headier, more exciting time for participants in Free Software. Netscapeâ€™s decision to release the source code was a tremendous opportunity for geeks involved in Free Software. It came in the midst of the rollicking dotcom bubble. It also came in the midst of the widespread adoption of [PAGE 108] key Free Software tools: the Linux operating system for servers, the Apache Web server for Web pages, the perl and python scripting languages for building quick Internet applications, and a number of other lower-level tools like Bind (an implementation of the DNS protocol) or sendmail for e-mail.
Perhaps most important, Netscapeâ€™s decision came in a period of fevered and intense self-reflection among people who had been involved in Free Software in some way, stretching back to the mid-1980s. Eric Raymondâ€™s article â€œThe Cathedral and The Bazaar,â€ delivered at the Linux Kongress in 1997 and the Oâ€™Reilly Perl Conference the same year, had started a buzz among Free Software hackers. It was cited by Frank Hecker and Eric Hahn at Netscape as one of the sources for their thinking about the decision to free Mozilla; Raymond and Bruce Perens had both been asked to consult with Netscape on Free Software strategy. In April of the same year Tim Oâ€™Reilly, a publisher of handbooks for Free Software, organized a conference called the Freeware Summit.
The Freeware Summitâ€™s very name indicated some of the concern about definition and direction. Stallman, despite his obvious centrality, but also because of it, was not invited to the Freeware Summit, and the Free Software Foundation was not held up as the core philosophical guide of this event. Rather, according to the press release distributed after the meeting, â€œThe meetingâ€™s purpose was to facilitate a high-level discussion of the successes and challenges facing the developers. While this type of software has often been called â€˜freewareâ€™ or â€˜free softwareâ€™ in the past, the developers agreed that commercial development of the software is part of the picture, and that the terms â€˜open sourceâ€™ or â€˜sourcewareâ€™ best describe the development method they support.â€15
It was at this summit that Raymondâ€™s suggestion of â€œOpen Sourceâ€ as an alternative name was first publicly debated.16 Shortly thereafter, Raymond and Perens created the Open Source Initiative and penned â€œThe Open Source Definition.â€ All of this self-reflection was intended to capitalize on the waves of attention being directed at Free Software in the wake of Netscapeâ€™s announcement.
The motivations for these changes came from a variety of sourcesâ€”ranging from a desire to be included in the dotcom boom to a powerful (ideological) resistance to being ideological. Linus Torvalds loudly proclaimed that the reason to do Free Software was because it was â€œfunâ€; others insisted that it made better busi[PAGE 109]ness sense or that the stability of infrastructures like the Internet depended on a robust ability to improve them from any direction. But none of them questioned how Free Software got done or proposed to change it.
Raymondâ€™s paper â€œThe Cathedral and the Bazaarâ€ quickly became the most widely told story of how Open Source works and why it is important; it emphasizes the centrality of novel forms of coordination over the role of novel copyright licenses or practices of sharing source code. â€œThe Cathedral and the Bazaarâ€ reports Raymondâ€™s experiments with Free Software (the bazaar model) and reflects on the difference between it and methodologies adopted by industry (the cathedral model). The paper does not truck with talk of freedom and has no denunciations of software hoarding Ã la Stallman. Significantly, it also has no discussion of issues of licensing. Being a hacker, however, Raymond did give his paper a â€œrevision-history,â€ which proudly displays revision 1.29, 9 February 1998: â€œChanged â€˜free softwareâ€™ to â€˜open source.â€™â€17
Raymond was determined to reject the philosophy of liberty that Stallman and the Free Software Foundation represented, but not in order to create a political movement of his own. Rather, Raymond (and the others at the Freeware Summit) sought to cash in on the rising tide of the Internet economy by turning the creation of Free Software into something that made more sense to investors, venture capitalists, and the stock-buying public. To Raymond, Stallman and the Free Software Foundation represented not freedom or liberty, but a kind of dogmatic, impossible communism. As Raymond was a committed libertarian, one might expect his core beliefs in the necessity of strong property rights to conflict with the strange communalism of Free Softwareâ€”and, indeed, his rhetoric was focused on pragmatic, business-minded, profit-driven, and market-oriented uses of Free Software. For Raymond, the essentially interesting component of Free Software was not its enhancement of human liberty, but the innovation in software production that it represented (the â€œdevelopment modelâ€). It was clear that Free Software achieved something amazing through a clever inversion of strong property rights, an inversion which could be expected to bring massive revenue in some other form, either through cost-cutting or, Netscape-style, through the stock market.
Raymond wanted the business world and the mainstream industry to recognize Free Softwareâ€™s potential, but he felt that Stallmanâ€™s [PAGE 110] rhetoric was getting in the way. Stallmanâ€™s insistence, for example, on calling corporate intellectual-property protection of software â€œhoardingâ€ was doing more damage than good in terms of Free Softwareâ€™s acceptance among businesses, as a practice, if not exactly a product.
Raymondâ€™s papers channeled the frustration of an entire generation of Free Software hackers who may or may not have shared Stallmanâ€™s dogmatic philosophical stance, but who nonetheless wanted to participate in the creation of Free Software. Raymondâ€™s paper, the Netscape announcement, and the Freeware Summit all played into a palpable anxiety: that in the midst of the single largest creation of paper wealth in U.S. history, those being enriched through Free Software and the Internet were not those who built it, who maintained it, or who got it.
The Internet giveaway was a conflict of propriety: hackers and geeks who had built the software that made it work, under the sign of making it free for all, were seeing that software generate untold wealth for people who had not built it (and furthermore, who had no intention of keeping it free for all). Underlying the creation of wealth was a commitment to a kind of permanent technical freedomâ€”a moral orderâ€”not shared by those who were reaping the most profit. This anxiety regarding the expropriation of work (even if it had been a labor of love) was ramified by Netscapeâ€™s announcement.
All through 1998 and 1999, buzz around Open Source built. Little-known companies such as Red Hat, VA Linux, Cygnus, Slackware, and SuSe, which had been providing Free Software support and services to customers, suddenly entered media and business consciousness. Articles in the mainstream press circulated throughout the spring and summer of 1998, often attempting to make sense of the name change and whether it meant a corresponding change in practice. A front-cover article in Forbes, which featured photos of Stallman, Larry Wall, Brian Behlendorf, and Torvalds (figure 2), was noncommittal, cycling between Free Software, Open Source, and Freeware.18
By early 1999, Oâ€™Reilly Press published Open Sources: Voices from the Open Source Revolution, a hastily written but widely read book. It included a number of articlesâ€”this time including one by Stallmanâ€”that cobbled together the first widely available public history of Free Software, both the practice and the technologies [PAGE 111] involved. Kirk McKusickâ€™s article detailed the history of important technologies like the BSD version of UNIX, while an article by Brian Behlendorf, of Apache, detailed the practical challenges of running Free Software projects. Raymond provided a history of hackers and a self-aggrandizing article about his own importance in creating the movement, while Stallmanâ€™s contribution told his own version of the rise of Free Software.
By December 1999, the buzz had reached a fever pitch. When VA Linux, a legitimate company which actually made something realâ€”computers with Linux installed on themâ€”went public, its sharesâ€™ value gained 700 percent in one day and was the single [PAGE 112] most valuable initial public offering of the era. VA Linux took the unconventional step of allowing contributors to the Linux kernel to buy into the stock before the IPO, thus bringing at least a partial set of these contributors into the mainstream Ponzi scheme of the Internet dotcom economy. Those who managed to sell their stock ended up benefiting from the boom, whether or not their contributions to Free Software truly merited it. In a roundabout way, Raymond, Oâ€™Reilly, Perens, and others behind the name change had achieved recognition for the central role of Free Software in the success of the Internetâ€”and now its true name could be known: Open Source.
Yet nothing much changed in terms of the way things actually got done. Sharing source code, conceiving openness, writing licenses, coordinating projectsâ€”all these continued as before with no significant differences between those flashing the heroic mantle of freedom and those donning the pragmatic tunic of methodology. Now, however, stories proliferated; definitions, distinctions, details, and detractions filled the ether of the Internet, ranging from the philosophical commitments of Free Software to the parables of science as the â€œoriginal open sourceâ€ software. Free Software proponents refined their message concerning rights, while Open Source advocates refined their claims of political agnosticism or nonideological commitments to â€œfun.â€ All these stories served to create movements, to evangelize and advocate and, as Eugen Leitl would say, to â€œcorrupt young mindsâ€ and convert them to the cause. The fact that there are different narratives for identical practices is an advantageous fact: regardless of why people think they are doing what they are doing, they are all nonetheless contributing to the same mysterious thing.
To most onlookers, Free Software and Open Source seem to be overwhelmed with frenzied argument; the flame wars and disputes, online and off, seem to dominate everything. To attend a conference where geeksâ€”especially high-profile geeks like Raymond, Stallman, and Torvaldsâ€”are present, one might suspect that the very detailed practices of Free Software are overseen by the brow-beating, histrionic antics of a few charismatic leaders and that ideological commitments result in divergent, incompatible, and affect-laden [PAGE 113] opposition which must of necessity take specific and incompatible forms. Strangely, this is far from the case: all this sound and fury doesnâ€™t much change what people do, even if it is a requirement of apprenticeship. It truly is all over but for the shouting.
According to most of the scholarly literature, the function of a movement is to narrate the shared goals and to recruit new members. But is this what happens in Free Software or Open Source?19 To begin with, movement is an awkward word; not all participants would define their participation this way. Richard Stallman suggests that Free Software is social movement, while Open Source is a development methodology. Similarly some Open Source proponents see it as a pragmatic methodology and Free Software as a dogmatic philosophy. While there are specific entities like the Free Software Foundation and the Open Source Initiative, they do not comprise all Free Software or Open Source. Free Software and Open Source are neither corporations nor organizations nor consortia (for there are no organizations to consort); they are neither national, subnational, nor international; they are not â€œcollectivesâ€ because no membership is required or assumedâ€”indeed to hear someone assert â€œI belongâ€ to Free Software or Open Source would sound absurd to anyone who does. Neither are they shady bands of hackers, crackers, or thieves meeting in the dead of night, which is to say that they are not an â€œinformalâ€ organization, because there is no formal equivalent to mimic or annul. Nor are they quite a crowd, for a crowd can attract participants who have no idea what the goal of the crowd is; also, crowds are temporary, while movements extend over time. It may be that movement is the best term of the lot, but unlike social movements, whose organization and momentum are fueled by shared causes or broken by ideological dispute, Free Software and Open Source share practices first, and ideologies second. It is this fact that is the strongest confirmation that they are a recursive public, a form of public that is as concerned with the material practical means of becoming public as it is with any given public debate.
The movement, as a practice of argument and discussion, is thus centered around core agreements about the other four kinds of practices. The discussion and argument have a specific function: to tie together divergent practices according to a wide consensus which tries to capture the why of Free Software. Why is it different from normal software development? Why is it necessary? Why [PAGE 114] now? Why do people do it? Why do people use it? Can it be preserved and enhanced? None of these questions address the how: how should source code circulate? How should a license be written? Who should be in charge? All of these â€œhowsâ€ change slowly and experimentally through the careful modulation of the practices, but the â€œwhysâ€ are turbulent and often distracting. Nonetheless, people engaged in Free Softwareâ€”users, developers, supporters, and observersâ€”could hardly remain silent on this point, despite the frequent demand to just â€œshut up and show me the code.â€ â€œFiguring outâ€ Free Software also requires a practice of reflecting on what is central to it and what is outside of it.
The movement, as a practice of discussion and argument, is made up of stories. It is a practice of storytelling: affect- and intellect-laden lore that orients existing participants toward a particular problem, contests other histories, parries attacks from outside, and draws in new recruits.20 This includes proselytism and evangelism (and the usable pasts of protestant reformations, singularities, rebellion and iconoclasm are often salient here), whether for the reform of intellectual-property law or for the adoption of Linux in the trenches of corporate America. It includes both heartfelt allegiance in the name of social justice as well as political agnosticism stripped of all ideology.21 Every time Free Software is introduced to someone, discussed in the media, analyzed in a scholarly work, or installed in a workplace, a story of either Free Software or Open Source is used to explain its purpose, its momentum, and its temporality. At the extremes are the prophets and proselytes themselves: Eric Raymond describes Open Source as an evolutionarily necessary outcome of the natural tendency of human societies toward economies of abundance, while Richard Stallman describes it as a defense of the fundamental freedoms of creativity and speech, using a variety of philosophical theories of liberty, justice, and the defense of freedom.22 Even scholarly analyses must begin with a potted history drawn from the self-narration of geeks who make or advocate free software.23 Indeed, as a methodological aside, one reason it is so easy to track such stories and narratives is because geeks like to tell and, more important, like to archive such storiesâ€”to create Web pages, definitions, encyclopedia entries, dictionaries, and mini-histories and to save every scrap of correspondence, every fight, and every resolution related to their activities. This â€œarchival hubrisâ€ yields a very peculiar and specific kind of fieldsite: one in which a kind [PAGE 115] of â€œas-it-happensâ€ ethnographic observation is possible not only through â€œbeing thereâ€ in the moment but also by being there in the massive, proliferating archives of moments past. Understanding the movement as a changing entity requires constantly glancing back at its future promises and the conditions of their making.
Stories of the movement are also stories of a recursive public. The fact that movement isnâ€™t quite the right word is evidence of a kind of grasping, a figuring out of why these practices make sense to all these geeks, in this place and time; it is a practice that is not so different from my own ethnographic engagement with it. Note that both Free Software and Open Source tell stories of movement(s): they are not divided by a commercial-noncommercial line, even if they are divided by ill-defined and hazy notions of their ultimate goals. The problem of a recursive public (or, in an alternate language, a recursive market) as a social imaginary of moral and technical order is common to both of them as part of their practices. Thus, stories about â€œthe movementâ€ are detailed stories about the technical and moral order that geeks inhabit, and they are bound up with the functions and fates of the Internet. Often these stories are themselves practices of inclusion and exclusion (e.g., â€œthis license is not a Free Software licenseâ€ or â€œthat software is not an open systemâ€); sometimes the stories are normative definitions about how Free Software should look. But they are, always, stories that reveal the shared moral and technical imaginations that make up Free Software as a recursive public.
Before 1998, there was no movement. There was the Free Software Foundation, with its peculiar goals, and a very wide array of other projects, people, software, and ideas. Then, all of a sudden, in the heat of the dotcom boom, Free Software was a movement. Suddenly, it was a problem, a danger, a job, a calling, a dogma, a solution, a philosophy, a liberation, a methodology, a business plan, a success, and an alternative. Suddenly, it was Open Source or Free Software, and it became necessary to choose sides. After 1998, debates about definition exploded; denunciations and manifestos and journalistic hagiography proliferated. Ironically, the creation of two names allowed people to identify one thing, for [PAGE 116] these two names referred to identical practices, licenses, tools, and organizations. Free Software and Open Source shared everything â€œmaterial,â€ but differed vocally and at great length with respect to ideology. Stallman was denounced as a kook, a communist, an idealist, and a dogmatic holding back the successful adoption of Open Source by business; Raymond and users of â€œopen sourceâ€ were charged with selling out the ideals of freedom and autonomy, with the dilution of the principles and the promise of Free Software, as well as with being stooges of capitalist domination. Meanwhile, both groups proceeded to create objectsâ€”principally softwareâ€”using tools that they agreed on, concepts of openness that they agreed on, licenses that they agreed on, and organizational schemes that they agreed on. Yet never was there fiercer debate about the definition of Free Software.
On the one hand, the Free Software Foundation privileges the liberty and creativity of individual geeks, geeks engaged in practices of self-fashioning through the creation of software. It gives precedence to the liberal claim that without freedom of expression, individuals are robbed of their ability to self-determine. On the other hand, Open Source privileges organizations and processes, that is, geeks who are engaged in building businesses, nonprofit organizations, or governmental and public organizations of some form or another. It gives precedence to the pragmatist (or polymathic) view that getting things done requires flexible principles and negotiation, and that the public practice of building and running things should be separate from the private practice of ethical and political beliefs. Both narratives give geeks ways of making sense of a practice that they share in almost all of its details; both narratives give geeks a way to understand how Free Software or Open Source Software is different from the mainstream, proprietary software development that dominates their horizons. The narratives turn the haphazard participation and sharing that existed before 1998 into meaningful, goal-directed practices in the present, turning a class-in-itself into a class-for-itself, to use a terminology for the most part unwelcome among geeks.
If two radically opposed ideologies can support people engaged in identical practices, then it seems obvious that the real space of politics and contestation is at the level of these practices and their emergence. These practices emerge as a response to a reorientation of power and knowledge, a reorientation somewhat impervious to [PAGE 117] conventional narratives of freedom and liberty, or to pragmatic claims of methodological necessity or market-driven innovation. Were these conventional narratives sufficient, the practices would be merely bureaucratic affairs, rather than the radical transformations they are.
Posted by Christopher Kelty on May 8, 2008