1965 · Digital Equipment Corporation
DEC PDP-8
In 1965 a computer usually filled a room and needed a staff to run it. The PDP-8 fit on a bench, cost roughly what a house did, and could be bought by a single lab. Tens of thousands of them went to work.
| Made by | Digital Equipment Corporation (DEC); lead designer Edson de Castro |
|---|---|
| Introduced | 1965 |
| Word size | 12 bits |
| Memory | 4,096 words of magnetic core, expandable to 32K words |
| Registers | Accumulator (AC), link bit (L), program counter (PC) |
| Instructions | 8 basic operations (3-bit opcode) |
| Memory cycle | 1.5 µs |
| Built from | Discrete transistors on plug-in Flip-Chip modules |
| Price | about $18,000 at launch |
Why it was built
Computers in the early 1960s were sold to big companies and governments. DEC wanted to sell them to people: a physics lab that needed to log an experiment, a factory that wanted to control a machine, a typesetter. Those customers did not need a huge machine. They needed a small, reliable one with a price they could sign for without a board meeting.
The PDP-8 was that machine. It was designed to be as cheap as possible while still being a real general-purpose computer, and the design shows it everywhere. It sold so well that the word minicomputer grew up around it.
How it worked
Everything is 12 bits wide. One register does almost all the work: the accumulator, plus a single extra bit called the link that catches the carry out of additions. A 12-bit address reaches 4,096 words, the standard memory size.
An instruction is one 12-bit word. Three bits choose the operation, which is why there are only eight. The other nine bits say where the operand lives, and there is not much room: seven bits pick a word within a 128-word page, one bit chooses between page zero and the current page, and one bit turns on indirect addressing, where the word found there holds the real address.
| Instruction | What it does |
|---|---|
AND | AND a memory word into the accumulator |
TAD | Two’s complement add a memory word into the accumulator |
ISZ | Increment a memory word; skip the next instruction if it became zero |
DCA | Deposit the accumulator into memory and clear it |
JMS | Jump to subroutine (the return address is stored in its first word) |
JMP | Jump |
IOT | Input/output transfer: talk to a device |
OPR | Operate: a family of micro-operations on the accumulator and link |
There is no subtract and no plain load. To load a value you clear the accumulator and add. To subtract you negate (complement, then increment) and add, which is exactly the trick explained in two’s complement. There is no stack either: a subroutine call writes its return address into the first word of the subroutine itself.
The clever part: OPR
The eighth opcode is where DEC hid most of the instruction set. An OPR word does not refer to memory at all. Its bits are individual switches: clear the accumulator, clear the link, complement, increment, rotate left or right, skip if zero, skip if negative, and more. Several can be set in one word, and they fire in a fixed order. One instruction can clear, complement and increment the accumulator, which loads the constant −1 in a single word. Programmers loved hunting for combinations like that.
Why it mattered
The PDP-8 family stayed in production, in one form or another, for well over a decade and sold in the tens of thousands. It shrank from racks of transistor cards to a single chip, the Intersil 6100, which DEC later used in its own word processors. It put computers inside labs, hospitals, newsrooms and factories, and it trained a generation of programmers to do a lot with very little. Its design is still a favorite for anyone who wants to see how small a useful instruction set can be (more on that in designing an instruction set).
The PDP-8 in NANDSIM
The museum PDP-8 is rebuilt from NAND gates and runs real PDP-8 programs. Step through them and watch the accumulator, link and program counter change, or open it up and inspect memory as it is read and rewritten.