4.3 Multics, Unix and AT&T

I treat the development of Unix in a separate section because of two reasons. The Unix type of operation systems is the heritage to the most important FLOSS operating systems, the different BSD variants of Unix and Linux. Second the practice of source sharing have been common in the Unix community thought it’s history. There are important lessons to learn from this history.

In 1964 researchers at MIT along with colleagues at General Electrics (GE) and Bell Labs, began a joint project to build a second generation time-sharing system. It was designed for high availability, seeking to provide a computing utility on continuous basis, like the telephone or electricity systems. In this way you could plug a dump terminal into a socket in the wall and you would be connected to a Multics driven mainframe.

The Multics project was too ambitious for the state of technology at the time. It didn’t help that the tree collaborators had different goals for the system and that there was an awkward structure of decision making. The project decided to write Multics in a not yet implemented language, PL/I. PL/I proved difficult to implement. The project didn’t deliver on time and was under-performing when it did. Multics never became a commercial success, but it contained many new ideas in computer science. Among this ideas were dynamic linking and a single level of storage (discarding the clear distinction between process memory and files).

Bell Labs withdrew form the project in 1969. Several researchers at Bell Labs felt, however, that they had learned important lessons from the Multics project. Lessons that could be used to build a new and simpler operating system. In the summer of 1969 Ken Thompson, a researcher at Bell Labs, stayed at home while his wife took their new born baby to California to visit the grandparents. Thompson had access to a quite old and not very powerful computer, a PDP-7. Using the four quiet weeks he had available he allocated one week each to writing a kernel, a shell, an editor and an assembler. The system Thompson had made he called UNICS, a intentional play on Multics. Unics was later renamed Unix.

To build an operating system alone in just one month Thompson had to put behind big system mentality, and build small neat tings. The doctrine of smallness and simplicity is at the core of the Unix philosophy. Later the important innovation of the pipe would help in modularising Unix. A pipe is a mechanism for inter process communication (IPC) allowing, among other things, the output of one program to be given to the input of an other program. This made it easier to make small specialised programs. A program producing an unordered list of names could be piped into a program for soring thereby producing an ordered list of name.

  host -l ifi.uio.no | sort

There was increasing pressure to document Unix as it turned out that Unix would become more than an experimental toy. Dennis Richie, an other important Unix developer at Bell Labs, and Thompson turned the necessity to document into a virtue, because clean and well designed programs are easy to document, while documenting an ugly piece of code makes it clear just how ugly it is. The first edition of the programmers manual established the Unix tradition of listing each subprogram with an “owner”. The “owner” was responsible for writing and maintaining a subprogram.

Until 1973 Unix had only been deployed inside AT&T. This situation changed drastically after Thompson and Richie presented a paper on Unix to several hundred developers gathered at the ACM Symposium on Operating Systems in October 1973. After the paper was published in 1974 a flood of requests for copies flooded in at Bell Labs.

For a few hundred dollars license fee AT&T supplied the source code of Unix. The interest in Unix might have seemed like a business opportunity to AT&T but for a consent decree made in 1956. In 1956 AT&T entered a consent decree on an antitrust allegation stating that AT&T could not engage in manufacturing or sale outside of telephone, telegraph and “common carrier communications” services. The AT&T lawyers interpreted this to essentially mean “no business other than phones and telegrams”. The AT&T wanted a clean statement that they were not seeking software as a business. Because a decree provision required Bell Labs to license patients at nominal fee, Unix was licensed at nominal fee. The early Unix licenses were minimal. The software came “as is” without royalties to AT&T, but also without support and bug fixes. This encouraged sharing of support and bug fixes among Unix users.

In 1973 the important decision of rewriting Unix in the new high level programming language C was made. The initial version of C was developed by Dennis Richie between 1969 and 1973. This was important because this made Unix much more portable. Most earlier operating systems were made in assembler, and had to be rewritten for every computer architecture. The portability of Unix have made it possible to port it to many different computer architectures.

Unix made inroads into many university computer science departments. Because the source code was available Unix was treated as a research and learning tool. This created a good environment for experimentation in software development, creating many useful applications which were freely shared. In 1976 Unix to Unix Copy Program (UUCP) was made. UUCP became a “poor man’s” networking for Unix. You could exchange files point-to-point over ordinary telephone lines.

UC Berkley became an important node in the Unix community in the seventies. From the time of the first Unix installation done at Berkley there was a tone of cooperation between Bell Labs and Berkley. Thompson took a year sabbatical from Bell Labs to work at Berkley from the autumn of 1975. A number of popular Unix tools were developed at Berkley, most notably a pascal compiler and the ex line editor. In 1977 this tools were put together by Bill Joy into a package called the Berkley Software Distribution (BSD).

The first releases of BSD up until 2.9BSD for the PDP-11 architecture and 3BSD for the VAX architecture, were not complete operating systems, but rater a package of Unix tools. After that time the BSD releases included the kernel, C library and utilities making it a full operating system. A lot of code in the kernel, C library and utilities included source which required a AT&T license to use. This was no problem because you could get this license at nominal fee. This changed in 1983 when AT&T was forced to break up the company because of legal reasons. Now AT&T was not restricted from entering the software industry and the price of the Unix source license exploded to cost in the $100,000 range in 1988. Before the mood shift in, and breakup of AT&T, AT&T had happily shared source code in exchange for contribution and bug fixes.

In 1989 Berkley released a package without any AT&T code containing the increasingly popular TCP/IP stack for BSD and a number of other tools. This package where called Networking Release 1 (Net/1). Net/1 became immensely popular and inspired Keith Bostic to bring up the idea of reimplementing as much of the utilities contaminated with AT&T code as possible. This was a huge undertaking so Bostic consciously designed a public, voluntary, Internet based development effort to write the C library and the hundreds of utilities needed by BSD. Kirk McKusick and Michael Karels had agreed with Bostic that if he wrote the utilities, they would work on the kernel, partly believing that Bostic would never be able to do it. This proved wrong so they started to work on the kernel. This complicated job was more or less finished by spring 1991, only missing 6 files still containing AT&T code. This files were deemed to hard to rewrite, so this almost complete operating system was released under the name of Networking Release 2 (Net/2).

William (Bill) Jolitz ported Net/2 to the Intel x86 architecture and wrote the six remaining files betting that x86 would evolve quicker than competing architectures. This release, dubbed 386/BSD, was released with a license allowing free redistribution and modification as long as the credit file was kept intact (a BSD style license). People started to contribute to 386/BSD about the same time as the graduate student Linus Torvalds was trying to find a Unix-style operating system for his x86 PC. Having no World Wide Web (WWW) he did not find 386/BSD, so he started on making his own kernel which became Linux (see section 4.6). 386/BSD and 4.4BSD-light have evolved into FreeBSD, NetBSD and OpenBSD (see figure 4.1). The proprietary versions of Unix went along a different path, with multiple incompatible competing versions, which I will not cover here.


Figure 4.1: Evolution of Unix