First Monday, Volume 5, Number 11 ­ 5 November 2000
`
`This paper provides a historical account of how the Linux operating system kernel was developed from
`three different perspectives. Each focuses on different critical factors in its success at the individual, group,
`and community levels. The technical and management decisions of Linus Torvalds the individual were
`critical in laying the groundwork for a collaborative software development project that has lasted almost a
`decade. The contributions of volunteer programmers distributed worldwide enabled the development of an
`operating system on the par with proprietary operating systems. The Linux electronic community was the
`organizing structure that coordinated the efforts of the individual programmers. The paper concludes by
`summarizing the factors important in the successful distributed development of the Linux kernel, and the
`implications for organizationally managed distributed work arrangements.
`
`Contents
`
`Introduction
`What's Linux
`Enabling Conditions: Open Source and Internet
`Linus Torvalds
`Hackers
`Community
`Lessons for Organizations
`
`Introduction
`
`Complex tasks plus a global economy have impelled the creation of many distributed engineering and
`development groups supported by information and communication technologies [1]. Distributed groups
`range in duration from weeks to years; they range in size from fewer than ten people to more than a
`thousand; and they may have members located in two locations or many locations. Distributed engineering
`and development depends upon careful planning, coordination, and supervision. "Careful" does not
`necessarily imply micromanagement. Contributors who are geographically distant from one another
`inevitably operate under some degree of autonomy. The management challenge is to insure that members
`of geographically distributed engineering and development teams stay focused on shared goals, schedules,
`and quality. This challenge grows as the number of employees and sites increases. There have been some
`notable successes in large­scale distributed engineering and development. For example, the Boeing 777
`marshaled 4,500 engineers working on three continents (Committee on Advanced Engineering
`Environments, 1999). But successful large­scale distributed engineering and development projects are
`rare.
`
`That, in part, explains the business and media fascination with Linux. Linux is a PC­based operating system
`(OS) that has been produced through a software development effort consisting of more than 3,000
`developers and countless other contributors distributed over 90 countries on five continents. It is difficult to
`provide a precise estimate of the number of programmers who have contributed to Linux. Published
`estimates range from several hundred to more than 40,000 (Shankland, 1998; Raymond, 1999). In its first
`three and a half years of development (November 1991 to July 1995) more than 15,000 people submitted
`code or comments to the three main Linux related newsgroups and mailing lists. In the next three and a
`half years, thousands continued to contribute code and hundreds of thousands of people joined electronic
`discussions about Linux philosophy, applications, competitors, business models, and so forth. In this paper
`we focus narrowly on people actually writing code for the operating system kernel.
`
`As of December 1998, more than eight million users were running Linux on a wide variety of platforms.
`Linux was estimated to have 17% of server operating systems sales in 1998 and was projected to have a
`compound annual growth rate of 25%, 2.5 times greater than the rest of the market (Shankland, 1998;
`Berinato, 1999). It was widely regarded as being of very high quality and reliability. According to 1998
`internal Microsoft documents assessing the potential threat from Linux, the Linux failure rate was two to
`five times lower than that of commercial versions of Unix (Valloppillil, 1998). In both 1997 and 1998 Linux
`won the Info World Product of the Year award for best operating system; in 1997 it won the InfoWorld Best
`Technical Support award. Such a successful large­scale distributed project would make any organization
`
`Petitioners Great West Casualty Co., BITCO Gen. Ins. Corp., and BITCO Nat'l Ins. Co.
`Ex. 1025, p. 1
`
`

`
`proud and its shareholders happy.
`
`But the real fascination with Linux stems from the fact that it is not an organizational project. No
`architecture group developed the design; no management team approved the plan, budget, and schedule;
`no HR group hired the programmers; no facilities group assigned the office space. Instead, volunteers from
`all over the world contributed code, documentation, and technical support over the Internet just because
`they wanted to. This paper analyzes factors contributing to the Linux kernel story and explores how those
`factors could be brought into play in formal organizations that are managing distributed work [2].
`
`A 1971 book about the Cuban missile crisis, called Essence of Decision, suggested the title and rhetorical
`structure for this paper. That book's author, Graham Allison, observed that no single perspective could
`provide an entirely satisfactory explanation of a complex social phenomenon. Thus, in the book he told the
`story of the missile crisis three times, each time from a different explanatory perspective. In this paper,
`after a brief description of Linux and its enabling conditions, we tell the Linux kernel story three times. (See
`Figure 1 for timeline). First we tell the story from a "great man" perspective, emphasizing the technical and
`management abilities of Linus Torvalds. We then tell the story a second time from a "hacker culture"
`perspective emphasizing what motivates individual hackers to work on this project. We then tell the story a
`third time from an "electronic community" perspective, emphasizing communication forums and role
`differentiation. We conclude with suggestions for how the factors emphasized in these three perspectives
`could pertain to distributed work within organizations.
`
`Figure 1. Timeline of Key Events
`
`What's Linux
`
`An operating system is a computer's central program that oversees resource allocation, program
`execution, and the control of input, output, file management, and peripheral devices. The kernel is the
`central module of the operating system ­ the part of the operating system that loads first, remains in the
`main memory of the system, and controls memory management, process and task management, and disk
`management. Common operating systems in use today are Microsoft Windows and Unix­based systems
`such as Sun SolarisTM and IBM AIXTM.
`
`Linux version 1.0, released in March 1994, offered most features of a typical Unix operating system,
`including multitasking, virtual memory, and TCP/IP networking. It had about 175,000 lines of code. Linux
`version 2.0, released in June, 1996, offered 64­bit processing; symmetric multiprocessing, which allows the
`simultaneous deployment of several chips in a system; and advanced networking capabilities. It had about
`780,000 lines of code. Version 2.1.110, released in July, 1998, had about 1.5 million lines of code: 17% in
`architecture­specific code, 54% in platform­independent drivers, and 29% in core kernel and file systems.
`
`Linux is now much more than an operating system. As the number of people interested in Linux grew, they
`formed user groups to share information and code in face­to­face meetings with local Linux users in
`addition to communicating through the Internet with any Linux user in the world. By July 2000, there were
`more than 400 Linux user groups in 71 countries (Linux User Groups Worldwide,
`http://lugww.counter.li.org). More Linux users meant more interest in applications to run on the operating
`system. People began developing their own applications and making them available on the Web. The
`August 1999 Linux Software Map database lists about 2,500 people who have contributed over 3,500
`applications which range from word processors and mathematical applications to games (Dempsey, Weiss,
`Jones, and Greenberg, 1999). Approximately 300 people have also contributed over 20 megabytes of Linux
`documentation ranging from information sheets to full scale manuals. Over half of the documentation is in
`"How­to" documents, which are mini­tutorials on various tasks related to Linux development,
`implementation, and use (Dougherty, 2000).
`
`Petitioners Great West Casualty Co., BITCO Gen. Ins. Corp., and BITCO Nat'l Ins. Co.
`Ex. 1025, p. 2
`
`

`
`Anyone can download all Linux files from the Internet for free. Thus, anyone who wants to can install a
`Linux OS, applications, and documentation on his/her PC without going through (or paying) a commercial
`organization. For people who don't have the time or skill for a "do­it­yourself" installation, however, several
`commercial firms, such as RedHat, Suse and Caldera, and non­profit organizations such as Debian, also
`sell and support low­cost CD­ROM distribution versions of Linux [3].
`
`Enabling Conditions: Open Source and Internet
`
`Two enabling factors underlie the Linux development as well as that of similar volunteer distributed
`software development projects [4]. The first is the social and legal conventions of "open source," a means
`for sharing software code. The second is the information and communications infrastructure of the Internet.
`
`Open sharing of software code was a common practice in the MIT Artificial Intelligence Laboratory in the
`early 1960s and in similar laboratories at universities such as Stanford and Carnegie Mellon (Levy, 1984).
`Because there were very few computers at that time, people would start a program and leave it available
`for others using the machine after them to admire and improve upon. By the late 1960s, the scarcity of
`computers and the growing number of programmers and users led MIT to develop the Incompatible
`Timesharing System (ITS) for the Digital PDP­10, the large computer in use at the AI Lab. The system had
`no passwords and gave users the ability to browse both the source code [5] of the system itself as well as
`the personal programs and documents created by other users. In essence, the ITS facilitated open sharing
`of software code.
`
`Also in the late 1960s, a small group of people within AT&T's Bell Laboratories, led by Ken Thompson and
`Dennis Ritchie, developed the Unix operating system (Lerner and Tirole, 2000; Salus, 1994). Initially, the
`system was used within AT&T for research purposes. Antitrust regulations of the time restricted AT&T's
`ability to expand its business into areas beyond the telephone industry. After Thompson presented the
`ideas represented in the system at the ACM Symposium on Operating Systems Principles in 1973 however,
`Unix began to spread throughout the research and academic community (Salus, 1994). AT&T licensed the
`Unix operating system to academic institutions for a nominal fee and distributed the system in source, but
`maintained a policy of no official support. Due to the lack of official support, users of the Unix operating
`system began to informally share their bug fixes and improvements with one another. In 1975, many users
`met at the first USENIX meeting, the purpose of which was to bring together various people to share their
`experiences. In the late 1970s, the Unix user­developers developed a new feature, known as the UUCP
`(Unix­to­Unix­Copy), that enabled them to exchange files and data over phone lines (Gaffin and HeitKotter,
`1994). The feature was used to distribute information to the Unix community, and led to the beginning of
`Usenet [6]. In addition to the institutionalization of this open sharing culture, Unix also embodied various
`innovative principles that made the system portable and simple in design.
`
`Advances in computing architecture by the early 1980s saw the demise of the PDP­10 series machines for
`which MIT's ITS had been developed (Stallman, 1998). New machines in the AI Lab were now equipped
`with proprietary operating systems, which, unlike the ITS, came in binary code wrapped with non­
`disclosure agreements that forbade sharing with other people. Richard Stallman, who had used ITS at the
`AI Lab, started the GNU (GNU's Not Unix) project in 1984 to develop a free operating system like ITS to
`support open sharing and collaboration. However, free access to source code for everyone meant that
`commercial software developers could exploit the free software to develop proprietary programs. Stallman
`instituted the Copyleft software license to guarantee sustained easy sharing of code by decreeing that all
`users of the program have the right to use it, copy it, modify it, and distribute their modifications.
`Additionally, Copyleft also explicitly forbids privatization of derivations from software distributed under
`copyleft; derived works must also be distributed under the copyleft license. The canonical copyleft license
`is the GNU General Public License (GPL), which also forbids packaging of proprietary software with GPL­
`licensed software (Free Software Foundation [FSF], 1991). Copyleft codified the open sharing practices of
`the early closely­knit group of programmers; software distributed under a Copyleft license is known as
`open­source software.
`
`Whereas copyleft codified the social and legal norms of open sharing [7], the Internet provided a
`ubiquitous technology infrastructure that made it easy for programmers to communicate and share their
`code. While its predecessor, the Advanced Research Projects Agency Network (ARPANET) was a network of
`research laboratories in academia and industry funded by the U.S. Department of Defense (King, Grinter
`and Pickering, 1997), the Internet broadened the scope of connectivity through widespread emergence of
`commercial Internet service providers. It was no longer only the few privileged members of places like the
`AI Lab at MIT or Bell Labs who could share code and collaborate with others on improving their systems.
`The standard, robust communication system of the Internet made possible the exchange of both messages
`and source code among programmers worldwide. People could learn about a project and participate in
`open discussions about it through Usenet bulletin board discussions and electronic mailing lists. They could
`also download source code from the Internet and upload their modifications to the Net for others to critique
`and improve. The Internet made it possible to go beyond the exchange of source code among people who
`already knew one another. In the early days, the ITS facilitated sharing of code among programmers at
`the AI Lab; the ARPANET enabled collaboration and open sharing of code among programmers in select
`geographically­dispersed research institutions; and finally the Internet made it possible for people
`anywhere to share their code and ideas.
`
`Petitioners Great West Casualty Co., BITCO Gen. Ins. Corp., and BITCO Nat'l Ins. Co.
`Ex. 1025, p. 3
`
`

`
`Linus Torvalds
`
`In October 1991, Linus Torvalds, a computer­science graduate student at the University of Helsinki,
`announced on the Internet that he had written a "free version of a minix­lookalike for AT­386 computers"
`and would make it available to anyone who was interested (See Figure 2 for Torvalds' announcement
`message). Minix was a simplified version of Unix written and maintained largely as a teaching tool by a
`European computer science professor, Andrew Tanenbaum. It was widely used in computer science
`courses, even though its license cost $79.95 and restricted its redistribution. As a result of Minix use by
`computer science students, the professor was bombarded with requests and suggestions for improvement.
`He was reluctant to implement many of them, however, and some students were frustrated with his
`unresponsiveness [8]. Torvalds, a frustrated Minix user, noted in his announcement message that all of the
`code in his operating system was freely­available to be copied by others. He also volunteered to add
`functions written by others, if they were also freely distributable. In the next thirty months, Torvalds
`released 90 additional versions of his OS, culminating on March 14, 1994, with the release of version 1.0.
`
`Date:        Sat, 5 Oct 1991 05:41:06 GMT 
`Reply‐To:    INFO‐MINIX@UDEL.EDU
`Sender:      INFO‐MINIX‐ERRORS@PLAINS.NODAK.EDU
`Comments:    Warning ‐‐ original Sender: tag was info‐minix‐request@UDEL.EDU
`From:        Linus Benedict Torvalds <torvalds@KLAAVA.HELSINKI.FI>
`Subject:     Free minix‐like kernel sources for 386‐AT
`
`Do you pine for the nice days of minix‐1.1, when men were men and wrote their own
`device drivers? Are you without a nice project and just dying to cut your teeth on a
`OS you can try to modify for your needs? Are you finding it frustrating when
`everything works on minix? No more all‐nighters to get a nifty program working? Then
`this post might be just for you :‐)
`
`As I mentioned a month(?) ago, I'm working on a free version of a minix‐lookalike for
`AT‐386 computers. It has finally reached the stage where it's even usable (though may
`not be depending on what you want),and I am willing to put out the sources for wider
`distribution. It is just version 0.02 (+1 (very small) patch already), but I've
`successfully run bash/gcc/gnu‐make/gnu‐sed/compress etc under it.
`
`Sources for this pet project of mine can be found at nic.funet.fi (128.214.6.100) in
`the directory /pub/OS/Linux. The directory also contains some README‐file and a
`couple of binaries to work under linux (bash, update and gcc, what more can you ask
`for :‐). Full kernel source is provided, as no minix code has been used. Library
`sources are only partially free, so that cannot be distributed currently. The system
`is able to compile "as‐is" and has been known to work. Heh. Sources to the binaries
`(bash and gcc) can be found at the same place in /pub/gnu.
`
`ALERT! WARNING! NOTE! These sources still need minix‐386 to be compiled (and gcc‐
`1.40, possibly 1.37.1, haven't tested), and you need minix to set it up if you want
`to run it, so it is not yet a standalone system for those of you without minix. I'm
`working on it. You also need to be something of a hacker to set it up (?), so for
`those hoping for an alternative to minix‐386, please ignore me. It is currently meant
`for hackers interested in operating systems and 386's with access to minix.
`
`The system needs an AT‐compatible harddisk (IDE is fine) and EGA/VGA. If you are
`still interested, please ftp the README/RELNOTES, and/or mail me for additional info.
`
`I can (well, almost) hear you asking yourselves "why?". Hurd will be out in a year
`(or two, or next month, who knows), and I've already got minix. This is a program for
`hackers by a hacker. I've enjouyed doing it, and somebody might enjoy looking at it
`and even modifying it for their own needs. It is still small enough to understand,
`use and modify, and I'm looking forward to any comments you might have.
`
`I'm also interested in hearing from anybody who has written any of the
`utilities/library functions for minix. If your efforts are freely distributable
`(under copyright or even public domain), I'd like to hear from you, so I can add them
`to the system. I'm using Earl Chews estdio right now (thanks for a nice and working
`system Earl), and similar works will be very wellcome. Your (C)'s will of course be
`left intact. Drop me a line if you are willing to let me use your code.
`
`    Linus
`
`PS. to PHIL NELSON! I'm unable to get through to you, and keep getting "forward error
`‐ strawberry unknown domain" or something.
`
`Figure 2. Announcement of Linux v.0.02 (October 1991)
`
`Torvalds certainly did not set out to create a worldwide distributed OS development project. But he
`exhibited both technical and management capabilities and decisions without which Linux would not have
`
`Petitioners Great West Casualty Co., BITCO Gen. Ins. Corp., and BITCO Nat'l Ins. Co.
`Ex. 1025, p. 4
`
`

`
`grown. He makes it easy to build a "great man theory" of the success of Linux. Known as a "damn fine
`programmer" (Raymond, 1999) and an "arch hacker" (Moody, 1997), Torvalds' programming skills are
`widely admired. Even today up to half the code in key parts of the kernel have been written by Linus
`(Yamagata, 1997). And in the early days, if he didn't write the code himself, he edited code by others so
`heavily "as to be totally unrecognizable" by its original authors (Torvalds, 1992, March 8).
`
`Beyond programming skill, Torvalds' chief technical contribution lay in designing a portable, modular
`architecture for the kernel. Torvalds wrote the initial Linux for his own PC, which had an Intel 386
`architecture. By 1993 Linux had been completely rewritten once to run on a Motorola 68K architecture and
`it was about to be rewritten yet again to run on a DEC alpha architecture. The prospect of having to
`maintain a completely separate code base for every new machine architecture was unacceptable to
`Torvalds. Thus he redesigned the Linux kernel architecture to have one common code base that could
`simultaneously support a separate specific tree for any number of different machine architectures
`(Torvalds, 1999b). The architecture greatly improved the Linux kernel portability through establishing
`systematic modularity. A modular system minimized the need for communication between different
`components of the kernel and made it possible to write code in parallel on different portions of the kernel
`(Torvalds, 1999a; 1999b) [9]. Modularity decreased the total need for coordination and meant that
`necessary remaining coordination could be deferred.
`
`In creating a worldwide distributed OS development project, Torvalds' management decisions and skills
`were just as important as his technical ones. Perhaps Torvalds' most important management decision was
`establishing, in 1994, a parallel release structure for Linux (1994, March 15). Even­numbered releases
`were reserved for relatively stable systems and focused only on fixing bugs; odd­numbered releases were
`the development versions on which people could experiment with new features. Once an odd­numbered
`release series incorporated sufficient new features and became sufficiently stable through bug fixes and
`patches, it would be renamed and released as the next higher even­numbered release series and the
`process would begin again [10]. The parallel release structure allowed Torvalds to simultaneously please
`two audiences who are often in conflict with one another. Users who rely upon a Linux OS to support their
`production computing want a stable, reliable system in which new releases introduce only well­tested new
`functionality, no new bugs, and no backward compatibility problems. Developers, by contrast, want to try
`out new ideas and get feedback on them as rapidly as possible. The parallel structure offered both relative
`stability and certainty to users and rapid development and testing to programmers. Table 1, which displays
`the release history of Linux, illustrates the disparate release rate between the two release trees.
`
`Table 1. Linux Release History [11]
`
`Despite his position of importance there is little that is imperious or dictatorial in Torvalds' communication
`style. Initially he was (appropriately) quite deprecatory about his project, "just a hobby, won't be big and
`professional like gnu" (Torvalds, 1991, August 25). He never orders anyone to do anything and even his
`suggestions are mild­mannered. Typical suggestions are of the form: "hint, hint, Linus wants to get out of
`doing it himself;^)" (Torvalds, 1995, June 29) or "my personal priority is not that kind of behaviour, so it
`would be up to somebody else to implement this.. (hint hint)" (Torvalds, 1996, April 16). Yet, there is no
`confusion about who has decision authority in this project. Torvalds manages and announces all releases ­
`all 569 of them to date. He acts as a filter on all patches and new features ­ rejecting, accepting, or
`revising as he chooses. He can single­handedly decide to redo something completely if he wishes. In the
`early days he personally reviewed every contribution and communicated via personal e­mail with every
`contributor. As Torvalds says, "[There is] one person who everybody agrees is in charge (me)" (Yamagata,
`1997).
`
`Hackers
`
`Petitioners Great West Casualty Co., BITCO Gen. Ins. Corp., and BITCO Nat'l Ins. Co.
`Ex. 1025, p. 5
`
`

`
`In October 1991, Linus Torvalds announced on the Internet that he had written a "program for hackers by
`a hacker" (See Figure 2 again for the October 1991 announcement message). Hackers are people who
`enjoy "exploring the details of programmable systems and how to stretch their capabilities," and appreciate
`programming over theorizing (Jargon Dictionary, 2000). Torvalds encouraged people to look at his
`program and modify it for their own needs and to send him their code to add to the system. People who
`had been frustrated with the restricted features of Minix accepted Torvalds' invitation. By the end of the
`month, ten people had the system working on their machines (Torvalds, 1991, October 31). Some offered
`to work on different features of the program and began sending him contributions.
`
`Within two months of Torvalds' October 1991 announcement, about thirty people had contributed close to
`200 reports of errors and problems in running Linux, contributions of utilities to run under Linux, and
`drivers and features to add to Linux. When Torvalds released version 0.11 in December 1991, he credited
`contributions by three people in addition to himself (Torvalds, 1991, December 3). In version 0.13,
`released in February 1992, the majority of patches were written by people other than Torvalds. By July
`1995, more than 15,000 people from 90 countries on five continents had contributed comments, bug
`reports, patches, and features [12]. Why did these people accept Torvalds' invitation to test and modify
`Linux?
`
`One possible motivation for working on the Linux project is that hackers by nature enjoy solving interesting
`technical problems and building new programs (Raymond, 1999, p. 233). Torvalds labeled himself a hacker
`and said that he "enjoyed" developing the operating system in his October 1991 message and suggested
`that "somebody else might enjoy looking at it" (See Figure 2 again). To hackers, who are generally
`interested in "sexy" and "technically sweet" problems (Raymond, 1999, p. 72), an operating system
`represents an alluring challenge. Programming an operating system means a hacker has tamed the
`computer hardware and stretched its functionality. In his October announcement, Torvalds appealed to the
`hacker's need for such challenges when he asked if they were "without a nice project and just dying to cut
`[their] teeth on a OS."
`
`People also wrote code to solve particular personal problems. Torvalds himself developed Linux so that he
`could run a Unix­like operating system on his own PC. In his October announcement Torvalds noted that
`Linux was available for anybody "to modify for [their] needs." When people accepted Torvalds' invitation to
`try the first Linux release, they wrote their own device drivers to support their choice of hardware and
`peripherals. For instance, a German programmer using Linux developed the German keyboard driver that
`was included in the December 1991 release (Thiel, 1991). To this day, people work on areas that they
`know and care about (Raymond 1999; p. 32). No one tells anyone what to work on [13].
`
`However, whereas intrinsic pleasure and personal problem solving may be enough to motivate people to
`write Linux code for their own use, they do not satisfactorily explain why people contributed that code to a
`larger effort. People might contribute because they expect others will do so in return (Kollock, 1999;
`Raymond, 1999). When Torvalds announced his free operating system, he was also "interested in hearing
`from anybody who has written any of the utilities/library functions for minix" to add to his system. People
`posted bug reports hoping others would fix them; people contributed patches expecting that others would
`post patches to other problems with the system. The Gnu GPL ensured both that their contributions would
`be made accessible to everyone else and that everyone else's contributions would be accessible to them.
`This ensured the establishment of a stable 'generalized exchange system' (Kollock, 1999) in which people
`could expect returns to their contributions.
`
`This generalized exchange system, however, could have broken down if everyone waited for someone else
`to contribute (Kollock, 1998). In the Linux case, programmers also contributed because they wanted to be
`known for writing good code (Raymond, 1999). Ackerman and Palen (1996) offered a similar explanation
`when they suggested that MIT undergraduates contribute to a voluntary online help system to develop their
`reputation as "clueful". An economic explanation suggested that accrued reputation has a positive impact
`on the programmers' careers (Lerner and Tirole, 2000). However, this account fails to explain the
`motivation of early hackers of the Linux operating system. The potential career opportunities to be gained
`from building up a reputation as a skilled programmer in the Linux operating system project were not
`present from the start.
`
`Good code was acknowledged in a variety of ways. The separate management of production and
`development kernels meant that people contributing good code received rapid positive feedback as their
`contributions were incorporated in the development kernel in a short period of time. Some programmers
`left personal signatures within the source code so that others looking at the source code could recognize
`their work. The GPL ensured that freely contributed code would not be exploited by others. Torvalds also
`frequently acknowledged the contributions of others. In his original October 1991 announcement message,
`Torvalds credited another programmer for code he had used in the first release ("thanks for a nice and
`working system Earl <Chews>"). In his January 1992 release, he acknowledged the significant
`contributions of three other programmers (Torvalds, 1992, January 9). As the number of contributors grew,
`it became impossible for Torvalds to acknowledge all those who had contributed code with each release.
`With the official release of version 1.0 in 1994, Torvalds acknowledged and thanked more than 80 people
`by name (Torvalds, 1994, March 14). Version 1.0 was also the first version to include a 'credits' file that
`listed the various contributors and their role in developing and maintaining the Linux kernel. The
`programmers themselves were responsible for requesting to be added to the credits file if they considered
`themselves to be "worth mentioning" (Torvalds, 1993, December 21). In the early days, Torvalds credited
`programmers personally. The credits file marked a transition to a process in which programmers could
`credit themselves according to a shared understanding of what constituted creditable contributions.
`
`Petitioners Great West Casualty Co., BITCO Gen. Ins. Corp., and BITCO Nat'l Ins. Co.
`Ex. 1025, p. 6
`
`

`
`However, whereas reputation as a skilled programmer was the most important motivation for contributing
`code, it was not the only way of gaining reputation. Credit could also come from significant contributions of
`documentation and other information useful to developers and users of Linux. In fact, in an early message
`Torvalds acknowledged a contributor for compiling the Linux information sheet (Torvalds, 1992, January 9),
`and stated that one did not "need to be a *kernel* developer to be on the credits list" (Torvalds, 1993,
`December 21).
`
`Community
`
`In July and August, 1991, Linus Torvalds posted messages to a Usenet group to which he belonged asking
`the group for help on a project. He asked where to find a particular set of operating system standards,
`what things group members liked and disliked about minix, and what features they would want in a free
`minix look alike. The August message received five replies within two days of its posting (See Figure 3 for
`the August message). Torvalds did not create his original project in social isolation. He was a member of an
`on­going active community of programmers ­ electronically organized in a Usenet group, comp.os.minix,
`with thousands of members [14]. It was to this group that Torvalds turned for advice, suggestions, and
`code. It was to this group that Torvalds announced his initial project. It was from this group that early Linux
`contributors were drawn. And it was out of this group that the first Linux group was created.
`
`Writing code is a solitary activity and, as noted in the previous section, some people may have written
`Linux code just for the joy of it or to solve a personal problem with no thought of contributing to a larger
`ende