The idea that made computers universal: put the program in the same memory as the data, encoded as ordinary numbers, so a fixed machine can run any code you write into it. Below is a tiny real CPU — memory, a program counter, an accumulator, seven opcodes — running the fetch–decode–execute cycle live. The code you see is just numbers in cells. Terms go in, the machine steps, the result comes out. The blue team builds and defends it; the red team tries to break it.
source John von Neumann, First Draft of a Report on the EDVAC (Moore School, 1945) — archive.org/details/vnedvac. Rendered, not quoted.
One memory holds words. A word is a number: op×100 + address. The program counter (PC) names the next word; the accumulator (ACC) is the one register the machine computes in. Each tick:
| phase | what happens now |
|---|
The instruction set (7 opcodes):
| op | name | effect |
|---|---|---|
| 0 | HALT | stop |
| 1 | LOAD a | ACC ← mem[a] |
| 2 | ADD a | ACC ← ACC + mem[a] |
| 3 | STORE a | mem[a] ← ACC |
| 4 | SUB a | ACC ← ACC − mem[a] |
| 5 | JMP a | PC ← a |
| 6 | JMPZ a | if ACC=0: PC ← a |
Turing (On Computable Numbers, 1936) proved one universal machine can imitate any other by reading a description of it from its tape. That description and the data it works on were, in his proof, symbols of the same kind.
The 1945 Draft gives that abstraction an architecture: instructions and data share one addressable store, one encoding, one bus. Code is data — a program can be read, written, and computed like any number. That single decision is why the machine in the center can be reprogrammed instead of rebuilt. Each sphere is the next one's premise.
The blue team's live check: build and run the sum program for N=1..10 and several multiply programs, then confirm each result against N(N+1)/2 and a·b. If red corrupts an opcode, this badge is where it shows.
You choose a task; the assembler writes a program into memory as plain numbers, right beside the values it works on. Nothing distinguishes an “instruction” from a “datum” except how the machine reaches it: if the PC points at a word, it is decoded and executed; if a LOAD names it, it is read as a value.
For example the word 221 is both the number two-hundred-twenty-one and the instruction ADD 21. Same bits, two readings. That ambiguity — resolved only at runtime — is the whole stored-program idea, and it is what you feed the panel below.
memory (blue = code, green = data, boxed = PC):
Every value is computed by executing these exact words — nothing is looked up.
What the machine produces, proven by running it: sum 1..10 = 55 (and every N matches N(N+1)/2), and multiply-by-repeated-addition gives a·b for every small pair — e.g. 3×4 = 12, 9×9 = 81. The current run's answer sits in ACC above; the totals are the output.
The blue team's witness (left) re-runs these live; the red team (right) tries to make the result wrong.
This toy is honest but small: 24 cells, one accumulator, no I/O, no negative-address guard, arithmetic unchecked for overflow. It demonstrates the principle; it is not the EDVAC and not a modern ISA.
“Von Neumann invented the stored-program computer.” Cut. The concept had several parents — Eckert, Mauchly, and Turing among them. The Draft is the first written description; Goldstine circulated it under von Neumann's name alone, which itself helped void the patent.
“The EDVAC ran these programs in 1945.” Cut. The Draft was an incomplete design (parts were never written); EDVAC did not become operational until ~1951.
“Code and data are truly indistinguishable.” Kept, corrected. They share memory and encoding, but the machine interprets a word as instruction only when the PC reaches it — exactly as the panel shows. Same bits, resolved by role.
The red team's move: reach into the sum program and corrupt one opcode — flip ADD (2) at address 3 into SUB (4). The blue team's witness (window 7) is watching.
Flip that single opcode and the sum program subtracts instead of adds: sum 1..10 returns −55, not 55. The witness re-runs, disagrees with N(N+1)/2, and turns red. Nothing is faked; the attack is a real bit-flip in memory and it is caught.