PDP-6 Computer Emulator Running 1966 Lisp

TL;DR

The PDP-6, built in only 23 units, was architecturally optimized for Lisp by splitting its 36-bit word into left and right halves to efficiently implement car and cdr operations, making it a sibling machine to the language it was designed to run.

Key Takeaways

1Only 23 PDP-6 computers were ever built, prompting the speaker to create a software emulator of the entire machine based on publicly available schematics and descriptions.
2The PDP-6 and Lisp were co-developed in the 1960s with MIT hackers writing Lisp on blackboards while simultaneously testing code on DEC's incomplete PDP-6 prototype.
3The PDP-6's 36-bit architecture splits words into two 18-bit halves to store cons cell pairs (car and cdr), enabling Lisp list operations with single-instruction efficiency.
4Car and cdr names originated from IBM 704 instruction fields (content of address register, content of decrement register), not from cryptic Lisp abbreviations.
5The restored 1966 Lisp version was recovered from a deck tape image in binary form; the speaker rebuilt working source code from assembly language.
6PDP-6 Lisp predates modern Lisp conventions like defun, instead using property lists to define functions.
7The emulator includes period-accurate peripherals: four deck tape units, teletype, vector display with character generator, and a front-panel interface.

Notable Quotes

“Only about 23 were built. And so I had to create my own in software.”
— Speaker

“I don't think it's acceptable to not have a PDP-6 in the living room.”
— Speaker

“Lisp and the PDP-6 are actually siblings in this PDP-6 Lisp. They are kind of siblings because the MIT hackers were writing the Lisp, developing this Lisp on a blackboard like on campus on MIT. And they would drive to DEC while they were building the first PDP-6.”
— Speaker

“To me this is poetry. It's very short, sweet, succinct code.”
— Speaker

Chapters

1. Introduction & Emulation Project

The speaker describes being inspired by Steven Levy's Hackers book to recreate the PDP-6, of which only 23 were built; he built a second-generation software emulator with graphical peripheral display including tape drives, teletype, vector display, and paper tape reader/punch.

2. PDP-6 Design Goals & Lisp Sibling Relationship

The PDP-6 was engineered for three goals: time-sharing, floating-point scientific computation, and efficient Lisp execution; MIT hackers developed Lisp on campus while simultaneously debugging code on DEC's unfinished PDP-6 prototype, creating a co-evolutionary relationship.

3. Loading and Running 1966 Lisp Demo

The speaker demonstrates using TECO text editor and a light-pen interface to load a Lisp program from tape unit four, then loads the 1966 Lisp version from tape unit one (recovered from a deck tape image in binary form) and executes simple factorial and greet functions.

4. Car and Cdr Origins on IBM 704

Car and cdr were named after IBM 704 instruction word fields (content of address field and content of decrement field of a register), not cryptic abbreviations; the 704's 36-bit word was split into four fields allowing two addresses per instruction word.

5. PDP-6 Architecture for Efficient List Operations

The PDP-6 simplifies the 704 design by splitting its 36-bit word into just two 18-bit halves for left (car) and right (cdr) values, enabling cons cell pairs with dedicated half-word instructions; the speaker displays assembly code implementing car/cdr chains as single-page implementations.

6. Lisp List Structure Navigation

Lisp uses permutations of car and cdr names (cdr, cadr, caddr, caadr, etc.) to navigate nested list structures up to four levels deep; extracting the second element from a list combines cdr (tail) and car (head) operations.

Key People & Entities

Gordon Bell: Architect of the PDP-6 and other PDP computers
Steven Levy: Author of Hackers book, which inspired the speaker's PDP-6 emulation project
MIT hackers: Developers of PDP-6 Lisp who co-evolved the language alongside the machine's design in the 1960s

Glossary

Car: Lisp function that extracts the first element (address field) of a cons cell or the left half of a PDP-6 word; originally 'content of address register' from IBM 704 terminology.
Cdr: Lisp function that extracts the remaining list structure (decrement field) or the right half of a PDP-6 word; originally 'content of decrement register' from IBM 704 terminology.
Cons cell: A data structure pairing two values (car and cdr) to build linked lists; stored in the left and right halves of a 36-bit PDP-6 word.
Deck tape: Removable 1960s magnetic tape storage medium, similar to floppy disks but using tape technology; held individual files and was portable between machines.
TECO: Early text editor for PDP machines, originally designed as a screen editor with light-pen support; screen features were later removed for time-sharing systems.
Light pen: Input device that senses when a spot on a display has been brightened, allowing the computer to determine cursor position without a mouse.
Time-sharing: Computing model allowing multiple users to simultaneously use a single computer, a primary design goal of the PDP-6.
Half-word instructions: PDP-6 assembly instructions that operate on 18-bit halves of the 36-bit word, enabling efficient manipulation of cons cell pairs.

Explore