Unix History, Episode 1 of the series. In this episode: the birth, spread and fragmentation of Unix, 1965–1983. Next episode: the Unix Wars.

In the beginning was the code

In the beginning was the code, and the code was with the computer. But the code stayed with the computer. Change the machine — an upgrade, a new model, a different vendor — and you rewrote everything. Everyone agreed this was wasteful.

What was needed was a platform to develop software on: one that could cope with different hardware, that didn’t cost a fortune, and that was — perhaps — maintained collectively by people scattered around the world.

I wonder if such a thing is possible.

The emergence of Unix was one of those rare moments where the answer turned out to be yes. This is the story of how it happened, and of the commercial pressures that were already building while it did.

Multics: trying to boil the ocean

In 1965, a handful of scientists at Bell Labs joined peers from MIT and General Electric on a project with a suitably grand name: the Multiplexed Information and Computing Service, or Multics.

The goal was a general-purpose computing utility — time on a computer, sold like electricity. Computers were extraordinarily expensive, so time-sharing systems had been developed to let many users share one machine efficiently. Over time those systems grew into something more social: a communications tool connecting the people on the timeshare, complete with public user profiles.

General Electric had a business selling time on its machines, and offered the Multics team a GE 645 mainframe. In the early years, before the 645 was in place, development happened on MIT’s CTSS and on a 645 simulator that ran on a GE 635 under GECOS — GE’s own operating system. That detail matters later.

Multics pushed a lot of ideas that were floating around at the time into one product:

  • Arbitrary file names in a hierarchical directory structure — an enormous improvement over the flat, rigid file catalogues of the day, and the model essentially every system still uses.
  • Virtual memory, where secondary storage such as a disk is presented as if it were part of main memory, letting a machine work with more data than its RAM physically allows.

Individually, none of these were unheard of. Assembling them into a shipping commercial product was the hard part — and, looking back, the team was trying to boil the ocean.

Progress turned into a slog: too much money spent on too few people following too vague a plan. Frustrated by the absence of a workable product, Bell Labs formally withdrew from Multics in April 1969. GE left the computer business entirely the following year, selling the division to Honeywell. (Multics itself survived under Honeywell for decades — it just survived without Bell Labs.)

But a few people at the Bell Labs Computing Science Research Center — Ken Thompson, Dennis Ritchie, Rudd Canaday, Doug McIlroy and J. F. Ossanna — were not done thinking about operating systems.

An expensive game about Pluto

Withdrawing from Multics meant losing access to the big GE machine, and with it something Thompson cared about rather a lot: Space Travel.

Space Travel was an ambitious little game. It simulated the motion of the planets of the solar system — and Pluto, which in 1969 still counted — and let the player fly a ship among them and attempt landings. Thompson had written it for Multics on the GE 645 and then ported it to GECOS.

It was fun. It was also mildly ruinous: each session cost roughly $50–75 in internal charges for computer time, which is real money in 1969 dollars.

So when Thompson discovered that a neighbouring department had an older, little-used PDP-7 minicomputer with an excellent display processor, he decided in 1969 to rewrite the game for it.

This turned out to be more ambitious than it sounds. Thompson used none of the existing PDP-7 software, writing everything from scratch — including a floating point arithmetic package and a debugging subsystem. The workflow was gloriously awkward: cross-assemble on the GE machine, punch the result to paper tape, carry the tape across to the PDP-7, load, repeat.

A file system, and then an operating system

With the game running, Thompson turned to something he, Ritchie and Canaday had been kicking around for a while: a new kind of file system.

They had sketched the design for the GE 635 — ideas for keeping files out of each other’s hair — mostly on blackboards. Now thoroughly familiar with the PDP-7, Thompson hacked out a working implementation in very short order.

From there the pieces accumulated: simple utilities for copying, printing, deleting and editing files, and a shell — a program whose job is to run other programs.

Along the way, the concept of the file coalesced into something powerful. A file became an interface through which you perform data operations — read, write — while the file system itself remains supremely uninterested in what the file actually contains. That indifference is the point: it abstracts away the differences between wildly different pieces of hardware. Anyone, on any device, can operate on a file the same way. This became one of Unix’s killer features.

In the late summer of 1969, Thompson’s wife took their small son to California to visit family for three weeks, leaving him with an unusual amount of uninterrupted time. He budgeted roughly a week each to an operating system, a shell, an editor and an assembler. By the end of those three weeks, the thing was self-supporting: it no longer needed the GECOS machine that the whole journey had started on.

Nobody would have called it an operating system at the time. It was simply a convenient platform for developing software.

Well into 1970, Brian Kernighan suggested a name: “Unics”, as what Ritchie later called “a somewhat treacherous pun on Multics”. At some point the spelling shifted to Unix.

The pitch that worked: a text editor

Unix on the PDP-7 was a decent programming environment on an indecent machine. The PDP-7 had been introduced back in 1964, it was obsolete, and — a detail worth repeating — it wasn’t theirs.

So in 1970 the team asked for a DEC PDP-11, then brand new. Thompson, Ritchie and colleagues had been asking for a new computer for a while, and had been turned down every time.

This time it worked, for two reasons. The PDP-11 was comparatively cheap — the order came to about $65,000. And the request now came with an actual business case attached: use the new file system to build a system for creating and editing text.

Unix was rewritten in the PDP-11’s assembly language, and gained a text editor and a typesetting markup language called roff.

In this form it was offered to the Bell Labs Patent Department, which chose it over a commercial alternative — largely because Thompson and Ritchie quickly endowed roff with the ability to produce the line-numbered pages the Patent Office required. Give people the one feature they actually need and you win the evaluation.

What started with three typists in the Patent Department grew into a popular homegrown product across all of Bell Labs, with multiple versions and its own support group.

Why Unix escaped the lab

Unix was only ever meant to be an internal tool. It escaped anyway, and spread through the computing world with a speed nobody planned for. Three reasons stand out.

1. It was born on humble hardware. In that era, the people using a machine were rarely the people buying it, and programmers made do with whatever the budget allowed. A typical Unix machine of the late 1970s — a PDP-11/40, say — ran somewhere in the range of $50,000–150,000 in 1977 dollars depending on memory. Against a graduate student at around $10,000 a year that was a lot of money; against a mainframe starting at half a million, it was a bargain.

2. It was written in C. Unix wasn’t quite the first operating system written in a high-level language — Multics itself was largely written in PL/I — but it was the one that made the idea work. Dennis Ritchie produced C from Thompson’s B, which was in turn heavily influenced by BCPL, the language Martin Richards developed at Cambridge (and first implemented while visiting MIT). Programming in C beat programming in machine assembly by a wide margin, and because the system was written in C, Unix was comparatively easy to port beyond the PDP family — and easy to modify and extend once you got there.

3. It didn’t cost an arm and a leg. AT&T and Bell Labs licensed the Unix source code to universities for a nominal fee — the Version 6 educational licence ran a couple of hundred dollars, against $20,000 for a commercial one. Other software companies of the era guarded source code zealously, and even where customers could read it, they were forbidden to change it. Not so with Unix.

This generosity was not a matter of good hearts. It was a matter of law.

In 1956, AT&T settled a federal antitrust suit — the 1956 AT&T Consent Decree. In exchange for keeping its legal monopoly on the US telephone system, AT&T had to license its existing patents royalty-free to any applicant and subsequent ones on reasonable terms. Crucially, the decree also confined AT&T to the common-carrier communications business, which barred it from the computer industry. An operating system like Unix simply could not be a commercial product for them.

The same antitrust pressure had already shaped the diffusion of another Bell Labs invention: the transistor, which Bell licensed remarkably broadly in 1952 while the government’s suit — the one the decree eventually settled — was pending. Two decades later, the pattern repeated with software.

Any university that asked AT&T for the Unix source got it — or, more accurately, had it thrown at them from the window of a passing truck. Wary of violating the decree, AT&T managers shied away from offering their licensees any support at all.

Which was another accident of good fortune: with no vendor to call, students with more cleverness and time than money had no choice but to work together and implement the features they wanted themselves.

The spread went international quickly. One of the earliest foreign educational licences went to the Netherlands in December 1974, and by September 1976 Unix was licensed at roughly 138 institutions, with machines running it in Australia, the United Kingdom, Belgium and the Netherlands.

Berkeley

In October 1973, Thompson and Ritchie presented the first Unix paper at the Fourth ACM Symposium on Operating Systems Principles. In the audience was UC Berkeley professor Bob Fabry, who obtained a copy.

Unix then ran only on PDP hardware, so several Berkeley departments pooled money for a machine: a PDP-11/45 arrived in January 1974, and a shared PDP-11/70 in the autumn of 1975. Graduate students and professors started working with it — and Ken Thompson himself took a one-year sabbatical at Berkeley, his alma mater, from the autumn of 1975, helping install Version 6 on the new 11/70.

Two students in particular got deeply familiar with that system: Chuck Haley and Bill Joy. They finished and improved a Pascal implementation Thompson had started, letting Unix support the higher-level language properly. Theirs was widely admired, largely for its error handling — Thompson’s original apparently produced error messages that were not, shall we say, illuminating.

Haley and Joy also built utilities, among them a line-oriented text editor called ex, short for EXtended. Ex is the direct ancestor of vi, whose visual mode arrived with the next Berkeley release; vim (“Vi IMproved”) came much later, in 1991, as a separate clone. Some people like it.

Word got around — mostly about how fast that Pascal compiler was and how gracefully it recovered from errors — and people began asking for copies of the Berkeley variant. So early in 1977, Bill Joy assembled what he called the Berkeley Software Distribution, and over the following year sent out around thirty copies; the formal 1BSD release is dated 9 March 1978. Joy later recalled charging $50 for a tape that cost about $10, with the difference going into a slush fund for travel and phone bills. A second version, 2BSD, followed in May 1979 — this one carrying vi and the C shell.

Then in 1978 DEC introduced the VAX-11/780: 32-bit, more memory, more compute. AT&T released its own port, UNIX/32V — which did not support the VAX’s virtual memory. That pinned processing to physical memory and squandered much of the machine.

In a game-changing move, Bill Joy and Turkish graduate student Özalp Babaoğlu added virtual memory support and shipped the result in December 1979 as 3BSD.

With that, Berkeley had established itself as the coordinating gateway for leading-edge Unix.

DARPA and the Internet

BSD’s next leap came courtesy of DARPA.

DARPA’s own computing was a legacy mishmash: software written in different languages for different machines, none of it shareable. In 1979 the agency decided to consolidate onto a single “universal computing environment”, and chose Unix — precisely because it coped so well with heterogeneous hardware.

In April 1980, Fabry secured an 18-month DARPA contract to extend 3BSD. He and Bill Joy set up the Computer Systems Research Group (CSRG) to do the work: a small core of programmers — the “steering committee” — coordinating a global network of volunteer contributors on what became the 4BSD line.

The new system had to support DARPA’s protocols, the Internet ones included. 4.2BSD shipped a full TCP/IP stack, and in doing so did an enormous amount to popularise the Internet as we know it.

4.2BSD, released in August 1983, was a hit: more than a thousand site licences within eighteen months — more than all previous BSD releases combined. Momentum was accelerating.

Sun: from hobby to industry

Shortly before that release, in the late spring of 1982, Bill Joy announced he was leaving CSRG for Sun Microsystems as a co-founder.

His BSD work was earning him tens of thousands of dollars, but he felt the academic atmosphere at Berkeley constrained what the work could become. In his own words, it needed to be a commercial activity.

Sun went on to pioneer and popularise the workstation: a Unix machine with scientific and engineering applications, built around the Motorola 68000 and other off-the-shelf hardware. Sun later developed its own closed-source Unix for that hardware — SunOS, whose 1.0 release in November 1983 was based on 4.2BSD.

One Sun workstation could not match a mainframe, or even a minicomputer. But these machines were built to be networked, and networked they became immensely valuable. Sun reaped the benefit and became one of the fastest-growing companies in Silicon Valley.

Sun rose fastest, but it was far from alone:

  • Mt. Xinu, a small Berkeley software company, sold a commercially licensed BSD for the DEC VAX. The name is “Unix TM” backwards, which pairs nicely with the slogan “We know Unix™ backwards and forwards” — and with the genuinely fun posters and calendars they handed out at events.
  • Santa Cruz Operation (SCO) sold Unix variants for x86 machines.
  • Onyx Systems marketed a Unix variant for Zilog Z8000-based microcomputers — among the first Unix systems on micro hardware.
  • Even Microsoft joined in, licensing Unix and shipping Xenix for 16-bit microcomputers from 1980.
  • And NeXT, Steve Jobs’ workstation startup founded in 1985, built NEXTSTEP on Carnegie Mellon’s Mach kernel — itself developed on top of BSD code — with a BSD userland on top.

The seeds of the fall

Unix pioneered the concepts that helped make software the powerhouse industry it is today. Its early development came almost entirely from people who were interested in it, not people making money from it.

But Bill Joy said the quiet part out loud. As the community grew and the potential became obvious, the work around Unix needed to be a commercial activity.

1983 marks the end of Unix’s awkward growth years. A bounty of wealth lay seemingly ahead for the Unix industry — but who would reap it? The stage is set for the blood and fury of the Unix Wars.

Next episode: The Unix Wars.

Sources and notes

  • Dennis M. Ritchie, The Evolution of the Unix Time-sharing System — the primary account of the PDP-7 years, the $65,000 PDP-11, the Patent Department, roff and Kernighan’s “treacherous pun”.
  • Marshall Kirk McKusick, Twenty Years of Berkeley Unix: From AT&T-Owned to Freely Redistributable (in Open Sources, O’Reilly) — the primary account of the Berkeley story, the DARPA contract and the 4BSD releases.
  • Multicians.org, on Bell Labs’ April 1969 withdrawal and the GE 635/645 simulator arrangement.
  • Watzinger et al., How Antitrust Can Spur Innovation: Bell Labs and the 1956 Consent Decree, on the decree’s patent-licensing terms.

One disputed detail. Several widely repeated accounts — including McKusick’s — place the first Unix paper at Purdue University in November 1973. The conference records are unambiguous, though: the Fourth ACM Symposium on Operating Systems Principles was held at IBM’s Thomas J. Watson Research Center in Yorktown Heights, New York, on 15–17 October 1973. This article follows the conference proceedings.