The Beginning of BSD Unix History

On March 9, 1978, roughly 30 magnetic tapes left Berkeley for university computer rooms around the country, each one holding a Pascal compiler and an editor stacked on top of Version 6 Unix. No launch event, no boxed product, no version number silkscreened on anything. A graduate student with a tape drive and a list of names did the shipping.

Three People, Three Jobs

Episode 13 belongs to a BSD arc. Episode 11, from September 30, 2026, follows Ken Thompson’s arrival at Berkeley with Unix source in hand; episode 12, from October 11, 2026, traces ed through em and ex to vi. Part three starts where those stop.

Babaoglu, Joy, and a VAX Without Reference Bits

Three names carry the narrative, each with a different job. Bill Joy handles distribution and debugging. Chuck Haley comes out of the earlier Pascal and editor work. Ozalp Babaoglu arrives for the virtual memory implementation that made 3BSD possible.

The setting constrained all of it. Unix reached Berkeley in 1974 at the request of computer science professor Bob Fabry, and the machine running it was a PDP-11 shared with the mathematics and statistics departments, which used RSTS/E. Unix was available on that hardware eight hours a day, day shift or night shift, never both. A lab with eight hours of computer time does not build an operating system on schedule. It builds one in the gaps.

From 1BSD to 3BSD: Three Releases, Three Different Things

Ken Thompson took a sabbatical from Bell Labs in 1975 and became a visiting professor at Berkeley, where he helped install Version 6 Unix. Haley and Joy then improved his Pascal implementation and built an enhanced ex editor. Be precise about the origin: the first Berkeley software other universities wanted was a compiler and an editor, not a kernel.

Demand turned local work into a distribution. Joy began compiling the first bundle in 1977, and it shipped as 1BSD on March 9, 1978, an extension of Version 6 Unix rather than a full system, with about 30 copies distributed. 2BSD followed in May 1979 carrying updates plus two programs Joy wrote, the C shell and the vi text editor, the visual version of ex. Roughly 75 copies went out. Those figures come from the Wikipedia entry on the Berkeley Software Distribution, which also records the release dates in the table below.

Release	Date	Hardware	What it was built from	What it added
1BSD	March 9, 1978	PDP-11	Version 6 Unix, as an extension rather than a full operating system	Improved Pascal implementation and an enhanced ex editor
2BSD	May 1979	PDP-11	Updates to the 1BSD software	C shell and vi text editor, both written by Bill Joy
3BSD	End of 1979	VAX	UNIX/32V kernel plus ports of 2BSD utilities and 32V utilities	Babaoglu’s virtual memory implementation in a largely rewritten kernel

The Unix Heritage Society archive still files these as separate directories: 1BSD, 2BSD, 3BSD, 4BSD, Net1, Net2. The 1BSD directory holds a single tarball and nothing else; the 2BSD directory holds its own archive beside later trees reaching 2.11BSD, patched for years under the same name.

Hardware forced the third step. The VAX arrived at Berkeley in 1978, and UNIX/32V, the port of Unix to that architecture, did not use the machine’s virtual memory. A 32-bit minicomputer running a memory model designed for a PDP-11 is an expensive machine doing cheap work. So the 32V kernel was largely rewritten to include Babaoglu’s virtual memory code, and the complete system, new kernel plus ports of the 2BSD and 32V utilities, shipped as 3BSD at the end of 1979.

3BSD left a filename behind too. The release was alternatively called Virtual VAX/UNIX or VMUNIX, and BSD kernel images were normally named /vmunix until 4.4BSD, which is why old BSD and Solaris systems look for a kernel at that path.

The Editor That Shipped Before the Operating System

Because ex runs from episode 12 straight into episode 13, it is worth showing it still works. It is a POSIX line editor, and vim ships an ex-compatible binary, so the software Haley and Joy were improving in 1976 runs on a 2026 machine. Install vim if it is missing (apt install vim on Debian and Ubuntu, brew install vim on macOS), then batch-edit a config without an interactive session:

Note: The following code is an illustrative example and has not been verified against official documentation. Please refer to the official docs for production-ready code.

# Requires vim, which ships an ex-compatible binary.
printf 'burst: 1024\nburst: 1024\nscheduler: fifo\n' > kernel.conf

ex -s kernel.conf <<'CMDS'
%s/^burst: 1024$/burst: 512/
/^scheduler:/s/fifo/clock/
wq
CMDS

cat kernel.conf

# Expected output:
# burst: 512
# burst: 512
# scheduler: clock
#
# Note: ex -s suppresses status messages, so a bad address fails quietly.
# Production scripts should check the exit status and copy the file first.

Two of those lines show the model in miniature. The first substitutes on every matching line; the second addresses the line beginning with scheduler: and changes only that one. ex had line addressing before it had a screen, which is why a visual editor could be built on top of it instead of beside it.

The same 2BSD bundle carried the C shell. The package is tcsh on Linux (apt install tcsh), and macOS ships csh at /bin/csh. Here is the arithmetic a tape run actually required:

One-indexed arrays, @ for arithmetic assignment, and the foreach loop are all csh idioms, and they are why the shell got adopted for short operational scripts. The costs are real: csh pipes behave differently from sh pipes, and its parsing of complex redirection is inconsistent enough that most sites moved scripting back to sh.

Babaoglu, Joy, and a VAX Without Reference Bits

The technical core of episode 13 is a hardware limitation. Babaoglu, then working on his doctorate at Berkeley, implemented the virtual memory system together with Bill Joy, and the result let Unix run on hardware lacking page-reference bits, according to his Wikipedia entry. It shipped as 3.0BSD.

Page-reference bits are how hardware tells a kernel which pages were touched recently. Take them away and a kernel that wants to approximate least-recently-used replacement has to reconstruct usage history in software or pick a policy that never needs it. The 1981 paper Babaoglu and Joy published on the conversion is titled, with no hedging, “Converting a swap-based system to do paging in an architecture lacking page-referenced bits,” in ACM SIGOPS Operating Systems Review 15(5), pages 78 to 86. They started from a system that swapped whole processes and moved it to one that paged memory, on a machine that would not answer the question “which page did you use last?”

That question is the whole of page replacement policy in one line, and it is cheap to run.

Simulating the Page Replacement Problem

The script below compares first-in-first-out against least-recently-used on the same reference string with three frames. LRU stands in for the policy a kernel would prefer; it needs recency information, which is what a reference bit normally supplies for free.

from collections import OrderedDict, deque

TRACE = [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1]
FRAMES = 3

def fifo(trace, frames):
 resident, queue = set(), deque()
 faults = 0
 for page in trace:
 if page in resident:
 continue
 faults += 1
 if len(resident) == frames:
 resident.remove(queue.popleft())
 resident.add(page)
 queue.append(page)
 return faults

def lru(trace, frames):
 recent, faults = OrderedDict(), 0
 for page in trace:
 if page in recent:
 recent.move_to_end(page)
 continue
 faults += 1
 if len(recent) == frames:
 recent.popitem(last=False)
 recent[page] = True
 return faults

for name, policy in (("FIFO", fifo), ("LRU", lru)):
 faults = policy(TRACE, FRAMES)
 hits = len(TRACE) - faults
 print(f"{name}: {faults} faults, {hits} hits, {hits / len(TRACE):.0%} hit rate")

# Expected output:
# FIFO: 15 faults, 5 hits, 25% hit rate
# LRU: 12 faults, 8 hits, 40% hit rate
#
# Note: this models the policy choice only, not the 3BSD implementation.
# Real kernels need frame pinning, dirty-page writeback and shared-page
# handling, none of which appear here.

Three faults out of twenty references, a 15-point swing in hit rate, on a trace this short. Scale that to a VAX serving a timesharing load and the missing reference bits stop looking like a rounding error. FIFO carries its own pathology besides: on some traces, adding memory makes it perform worse.

The payoff reached past the release. 3BSD was followed by 4BSD in November 1980, which became a popular choice for VAX installations, and DARPA funded the BSD project from 1979 through 1988. A graduate student’s page replacement work is why the Defense Department’s research arm had something worth funding.

Reading the Comic Against the Record

Treat the episode as a map and it works: sequence, motivation, who was in the room, why one release led to the next. It is a narrative aid rather than an archival source, a methods note about the medium rather than a complaint about the strip.

Compression shows up even in the well-documented anecdotes. The familiar line is that Joy wrote vi over a weekend. Joy denies it. Eric Schmidt, then CEO of Novell, said during an interview in PBS’s documentary Nerds 2.0.1 that Joy had rewritten the BSD kernel over a weekend, and that claim is inaccurate by the account on Bill Joy’s Wikipedia page.

Licensing is the gap the episode has no room for. Every BSD release up to that point carried proprietary AT&T Unix code and therefore fell under an AT&T software license. That constraint ended in court: USL v. BSDi was filed in 1992 and produced an injunction on distribution of Net/2. The January 1994 settlement went largely Berkeley’s way. Of 18,000 files in the Berkeley distribution, three had to be removed and 70 modified to carry USL copyright notices.

Developers who want the same instinct applied to current Unix tooling will recognize the shape of the problem: a small set of binaries, a long tail of surprising behavior, and documentation that never caught up. Our analysis of how trusted Unix binaries become attack vectors covers that from the security side, and building Linux from scratch is the closest modern equivalent to what Joy was doing with a tape.

More in-depth coverage from this blog on closely related topics:

Sources and References

Sources cited while researching and writing this article: