Bill Joy: The Other Sun Founder

Zusammenfassung

Bill Joy rewrote the TCP/IP stack that made the internet scale. He wrote vi, the text editor that millions of developers still use every day. He was the primary technical force behind BSD Unix, which became the foundation of free Unix distributions and, through Apple’s Darwin, of macOS and iOS. He co-founded Sun Microsystems and shaped the software strategy of the company for two decades. Then, in 2000, he published an essay arguing that the technologies he had spent his career building might destroy human civilization — and that engineers had a moral responsibility they were not prepared to accept. He remains, forty years after his most important technical contributions, both more influential and less famous than almost anyone in the history of computing.

Michigan and Berkeley

William Nelson Joy was born on November 8, 1954, in Farmington Hills, Michigan. His father was a school district administrator. He was mathematically gifted from early childhood — testing at college-entrance levels on standardized tests while still in middle school — and this aptitude combined with restlessness. School moved too slowly. He enrolled at the University of Michigan in electrical engineering, transferred to computer science as the more interesting discipline, and graduated in 1975.

He arrived at UC Berkeley’s graduate computer science program in the fall of 1975. Berkeley was running PDP-11 minicomputers under Unix time-sharing — machines that many researchers and graduate students shared, with each user allocated a slice of the machine’s time. (The more powerful VAX-11/780, on which Joy’s later BSD work would run, did not arrive until the end of the 1970s.) Joy began using it intensively, then obsessively. By his own account, he was spending more time on the computer than the department had intended for any single user, working through the night on problems that interested him, often losing track of whether it was day or night outside.

Berkeley’s computer science department was engaged in one of the most consequential software projects in the history of computing. AT&T had developed Unix at Bell Labs in the late 1960s — a clean, portable operating system that ran on a wide variety of hardware. Because of AT&T’s status as a regulated monopoly, it was prohibited from commercializing Unix; it distributed the source code to universities for a nominal fee. Berkeley’s Computer Systems Research Group (CSRG) had been extending and enhancing Unix since the early 1970s, producing what they called the Berkeley Software Distribution.

Joy joined the CSRG and became central to it. He ported tools to the Berkeley systems, debugged the kernel, and reorganized the distribution. His contributions were not primarily theoretical; they were implementation work — taking things that didn’t quite work and making them work, taking things that worked but were slow and making them fast.

BSD Unix and the TCP/IP Stack

BSD became the most important variant of Unix outside AT&T. BSD introduced features — virtual memory, the fast file system, long file names, job control — that AT&T’s Unix did not have. Universities running BSD got a better Unix than the one AT&T shipped. By the early 1980s, BSD was the dominant Unix at American research universities.

The most consequential single contribution Joy made to BSD was the TCP/IP implementation in 4.2BSD, shipped in 1983. In 1980, DARPA had commissioned Berkeley to implement the TCP/IP protocols — designed by Vint Cerf and Bob Kahn — in Unix. The internet needed an implementation that other Unix systems could adopt; a prototype implementation existed, but it was not production quality. Joy led the engineering team that built the production implementation.

The 4.2BSD TCP/IP stack became the reference implementation of TCP/IP for the internet. It was not the only implementation, but it was the one that most workstation and server vendors adopted when they needed to add networking to their Unix systems. DEC, HP, IBM, SGI, and eventually Sun all shipped BSD-derived TCP/IP stacks. When the internet expanded from a research network to commercial infrastructure in the late 1980s and early 1990s, the code running on the vast majority of connected machines — the code that actually implemented the internet protocols for real systems — was substantially what Joy and his team had written at Berkeley.

Info

The distinction between protocol design and protocol implementation is often overlooked in histories of the internet. Cerf and Kahn designed TCP/IP as a specification — they described what the protocol should do and how it should work. Joy’s team wrote the code that actually did it, in a form that could be compiled and run on the machines that were being deployed. The specification was necessary but not sufficient. The code was what actually connected computers. When people say the internet is built on TCP/IP, they mean, in large part, that it is built on the code Joy’s team wrote.

vi: The Editor That Would Not Die

Joy wrote the vi text editor in 1976, during his first year at Berkeley. The immediate problem was practical: the standard Unix text editor, ed, was a line editor — it operated on one line at a time, displaying only the line currently being edited. On video terminals capable of displaying twenty-four lines of text simultaneously, a line editor was a significant usability limitation. Existing editors for full-screen terminals existed but were not well-integrated with Unix.

Joy built vi (visual editor) as an extension to another Berkeley editor called ex. The design choices he made reflected the constraints of the hardware: on slow serial connections, sending every character immediately to the terminal was expensive. Vi’s modal design — separate modes for inserting text and for issuing commands — allowed complex operations to be performed with single keystrokes, minimizing the data sent to the terminal. Navigation with h, j, k, l (left, down, up, right) rather than arrow keys (which didn’t yet have standard escape sequences) was a practical choice made necessary by the terminal landscape of 1976.

Vi has been described as counterintuitive by generations of users who encounter it without preparation. Its two-mode design — pressing ‘i’ to begin inserting text, pressing Escape to return to command mode — violates the assumption, universal in subsequent word processors and text editors, that text you type always appears immediately as text. Learning vi requires learning that typing characters is not always typing; that the same key that inserts the letter ‘w’ also, in command mode, moves the cursor forward one word.

For people who have learned vi, the interface is faster than any alternative for many editing tasks. The commands compose: ‘d3w’ deletes three words. ‘ci"’ changes the content inside quotation marks. ‘gg=G’ reformats the entire file. Decades of users have found that after the initial disorientation, vi’s economy of expression makes editing feel efficient in a way that mouse-driven interfaces do not.

Vi or its derivative Vim (vi improved) is installed by default on virtually every Unix and Linux system in existence, including macOS. It runs on every cloud server. It is used daily by millions of developers who were born decades after Joy wrote the first version. Its survival is not nostalgia but utility: it is simply the best tool for certain classes of editing, and it is always present.

Sun Microsystems and Joy’s Law

Joy co-founded Sun Microsystems in 1982 with Andy Bechtolsheim, Scott McNealy, and Vinod Khosla. His role was software: he owned Sun’s operating system strategy and the company’s relationship with the Unix and academic computing communities. Where Bechtolsheim built hardware and McNealy managed the business, Joy shaped what Sun’s software would be and what technical community it would speak to.

SunOS, the operating system Sun shipped with its workstations, was based on BSD Unix — the system Joy had helped build at Berkeley. This was not accidental; Joy brought BSD’s culture and community with him. When Sun needed features, it often drew from the pool of researchers and engineers who had been working on BSD, and from the broader Unix research community. Sun’s technical credibility with the research community that was its primary early market was substantially built on Joy’s reputation.

Sun’s software strategy evolved over Joy’s tenure. The company eventually migrated from SunOS (BSD-based) to Solaris (based on AT&T’s System V Unix) in the early 1990s, a politically and technically contentious transition that reflected the consolidation of the Unix market. Joy was involved in Sun’s Java strategy in the mid-1990s: when James Gosling’s team at Sun developed the Java programming language, Joy participated in its design and was among its most prominent internal advocates. He had ideas about language design — about what a language for distributed networked applications should look like — and Java incorporated some of them.

He articulated what became known as Joy’s Law: “No matter who you are, most of the smartest people work for someone else.” The observation — that the ratio of talented people outside any given organization to those inside it was always overwhelmingly in the outside’s favor — was an argument for open source development, for industry standards, and for the kind of collaborative research culture that had produced BSD and the internet. A company that could only use the talent it employed was at a permanent disadvantage to a community that could use everyone’s. The law was both an explanation of how BSD had outcompeted AT&T’s proprietary Unix and a prescription for how Sun should build its software.

“Why the Future Doesn’t Need Us”

Joy’s most widely read piece of writing was not a technical paper or a product announcement. It was an essay published in Wired magazine in April 2000, titled “Why the Future Doesn’t Need Us.” At the time, Joy was still a Sun employee and one of the most technically respected people in the computer industry. The essay was a warning from inside.

Joy had been having conversations with futurists and technologists — Ray Kurzweil most prominently — about the long-term trajectory of three technologies: robotics, genetic engineering, and nanotechnology. The conversation had unsettled him. He began reading widely: Eric Drexler’s work on molecular nanotechnology, the technical literature on autonomous systems, discussions of gain-of-function research in biology. The picture that assembled itself was alarming in a way that felt different from previous discussions of technology risk.

Previous dangerous technologies — nuclear weapons, chemical and biological agents — shared a common property: they required massive resources to produce. A nuclear weapon needed rare fissile materials, industrial-scale processing, and nation-state-level engineering capacity. The constraint on proliferation was economic and logistical. Dangerous knowledge alone was insufficient; the means of production were controlled.

The technologies Joy was examining did not have this constraint, or would not have it at maturity. A sufficiently advanced robot could, in principle, replicate itself using available materials. A sufficiently precise genetic modification could spread through a population. A sufficiently capable nanotechnology could self-replicate from environmental feedstocks. The dangerous feature was not the destructive capability itself but the self-replication — the ability to multiply without requiring continued human effort or extraordinary industrial resources.

Joy argued that the convergence of artificial intelligence (which would make robots and genetic design tools more capable) with robotics and biotechnology and nanotechnology created a category of risk that was qualitatively different from nuclear weapons. And he made an argument that was unusual coming from inside the technology industry: that the engineering community should consider relinquishment — a deliberate decision not to build certain things — rather than simply regulation after the fact. Not “build it and govern it” but “decide, before building, whether it should be built at all.”

The essay attracted enormous attention. It was the most widely discussed piece of technology writing of the dot-com era — more widely read, and more seriously engaged with, than the business and investment commentary that dominated the period. It also attracted significant criticism. Technologists who disagreed with Joy’s conclusions argued that relinquishment was not achievable in a world of multiple states with competing interests; if the United States declined to develop a technology, China or Russia would not. The argument for governance after building, rather than relinquishment before, was that governance was at least achievable.

After Sun and the Long Concern

Joy left Sun in 2003. His departure was quiet; he gave no dramatic announcement and offered no public account of why. He had been at Sun for twenty-one years. The company was a different place from the one he had helped found — larger, more bureaucratic, under competitive pressure from Microsoft and, increasingly, from open source Linux. Joy joined Kleiner Perkins Caufield & Byers as a venture partner, focusing on investments in clean energy and environmental technology. He made public statements about artificial intelligence risk in subsequent years, warning that the development of AI systems more capable than humans posed existential risks — a position that placed him, by the 2010s, in a community of concern that included many of the technologists who had read his 2000 essay.

His relative obscurity compared to other Sun founders is one of computing history’s persistent anomalies. McNealy ran the company and became its face. Khosla became a prominent venture capitalist and public figure in clean energy and technology. Bechtolsheim founded multiple subsequent companies and the Google check became a famous anecdote. Joy did the foundational technical work — BSD, TCP/IP, vi, Sun’s operating system strategy — and became, by most public measures, the least visible of the four.

The technical legacy does not require visibility to be real. Every macOS or iOS device runs Darwin, which descends from BSD. Every Linux system can run vi or Vim. Every server connected to the internet runs a TCP/IP stack descended from the one Joy’s team wrote. The work is present in billions of devices, running right now, unattributed.

The Unix story and BSD’s relationship to it are covered in The Unix Story; Sun Microsystems’ hardware context in Andy Bechtolsheim and Sun.