Skip to content

03 — The Minicomputer Revolution: DEC, Unix, and the Democratization of Computing

Technical Overview

The minicomputer era (roughly 1959–1980) democratized computing. Where a mainframe cost millions of dollars, required a raised floor, specialized cooling, and a staff of operators, a minicomputer cost tens of thousands of dollars, fit in a small room or even a large cabinet, and could be run by a single engineer or researcher. This economic shift placed computers directly into research labs, universities, and engineering departments — and the people who worked with these machines tended to be curious, inventive, and unsupervised. The most consequential result of this shift was Unix, born on a DEC PDP-7 in 1969, developed on a PDP-11 in 1971–1973, and eventually spread to universities worldwide. This file traces the PDP lineage, the birth of Unix and C, and the ripple effects that shaped every modern operating system.

Prerequisites

  • Understanding of what an operating system is at a basic level
  • Familiarity with concepts of address space, registers, and machine instructions
  • Awareness of the IBM mainframe era and what "batch processing" meant

Digital Equipment Corporation and the PDP Series

DEC's Founding and Philosophy

Ken Olsen and Harlan Anderson founded Digital Equipment Corporation (DEC) in 1957 in Maynard, Massachusetts, with $70,000 in venture capital. Their premise was that IBM's mainframe model was unnecessarily expensive and that interactive computing — a user sitting at a machine and getting immediate responses — was practical and valuable. IBM's sales strategy at the time actively discouraged customers from considering interactive use, since IBM's mainframe business model depended on batch processing economics.

DEC's PDP (Programmed Data Processor) line was named specifically to avoid the word "computer" — Olsen reportedly said "computer" would scare off customers unfamiliar with the term.

PDP-1 (1959): Interactive Computing Arrives

The PDP-1 was the first minicomputer, priced at $120,000 — expensive by consumer standards but a fraction of IBM mainframe costs. It had: - 18-bit word length - 4,096 words of core memory (expandable to 65,536) - 100,000 additions per second - A Type 30 precision CRT display — interactive graphics from the start

The PDP-1 was purchased by MIT, BBN (Bolt Beranek and Newman), and others. Steve Russell at MIT implemented Spacewar! on the PDP-1 in 1962 — the first video game on a computer, running on interactive hardware.

PDP-8 (1965): First Mass-Market Minicomputer

The PDP-8, priced at $18,500 (roughly $175,000 in 2024 dollars), was the turning point. Fifty thousand PDP-8s were eventually sold — an enormous number for the era. It had: - 12-bit word length - 4,096 words of core memory - A simple 8-instruction architecture (AND, TAD, ISZ, DCA, JMS, JMP, IOT, OPR) - An omnibus (single shared bus) connecting all components — an architectural simplification that made it cheap

The PDP-8's low price put computers in high schools, dental offices, newspaper typesetting systems, grocery scanners, and research labs. Many scientists programmed their first computer on a PDP-8. Its single-bus architecture influenced nearly every subsequent small computer.

PDP-11 (1970): The Influential Architecture

The PDP-11 was the most commercially successful and architecturally influential minicomputer ever built. It sold over 600,000 units across 18 models over a 20-year production run. Its architecture is studied in computer architecture courses to this day.

PDP-11 Architecture Highlights:

PDP-11 Register File:
+----+----+----+----+----+----+----+----+
| R0 | R1 | R2 | R3 | R4 | R5 | SP | PC |
+----+----+----+----+----+----+----+----+
  16-bit general purpose registers
  SP = R6 (stack pointer)
  PC = R7 (program counter — a general register!)

Addressing Modes (the key innovation):
Mode 0: Register       (R0)              - value in register
Mode 1: Register def.  (@R0)             - address in register
Mode 2: Autoincrement  (R0)+             - address in R0, then R0 += 2
Mode 3: Autoinc def.   @(R0)+           - indirect autoincrement
Mode 4: Autodecrement  -(R0)            - R0 -= 2, then use as address
Mode 5: Autodec def.   @-(R0)          - indirect autodecrement
Mode 6: Index          X(R0)            - R0 + X-offset
Mode 7: Index def.     @X(R0)          - indirect index

Because PC is R7:
  Mode 2 on R7 = (PC)+ = immediate mode (next word IS the operand)
  Mode 6 on R7 = X(PC) = PC-relative addressing
  Mode 3 on R7 = @(PC)+ = absolute addressing

This orthogonality was elegant and admired widely.

UNIBUS: The PDP-11 used a single unified bus (UNIBUS) for all I/O. Devices were memory-mapped: I/O device registers appeared as memory addresses. To read from a device, you read from a specific address; to write, you wrote to an address. This is the same model used by every modern computer (memory-mapped I/O, or MMIO).

Why the PDP-11 Mattered for Unix:

Ken Thompson had begun writing Unix on a DEC PDP-7. When Thompson and Ritchie wanted to rewrite Unix in a high-level language, they needed a machine that could generate efficient code from a compiled language. The PDP-11's orthogonal addressing modes and clean register architecture made it an excellent compilation target. C was designed to match PDP-11 capabilities closely: - C's *p dereference maps to PDP-11 register deferral mode - p++ and p-- map to PDP-11 autoincrement/autodecrement modes - C struct memory layout maps to PDP-11 word offsets

The C language and the PDP-11 architecture co-evolved, each influencing the other.

Ken Thompson, Dennis Ritchie, and the Birth of Unix

Background at Bell Labs

Bell Labs in Murray Hill, New Jersey, in the late 1960s was arguably the greatest industrial research lab in history. The transistor, information theory, the laser, cellular telephony, Unix, C, Plan 9 — all came from Bell Labs. Researchers had extraordinary freedom: work on anything interesting, publish freely, collaborate across disciplines.

Ken Thompson and Dennis Ritchie were working on the Multics project at Bell Labs when Bell Labs withdrew from the project in 1969. The two researchers found themselves without a computer system they liked working on. Thompson had been playing with a simulation of a space travel game and wanted better hardware.

Unix Origins (1969): Space Travel on a PDP-7

The story of Unix's birth is one of the most famous in computing. Thompson found an unused PDP-7 in a corner of Bell Labs. He spent approximately three weeks writing, one week each on: the kernel, a shell, and an editor. The result, initially called "Unics" (a pun on Multics — one, rather than many), was a simple interactive operating system with a hierarchical filesystem and a shell.

Thompson's key insight, influenced by Multics: everything should be a file. Disk files, devices, inter-process communications — all accessed through the same open/read/write/close interface. This uniformity made programs composable in ways that were not possible on other systems.

Unix on the PDP-11 (1970–1973)

Thompson requested funding for a PDP-11 from Bell Labs management by proposing it would be used for a text processing system (Bell Labs needed a document preparation system). The PDP-11/20 was approved in 1970. Thompson and Ritchie ported Unix to the PDP-11 and extended it significantly.

Key Unix innovations on the PDP-11:

  1. Pipes (1972): Doug McIlroy proposed and Thompson implemented pipes — the | operator connecting the output of one program to the input of another. This was the realization of the Unix philosophy in practice.

  2. The C Language (1972–1973): Dennis Ritchie developed C from Thompson's earlier B language (itself derived from BCPL by Martin Richards). C added a type system, struct definitions, and code generation efficient enough for systems programming. In 1973, Unix was rewritten almost entirely in C — a radical move. Only the lowest-level hardware-dependent code remained in assembly. This made Unix portable: to run on a new machine, you needed only a C compiler and a small assembly stub.

  3. Fork/exec process model: The Unix process creation model — fork() duplicates a process, exec() replaces it with a new program — gave a simple, uniform mechanism for running programs. A shell is just a loop calling fork/exec.

  4. Process isolation: Each process had its own address space. Processes communicated via files, pipes, or signals. This isolation made the system robust.

The Unix Philosophy

The Unix philosophy, articulated by Doug McIlroy:

Write programs that do one thing and do it well.
Write programs to work together.
Write programs to handle text streams, because that is a universal interface.

This philosophy drove Unix tool design: grep, sort, awk, sed, cut, head, tail — each does one thing, each reads from stdin and writes to stdout, each can be chained via pipes. A simple shell pipeline:

cat /var/log/auth.log | grep "Failed password" | awk '{print $11}' | sort | uniq -c | sort -rn | head -20

...analyzes auth log failures using six single-purpose tools. No single tool needed to know about the others.

DEC VAX (1977): 32-Bit and Virtual Memory

The VAX (Virtual Address eXtension) was DEC's follow-on to the PDP-11. It addressed the PDP-11's fundamental limitation: 16-bit address space (64KB, or 256KB with extended addressing). The VAX offered:

  • 32-bit address space: 4GB virtual address space per process — enormous in 1977
  • Hardware virtual memory: TLB and page tables in hardware, demand paging
  • Rich instruction set: 303 opcodes, complex addressing modes, string operations, packed decimal arithmetic
  • VMS operating system: VAX/VMS (Virtual Memory System), designed by Dave Cutler (who later designed Windows NT)
VAX Memory Layout:
+---------------------+  0xFFFFFFFF
|  System space       |  <- shared across all processes (OS kernel)
|  (2GB)              |
+---------------------+  0x80000000
|  Per-process P1     |  <- stack, grows down
|  (1GB)              |
+---------------------+  0x40000000
|  Per-process P0     |  <- code and data, grows up
|  (1GB)              |
+---------------------+  0x00000000

System space is mapped identically in every process's address space.
System calls simply change privilege level -- no address space switch needed.
(This P0/P1/system model influenced VMS architecture significantly.)

The VAX was hugely successful in academia, research, and engineering. It ran VMS (proprietary, commercial) and later Unix variants (Ultrix). Berkeley's BSD Unix (see below) ran on the VAX from 1978 onward.

BSD: Unix Escapes Bell Labs

AT&T Licensing and University Access

AT&T, as a regulated utility under its 1956 consent decree with the DOJ, was prohibited from competing in the computer industry. This meant AT&T could distribute Unix source code to universities for a nominal fee but couldn't commercialize it. This restriction, paradoxically, made Unix's spread through academia possible.

AT&T source licenses were expensive ($20,000 for a commercial source license) but universities could get them for around $150. By the mid-1970s, dozens of universities had Unix source code and were hacking on it, adding features, fixing bugs, and sharing patches.

Bill Joy and BSD (1977–1993)

Bill Joy was a graduate student at UC Berkeley who received Unix source from Thompson. Joy made significant improvements and assembled them into the first Berkeley Software Distribution (1BSD, 1977), which was distributed on a single floppy disk to other Unix users for $50.

BSD timeline:

1BSD (1977): Pascal compiler, editor improvements
  |
2BSD (1978): Joy's csh (C shell), ex/vi editor
  |
3BSD (1979): First VAX version, virtual memory improvements
  |
4BSD (1980): Job control, reliable signals, improved filesystem
  |
4.1BSD (1981): DEC sponsorship, performance improvements
  |
4.2BSD (1983): TCP/IP implementation, fast filesystem (FFS), IPC
  |           [This release made TCP/IP available for free -- critical]
4.3BSD (1986): Continued networking improvements, NFS
  |
4.4BSD (1993): Major rearchitecture, Mach-based VM, cleaner internals
  |           [Released after AT&T lawsuit settlement]
  |
Net/2 (1991): Freely redistributable subset (lawsuit-clouded)
  |
FreeBSD/NetBSD/OpenBSD (1993-1996): Modern BSD derivatives

4.2BSD's TCP/IP stack deserves special emphasis. DARPA funded Berkeley to implement TCP/IP in Unix. The resulting TCP/IP stack, released in 4.2BSD in 1983, was freely available, well-documented, and high-quality. When the internet began to grow, the question "which TCP/IP implementation should I use?" had an obvious answer: the Berkeley one. This free implementation was the technical foundation for the internet's expansion.

Joy's vi and csh

Bill Joy wrote vi (visual editor) in 1976 for 1BSD and csh (C shell) with features like job control, history, and C-like syntax. Joy later co-founded Sun Microsystems and wrote the first Java specification. His contributions to Unix tooling are still in daily use by millions of engineers.

The Broader Minicomputer Market

Beyond DEC, the minicomputer era included:

HP 2100 (1967): Hewlett-Packard's minicomputer, used extensively in scientific instrumentation. Introduced the concept of memory-mapped I/O.

Data General Nova (1969): Designed partly in response to DEC's success, the Nova had a clean 16-bit architecture. The story of its development is told in Tracy Kidder's Pulitzer Prize-winning The Soul of a New Machine (1981). A 32-bit successor, the Eclipse MV/8000, is the subject of that book.

IBM System/3 (1969): IBM's minicomputer targeting small businesses, using a new 96-column punched card format. Competed with DEC in smaller installations.

Prime Computer (1972): Used for CAD/CAM workloads.

Interdata (1973): First computer to run Unix outside Bell Labs (Interdata 8/32, 1977).

Unix Spreads Through Universities

By 1978, Unix was running at dozens of US universities. The source code was readable, elegant (for its time), and instructive. Many computer science programs used Lions' Commentary on Unix as a teaching text — John Lions at the University of New South Wales annotated the entire Unix Version 6 source code in 1977. AT&T prohibited its distribution (it was source code under license), but photocopied bootleg copies circulated widely through the late 1970s and 1980s. An officially licensed edition was finally published in 1996.

The generation of OS researchers who learned from Unix — and from Lions' Commentary — went on to write FreeBSD, Linux, Plan 9, Minix, and countless commercial OS products. The Unix architecture — hierarchical filesystem, process model, pipes, C implementation — became the default mental model for what an operating system should look like.

Technology Evolution Timeline: Minicomputer Era

1959  DEC PDP-1 -- $120,000, interactive, CRT display
  |
1965  DEC PDP-8 -- $18,500, first mass-market minicomputer
  |
1967  HP 2100 -- scientific minicomputer, memory-mapped I/O
  |
1969  Data General Nova -- clean 16-bit design
  |   IBM System/3 -- small business market
  |
1969  Unix on PDP-7 -- Thompson writes OS for Space Travel game
  |
1970  DEC PDP-11/20 -- orthogonal ISA, UNIBUS, Unix target machine
  |
1972  C language -- Ritchie designs; Unix rewritten in C
  |
1973  Unix v4 -- first version mostly in C; portable OS concept proven
  |
1975  Unix v6 -- distributed to universities with source code
  |
1977  Lions' Commentary -- annotated Unix v6 source, teaches a generation
  |   1BSD -- Bill Joy at Berkeley, first BSD distribution
  |
1977  DEC VAX -- 32-bit, virtual memory, 4GB address space
  |
1978  VMS -- Dave Cutler's OS for VAX
  |
1983  4.2BSD -- TCP/IP, fast filesystem, IPC; internet enabled
  |
1985  DEC begins declining (minicomputer market disrupted by PC)
  |
1992  DEC acquired by Compaq (1998); then HP (2002)

Production Relevance

The minicomputer era's lasting contributions:

  1. C and Unix are everywhere. Linux, macOS, Android, iOS all trace directly to Unix concepts developed on minicomputers. C remains one of the top 3 most-used programming languages and is the language of nearly every OS kernel.

  2. Memory-mapped I/O (from HP 2100 and DEC UNIBUS) is how every modern computer accesses device registers — GPU BARs, NVMe controllers, PCIe devices all use MMIO.

  3. The fork/exec model is in every Unix process creation. When you run bash -c "ls", fork and exec are called.

  4. BSD TCP/IP code still runs (heavily modified) in macOS, iOS, FreeBSD, and influenced Linux's networking stack.

  5. The hierarchical filesystem — directories, subdirectories, paths — is universal and was pioneered on Unix.

  6. Pipes and text streams as a universal interface have influenced everything from Unix shell pipelines to Apache Kafka's stream processing model.

Key Figures

Person Contribution
Ken Olsen DEC founder; built minicomputer industry
Gordon Bell DEC chief engineer; designed PDP-11 and VAX architectures
Ken Thompson Unix, B language, UTF-8, Go
Dennis Ritchie C language, Unix co-creator
Doug McIlroy Pipes, Unix philosophy articulation
Bill Joy BSD, vi, csh, TCP/IP BSD implementation, Sun Microsystems co-founder
Dave Cutler VMS, later Windows NT
John Lions Lions' Commentary; taught Unix to a generation

Lessons Learned

  1. Portability is a superpower. Rewriting Unix in C made it portable; porting to a new machine required weeks rather than years. Every subsequent OS that chose a high-level language for most of its code (Linux in C, seL4 in Haskell for specification) benefited from this lesson.

  2. Economic barriers to computing determine who innovates. When computers were multi-million-dollar mainframes, only corporations and governments drove innovation. When minicomputers put machines in universities for $20,000, graduate students began innovating. When PCs put machines on desks for $3,000, hobbyists innovated. Each cost reduction produced an explosion of creativity.

  3. Research lab freedom produces transformative technology. Unix, C, TCP/IP, and countless other technologies came from researchers with broad freedom and no immediate commercial pressure. Bell Labs's structure — AT&T monopoly profits funding unconstrained research — was unique and is not easily replicated.

  4. Simplicity scales. Unix's "everything is a file" simplicity enabled composition and flexibility that complex Multics-style systems couldn't match. The most durable systems tend to have the simplest core abstractions.

  5. Bootleg knowledge spreads ideas. Lions' Commentary was bootlegged for two decades. The ideas in it — how a real OS works — shaped an entire generation of systems programmers regardless of copyright restrictions. Knowledge wants to propagate.

Exercises

  1. Examine the PDP-11 instruction set. Write an assembly routine to reverse a string in memory using autoincrement and autodecrement addressing modes.
  2. Trace through what happens when you type ls | grep foo | wc -l in a Unix shell. How many fork() and exec() calls are made? How many pipes are created?
  3. Compare Unix v6 (available freely online) with Linux 0.01. What's the same? What architectural concepts did Torvalds preserve? What did he change?
  4. Research why 4.2BSD's fast filesystem (FFS) was faster than earlier Unix filesystems. What allocation policy changes made the difference? How does modern ext4 compare to FFS in design?
  5. The VAX had a 32-bit address space but split it into system and user halves. How does this compare to how modern x86-64 Linux splits its 48-bit virtual address space?

References

  • Ritchie, D.M. and Thompson, K. (1974). "The UNIX Time-Sharing System." Communications of the ACM. 17(7).
  • Kernighan, B.W. and Ritchie, D.M. (1978). The C Programming Language. Prentice Hall.
  • Lions, J. (1977). A Commentary on the UNIX Operating System. (Formally published 1996, Peer-to-Peer Communications.)
  • Kidder, T. (1981). The Soul of a New Machine. Little, Brown and Company.
  • McKusick, M.K. et al. (1996). The Design and Implementation of the 4.4BSD Operating System. Addison-Wesley.
  • Severance, C. (2005). "Bill Joy: A Programmer's Programmer." IEEE Computer.
  • Bell, G. et al. (1978). "Computer Engineering: A DEC View of Hardware Systems Design." Digital Press.
  • Salus, P.H. (1994). A Quarter Century of UNIX. Addison-Wesley.