The Thinking Machine Chronicles #0007: The Blueprint of Every Computer Ever Built: Von Neumann Architecture

Era 1 · The Foundations (1936–1955) A mathematician writes twenty-three pages that tell every engineer alive exactly how to build a mind.

The World in 1945

On 8 May 1945, Victory in Europe Day,Germany surrendered unconditionally after nearly six years of war that had consumed an estimated seventy to eighty-five million lives. Adolf Hitler had taken his own life in a Berlin bunker on 30 April; within a week, the Third Reich collapsed. In San Francisco, delegates from fifty nations were simultaneously negotiating the United Nations Charter, which they signed on 26 June, three days before John von Neumann completed the document at the centre of this article. The Pacific war continued in its brutal island-hopping logic: American forces completed the conquest of Okinawa in late June at a cost of 12,000 American and 100,000 Japanese lives, and the Joint Chiefs were planning Operation Downfall, an invasion of the Japanese home islands projected to cost a million Allied casualties. President Franklin Roosevelt had died at Warm Springs on 12 April, leaving Harry Truman, who had known nothing of the Manhattan Project, to confront the most consequential military decision in history. On 16 July 1945, sixteen days after von Neumann dated his report, the Trinity device detonated at Alamogordo, New Mexico, and the atomic age began.

The scientific world was simultaneously exhausted and electrified. The Manhattan Project had assembled more mathematical talent in a single institution, Los Alamos,than any peacetime university could have hoped to attract, and John von Neumann had been among its most valued consultants. He had spent the war commuting between Los Alamos, Aberdeen Proving Ground, and the Moore School of Electrical Engineering at the University of Pennsylvania, where engineers J. Presper Eckert and John Mauchly were building ENIAC, a machine of 18,000 vacuum tubes capable of 5,000 additions per second. The implosion-lens hydrodynamics calculations von Neumann needed for the Fat Man bomb design required exactly the kind of machine Eckert and Mauchly were building, and the traffic between the two projects was constant. By the spring of 1945, von Neumann had formed a precise idea of how those machines could be made far simpler, far more flexible, and far more powerful, not by adding more tubes, but by rethinking what a program was.

The Draughtsman of the Machine Age

John von Neumann was born Neumann János Lajos in Budapest in 1903, the son of a prosperous banker. By the age of nineteen he had simultaneously completed a degree in chemical engineering at Zurich and a doctorate in mathematics at Budapest. By twenty-five he had axiomatised quantum mechanics and made foundational contributions to set theory. He escaped Nazi Europe in 1933, the same year as Einstein, accepting a permanent appointment at the newly founded Institute for Advanced Study in Princeton, a position he held for the rest of his life alongside a staggering number of government and industrial consultancies. His colleagues struggled to describe his mental speed. Herman Goldstine, the army liaison at the Moore School, recalled that von Neumann could compute a ballistic trajectory mentally faster than most people could set it up on a desk calculator. Physicist Edward Teller said that when he thought he understood something, talking to von Neumann revealed that he had only grasped the outline.

In the spring of 1945, von Neumann had joined the Moore School discussions about ENIAC's successor, a machine called EDVAC, the Electronic Discrete Variable Automatic Computer. Eckert and Mauchly had already proposed the core idea: instead of setting a program by reconnecting thousands of cables and switches, the machine should read its instructions from memory, just as it read its data. Von Neumann had arrived at the same idea from the direction of Turing's 1936 Universal Machine, which he knew well. What he brought to the Moore School was a systematic, mathematical framework for the architecture,a formal separation of the machine into logical organs, each with a defined role and a defined interface. On 30 June 1945, he completed a document titled "First Draft of a Report on the EDVAC." Its twenty-three pages would become the founding text of computer architecture.

The Problem: Programs Wired in Glass and Wire

Every computing machine that existed in June 1945 was, in a precise sense, not programmable. ENIAC, still under construction, not yet unveiled,executed a fixed sequence of operations determined by the physical positions of 6,000 switches and the connections of roughly 3,000 plugboard cables. Changing the "program" meant spending days rewiring the machine for each new calculation. Colossus at Bletchley Park was slightly more flexible, its switch panels and patch boards could be reconfigured in hours rather than days,but it too was fundamentally hardwired. IBM's relay-based calculators were worse: their sequence was encoded on plugboards set by operators, with no provision for conditional branching at all.

The consequences were concrete and crippling. An ENIAC operator described the programming process as comparable to "playing an organ with your feet and both hands simultaneously while someone else turns the pages." Two weeks of setup for twenty seconds of computation was a typical ratio. Each new problem, each new ballistic table, each new equation system,was a new machine in all but the vacuum tubes. There was no separation between the structure of the computation and its physical embodiment. Turing's 1936 paper had demonstrated, theoretically, that a single Universal Machine could simulate any other machine given a description of it on its input tape. But no one had yet built a physical realisation of this principle. Von Neumann's contribution was to turn Turing's theoretical insight into an engineering specification: a blueprint a real machine could follow.

The First Draft: Five Organs and a Radical Idea

Von Neumann's report describes a computing machine with five logical components, which he calls "organs." The language is deliberately biological, an echo of McCulloch and Pitts's 1943 neuron model, which von Neumann had read and admired.

Organ	Symbol	Function
Central Arithmetic	CA	Performs all arithmetic and logical operations
Central Control	CC	Sequences instructions; directs all other organs
Memory	M	Stores data and instructions in the same address space
Input	I	Receives data from the outside world
Output	O	Sends results to the outside world

The table looks almost obvious in retrospect. Its revolutionary content is in the definition of M. Von Neumann writes, with studied precision, that the memory must store "not only the number to be operated upon but also the orders by which the sequence of operations is to be governed." Instructions are numbers. Numbers can be treated as instructions. The program lives in exactly the same substrate as the data it processes.

This stored-program principle has three immediate consequences that still shape computing eight decades later. First, programmability: loading a new program means writing new numbers into memory, a purely electronic operation taking microseconds, not days of rewiring. Second, generality: any computation expressible as a finite sequence of simple operations can run on a single machine; the hardware does not need to be tailored to the problem. Third, programs as data: a program can read, modify, and write instructions into memory and then execute them,the foundation of every operating system, compiler, and interpreter ever written. Self-modifying code was exploited aggressively by early programmers for efficiency; modern processors restrict it for security, but the underlying capability remains.

Inside the Architecture

The machine von Neumann describes operates on a word-addressable memory. Each memory location holds one word, a fixed-width binary number. In the EDVAC design, each word was 44 bits. In general, for a machine with word width $w$ bits and $n$ addressable locations, we need $\lceil \log_2 n \rceil$ bits of address. An instruction word encodes an opcode $\delta$ (specifying which operation to perform) and an operand address $\alpha$ (specifying which memory location to operate on):

$\text{instruction} = \underbrace{\delta}_{\text{opcode}} \;\|\; \underbrace{\alpha}_{\text{address}}$

where $\|$ denotes bit concatenation. For a machine with $k$ distinct operations and $n$ memory locations, the instruction must be at least:

$|\delta| + |\alpha| = \lceil \log_2 k \rceil + \lceil \log_2 n \rceil \text{ bits wide}$

A minimal instruction set for useful computation requires surprisingly few opcodes: load from memory, store to memory, add, subtract, unconditional jump, conditional jump (on zero), and halt. The memory addresses at which constants and variables are stored become, in effect, the machine's "variables."

The Fetch-Decode-Execute Cycle

The heartbeat of every von Neumann machine is the fetch-decode-execute cycle, which the Central Control organ repeats for every instruction:

Fetch, read the instruction word at memory[PC] into IR, then increment PC.

Decode, split IR into opcode $\delta$ and operand address $\alpha$: $(\delta, \alpha) \leftarrow \text{split}(\text{IR})$

Execute, perform operation $\delta$ using the operand at address $\alpha$.

In register notation the fetch step is:

$\text{MAR} \leftarrow \text{PC}, \quad \text{MDR} \leftarrow M[\text{MAR}], \quad \text{IR} \leftarrow \text{MDR}, \quad \text{PC} \leftarrow \text{PC} + 1$

The five registers involved are:

• PC (Program Counter): holds the address of the next instruction to fetch
• MAR (Memory Address Register): the address currently being placed on the memory bus
• MDR (Memory Data Register): the data word read from or written to memory
• IR (Instruction Register): the instruction currently being decoded
• ACC (Accumulator): the primary arithmetic register

Execution is deterministic: given a fixed initial state of memory and PC, the machine will always produce the same output. A jump instruction simply overwrites PC with the target address instead of incrementing it, redirecting the cycle to a new point in memory. A conditional jump checks the accumulator before deciding whether to redirect. That is all: with these primitives, any computable function can be expressed.

The Von Neumann Bottleneck

The stored-program design contains a structural limitation that would be fully articulated only in 1977, when John Backus used his Turing Award lecture to name it. Because instructions and data share the same memory and the same communication pathway, the bus,the machine cannot simultaneously fetch the next instruction and read a data operand. At any given clock cycle, the bus is doing one thing or the other:

$\text{effective throughput} \leq \frac{B_{\text{mem}}}{2}$

where $B_{\text{mem}}$ is the memory bus bandwidth. As processors grew faster and memory grew larger, this bottleneck became the dominant constraint on performance. Every major advance in processor architecture since the 1980s, instruction caches, data caches, pipelines, out-of-order execution, superscalar issue, prefetching,is, in essence, a different strategy for hiding or mitigating the Von Neumann bottleneck. It has never been fully solved, only managed. The Harvard architecture, which uses separate buses for instructions and data, bypasses it structurally, but even modern Harvard-derived processors (the ARM Cortex series, most microcontrollers) implement a modified Harvard architecture that allows the two address spaces to be unified at the cache level, preserving the stored-program flexibility von Neumann's design required.

The Code

The stored-program principle is best understood by watching it work. Below is the core of the fetch-decode-execute loop from the companion simulator, a minimal Von Neumann machine in pure Python with 256 words of memory and nine opcodes:

def step(self) -> bool:
    """One fetch-decode-execute cycle. Returns False when halted."""
    # FETCH — read instruction from memory[PC]
    self.MAR = self.PC
    self.MDR = self.memory[self.MAR]
    self.IR  = self.MDR
    self.PC += 1

    # DECODE — split the 16-bit word into opcode and address
    opcode, addr = (self.IR >> 8) & 0xFF, self.IR & 0xFF

    # EXECUTE — nine operations cover all useful computation
    if   opcode == LDA:  self.ACC  = self.memory[addr]
    elif opcode == STA:  self.memory[addr] = self.ACC
    elif opcode == ADD:  self.ACC += self.memory[addr]
    elif opcode == SUB:  self.ACC -= self.memory[addr]
    elif opcode == JMP:  self.PC   = addr
    elif opcode == JZ:   self.PC   = addr if self.ACC == 0 else self.PC
    elif opcode == OUT:  print(self.memory[addr])
    elif opcode == HLT:  self.halted = True; return False
    return True

A loop that sums the integers 1 through 10 is encoded as ten instruction words loaded into addresses 0x00–0x09, with the running sum and counter stored as plain integers at addresses 0x20–0x22. There is no physical distinction between program and data, the memory is a single flat array of numbers. That is the von Neumann insight in its most concrete form.

The full project includes three demos: a stored-program principle illustration (shows the program as a raw memory dump before execution), the sum-1-to-10 loop, and a Fibonacci sequence generator, two entirely different algorithms running on the same hardware by virtue of different numbers written into the same memory.

Why It Mattered

Von Neumann's architecture mattered for reasons that go beyond hardware history.

It made software possible. Before the stored-program principle, there was no clean concept of a "program" separate from the physical machine running it. After von Neumann, a program was an abstract object, a sequence of encoded instructions,that could be written on paper, punched onto cards, transmitted over a wire, and loaded into any machine implementing the same instruction set. The entire software industry, from operating systems to compilers to cloud computing, rests on this abstraction.

It unified theory and practice. Turing's 1936 paper had proved that a Universal Machine was theoretically possible. Von Neumann's report showed engineers how to build one. The gap between "exists in principle" and "here is the instruction set and the bus width" was closed in twenty-three pages. The Manchester Baby ran the first stored program in June 1948. EDVAC followed in 1949. The IAS machine at Princeton, which von Neumann supervised personally, ran in 1951. Within a decade, the architecture described in the First Draft had propagated to IBM, to the British computing industry, to universities on three continents.

It established the template for thinking about computation. Programmers ever since have thought in terms of variables (named memory locations), instructions (encoded operations), and control flow (jumps that redirect the program counter). Assembly language, FORTRAN, C, Python, every programming language is, at some level, a notation for generating sequences of von Neumann machine instructions. The mental model imposed by the architecture has been so durable that it shapes how programmers conceive of problems even when the underlying hardware has long since departed from the pure von Neumann model.

The authorship controversy mattered too. The fact that von Neumann's name alone appeared on a collaborative document, and that this burned Eckert and Mauchly, and indirectly led to decades of patent litigation,is a cautionary tale the computing industry has never fully absorbed. Credit for foundational inventions is disproportionately assigned to the person who writes the clearest document, not necessarily the person who had the idea first. This dynamic appears again and again in computing history.

What Came Next

As von Neumann was drafting his architectural blueprint, a different kind of thinker was asking a complementary question, not how machines would compute, but how humans would find and navigate the information those machines produced. Vannevar Bush, the director of the US Office of Scientific Research and Development who had overseen the entire American wartime science programme, published "As We May Think" in The Atlantic in July 1945, days after von Neumann's report was dated. Bush imagined a device he called the Memex,a mechanical desk that could store all of a person's books, records, and communications, and retrieve them by association rather than by index. He could not build it; the technology did not exist. But the conceptual move, treating information itself as a material to be stored, linked, and navigated,would echo forward to hypertext, the internet, and the web. That story is next: The Thinking Machine Chronicles #0008: As We May Think: Vannevar Bush Dreams of the Thinking Machine's Memory.

---

References

1. Von Neumann, J. (1945). First Draft of a Report on the EDVAC. Moore School of Electrical Engineering, University of Pennsylvania. The founding document of stored-program computer architecture; circulated June 30, 1945. Reprinted in: Aspray, W. & Burks, A. (eds.), Papers of John von Neumann on Computing and Computer Theory, MIT Press, 1987.
2. Goldstine, H. H. (1972). The Computer from Pascal to von Neumann. Princeton University Press. First-hand account of the Moore School work and von Neumann's involvement; Goldstine was the army liaison who arranged the First Draft's distribution.
3. Eckert, J. P. (1980). The ENIAC. In N. Metropolis, J. Howlett, & G.-C. Rota (eds.), A History of Computing in the Twentieth Century, Academic Press. Eckert's own retrospective on ENIAC and the stored-program concept.
4. Backus, J. (1978). Can Programming Be Liberated from the Von Neumann Style? Communications of the ACM, 21(8), 613–641. The 1977 Turing Award lecture that named the Von Neumann bottleneck and proposed functional programming as an escape from it.
5. Aspray, W. (1990). John von Neumann and the Origins of Modern Computing. MIT Press. The definitive scholarly biography focusing on his computing work; covers the authorship dispute with Eckert and Mauchly in detail.
6. Copeland, B. J. (ed.). (2005). Alan Turing's Automatic Computing Engine. Oxford University Press. Covers the relationship between Turing's 1936 theoretical work and the stored-program machines of the late 1940s.
7. Williams, F. C. & Kilburn, T. (1948). Electronic Digital Computers. Nature, 162, 487. The Manchester Baby announcement; first public report of a stored-program computer actually running.