The smartphone in your pocket, the laptop on your desk, the servers that run the internet, the supercomputers that simulate climate models, and the chips inside your car’s engine all share a common ancestor. They are all, at their core, implementations of an architecture described in a 101-page document written in 1945 by the mathematician John von Neumann. The document, known as the First Draft of a Report on the EDVAC, laid out the design principles for a stored-program electronic computer, a machine that stores both its data and its instructions in the same memory and processes them sequentially through a central processing unit.
This architecture, now called the von Neumann architecture, has dominated computing for eighty years. Despite enormous advances in speed, miniaturization, and capability, the fundamental design has never been replaced. Every general-purpose computer built since 1945 follows the same basic plan.
Before EDVAC: The Problem with ENIAC
The EDVAC report was written in the context of a specific engineering project at the University of Pennsylvania. The team there, led by John Mauchly and J. Presper Eckert, had built ENIAC (Electronic Numerical Integrator and Computer), the first large-scale electronic digital computer, completed in late 1945. ENIAC was a marvel of engineering: 18,000 vacuum tubes, 70,000 resistors, and 1,500 relays, filling an entire room and consuming 150 kilowatts of power.
But ENIAC had a fundamental limitation. Its “program” was not stored in memory but was configured physically, by plugging cables into patch panels and setting switches. Changing the program required days of manual reconfiguration. ENIAC was essentially a new machine for each new problem, rewired by technicians who physically reconfigured its connections.
Von Neumann, who had joined the project as a consultant in 1944, recognized that this approach was unsustainable. If computers were to be practical tools rather than laboratory curiosities, they needed to be programmable in a fundamentally different way. The program itself had to be stored in memory, alongside the data, so that changing the computation required only changing the contents of memory, not rewiring the machine.
The Five Components
The EDVAC report described a computer organized around five functional components, a structure that remains the template for all modern computers:
1. The Central Arithmetic Unit (now the arithmetic logic unit, or ALU): the part of the computer that performs mathematical and logical operations. Addition, subtraction, multiplication, comparison, and Boolean logic all happen here.
2. The Central Control Unit: the part that fetches instructions from memory, decodes them, and directs the other components to execute them. The control unit determines which operation to perform next and coordinates the flow of data through the machine. Together with the ALU, it forms what we now call the central processing unit (CPU).
3. The Memory: a single storage system that holds both the program (the instructions to be executed) and the data (the numbers to be processed). This is the crucial innovation. By storing the program in the same memory as the data, the computer can modify its own program during execution, enabling loops, conditional branching, and subroutines, the fundamental constructs of all programming.
4. The Input Unit: the means by which data and programs enter the computer from the outside world. In the 1940s, this was punched cards or paper tape. Today, it is keyboards, network connections, sensors, and storage devices.
5. The Output Unit: the means by which results leave the computer. In the 1940s, printers and punch cards. Today, displays, network connections, and storage devices.
The Stored Program Concept
The most revolutionary aspect of the EDVAC architecture is that programs and data share the same memory. This seems obvious today, but in 1945 it was a radical idea. Previous computing machines (including ENIAC) kept programs and data strictly separate: the program was embodied in the machine’s wiring or switch settings, while the data was in the memory registers.
Storing the program in memory had profound consequences. A program could be loaded from an external medium (punched tape, later disk) without rewiring anything. A program could modify itself during execution (useful for certain mathematical techniques, though modern programming avoids this for reliability reasons). Most importantly, a program could treat other programs as data: loading them, storing them, copying them, and eventually compiling them from human-readable languages into machine instructions.
This last capability is what makes general-purpose computing possible. A single machine, with fixed hardware, can run an unlimited variety of programs. The hardware provides the capability; the software provides the specificity. The same computer that calculates artillery trajectories can also process payroll, play chess, or simulate weather, simply by loading a different program into memory.
The Fetch-Execute Cycle
The operation of a von Neumann computer follows a simple, endlessly repeated cycle:
Fetch: the control unit reads the next instruction from memory. Decode: the control unit determines what the instruction means. Execute: the appropriate operation is performed (a calculation, a data transfer, a comparison). Store: the result is written back to memory. Then the cycle repeats with the next instruction.
This fetch-decode-execute-store cycle is the heartbeat of every von Neumann computer. A modern processor executes billions of these cycles per second, but the fundamental rhythm is the same as in the first stored-program machines of the late 1940s.
The First Implementations
The EDVAC itself was not completed until 1951, delayed by patent disputes and the departure of key engineers. But the stored-program concept spread quickly. The Manchester Baby (1948) at the University of Manchester was the first machine to run a stored program. The EDSAC (1949) at Cambridge, built by Maurice Wilkes based on the EDVAC report, was the first practical stored-program computer used for regular scientific calculations.
By the early 1950s, stored-program computers were being built at universities and research laboratories around the world. The architecture proved so versatile and so efficient that it displaced every alternative approach. Analog computers, relay-based computers, and hard-wired digital computers all gave way to the von Neumann design.
The Architecture Scales
The von Neumann architecture has survived eight decades of technological change because it is a logical design, not a physical one. The EDVAC report describes functional relationships between components, not the specific technology used to implement them.
The first implementations used vacuum tubes (large, hot, unreliable). In the late 1950s, transistors replaced vacuum tubes (smaller, cooler, more reliable). In the 1960s, integrated circuits placed multiple transistors on a single chip. In the 1970s, the entire CPU was placed on a single chip (the microprocessor). Since then, the number of transistors on a chip has doubled roughly every two years (Moore’s Law), reaching billions of transistors on a single processor.
Through all of this, the basic architecture has not changed. A modern CPU still has an arithmetic logic unit, a control unit, and memory. It still fetches instructions from memory, decodes them, and executes them in sequence (with modern optimizations like pipelining, caching, and out-of-order execution that accelerate the process without changing the fundamental model).
The Von Neumann Bottleneck
The architecture’s greatest strength (simplicity and universality) is also the source of its greatest weakness. Because both data and instructions must pass through the same channel between the CPU and memory, the speed of computation is limited by the speed of this channel. The CPU can process data much faster than memory can supply it. This mismatch, called the von Neumann bottleneck, has been the central performance challenge in computer engineering since the 1960s.
Engineers have developed many techniques to mitigate the bottleneck: cache hierarchies (small, fast memories close to the CPU that store frequently accessed data), wider data buses, memory interleaving, and prefetching algorithms. These techniques reduce the impact of the bottleneck but do not eliminate it. The fundamental limitation, that data must travel between memory and processor, remains.
Alternative architectures have been proposed: dataflow computers, neural network processors, quantum computers, and in-memory computing systems. Some of these (particularly GPU-based parallel computing and neuromorphic chips) have found important niches. But for general-purpose computing, the von Neumann architecture remains dominant.
From EDVAC to the Cloud
The cloud computing infrastructure that powers the modern internet consists of millions of servers in data centers around the world. Each server is a von Neumann machine: a CPU, memory, storage, and I/O, connected to a network. The “cloud” is, at the hardware level, a vast collection of von Neumann computers communicating with each other.
When you stream video, search the web, or use a cloud-based application, your request travels to one of these servers, which fetches a program from memory, executes it, processes data, and sends the result back to you. The fetch-execute cycle runs trillions of times per second across millions of machines, but the architecture of each machine is recognizably the same as what von Neumann described in 1945.
The smartphone follows the same architecture: a system-on-chip containing a CPU (with ALU and control unit), RAM, flash storage, and I/O interfaces. The architectural diagram of a modern smartphone, stripped of its specific features, would look remarkably similar to the block diagram in the EDVAC report.
The Document
The First Draft of a Report on the EDVAC was circulated informally among researchers in 1945 and was never formally published by von Neumann during his lifetime. The attribution was controversial: Mauchly and Eckert, who had designed much of the ENIAC hardware, felt that their contributions to the EDVAC concept were not adequately credited in a report that bore only von Neumann’s name. The dispute led to patent conflicts that lasted for decades.
What is not disputed is the report’s influence. It became the most widely read and most influential document in the history of computing. Every computer science curriculum in the world teaches the von Neumann architecture. Every computer engineer works within its framework.
Kronecker Wallis’s edition of the EDVAC Report presents this foundational document printed on blue Fabriano paper in monospace type. It is the blueprint for every computer, the single document that defined how humanity would compute for the foreseeable future.
The cryptanalytical work that motivated much of early computer development, particularly Alan Turing’s efforts at Bletchley Park, demonstrated the need for programmable computing machines. Turing’s own theoretical framework (the Turing machine, described in his 1936 paper) provided the mathematical proof that a universal computing machine was possible. His wartime Treatise on the Enigma documented the practical application of computational thinking that helped end the war and accelerate the development of electronic computers.
Eighty Years and Counting
No other engineering design has dominated its field as completely or as long as the von Neumann architecture. Cars, airplanes, and buildings have been redesigned from the ground up multiple times since 1945. The fundamental architecture of the computer has not. The technology has changed beyond recognition (from room-sized vacuum tube machines to chips smaller than a fingernail), but the logical organization remains the same: memory, processor, input, output, and a program stored alongside its data.
This persistence is not due to lack of imagination or effort. Many alternative architectures have been proposed and some have been built. The von Neumann design persists because it is simple, universal, and good enough. It is the right level of abstraction: specific enough to be implemented efficiently, general enough to handle any computation. Von Neumann found, in 1945, a design that was not just good for its time but good for all time. Eighty years later, every computer in the world is still built on his blueprint.
No products in the cart.