Von Neumann architecture is one of the fundamental models of modern
computing. Formalized in the mid-1940s, as the first electronic
computers were being developed, it rests on an idea that seems almost
obvious today: a program’s instructions can be stored in memory, just
like the data they operate on.
This stored-program principle profoundly changed computer design.
The same machine could now perform very different tasks simply by
loading a new program, without requiring its physical wiring to be
changed.
More than eighty years after the early work on EDVAC, processors have
become vastly more complex. Yet memory, computation, control, and
input/output remain central to how computers work.
Before the stored-program computer
The earliest automatic calculating machines were not necessarily
programmed the way modern computers are.
On some machines, changing the calculation to be performed meant
altering connections, moving cables, setting switches, or preparing new
physical media. ENIAC, developed in the United States during the Second
World War, is a famous example: its original configuration required
substantial manual work.
These machines could perform calculations extraordinarily quickly for
their time, but switching from one problem to another remained
cumbersome.
A crucial question therefore emerged:
What if the instructions telling the machine what to do were
themselves stored in its memory?
The program would no longer be represented only by the machine’s
physical configuration. It would become information that the computer
could load and read.
This idea lies at the heart of the stored-program concept.
The EDVAC project and the 1945 report
In 1945, while ENIAC had not yet been officially unveiled to the public,
its designers were already working on its successor: EDVAC, the
Electronic Discrete Variable Automatic Computer.
John von Neumann joined the
discussions surrounding the project and wrote a document that became
famous: the First Draft of a Report on the EDVAC.
The report described an electronic machine organized around several
major functions: computation, control, memory, and communication with
the outside world. Most importantly, it presented the principle that
instructions could be represented numerically and stored in memory.
The document circulated widely and played a major role in spreading this
new way of designing computers.
This is one of the main reasons the expression “von Neumann
architecture” gradually became established.
The name, however, requires an important historical qualification.
An invention that did not belong to one man
Presenting John von Neumann as the sole inventor of this architecture
would be misleading.
Ideas surrounding the stored-program computer emerged from a much
broader scientific and engineering environment. Engineers J. Presper
Eckert and John Mauchly, who worked on ENIAC and then EDVAC,
directly contributed to the design of these new machines.
Other researchers also helped shape the development of electronic and
programmable computers.
Von Neumann nevertheless played a decisive role in formalizing and,
above all, disseminating these ideas. The First Draft bore his name
and circulated widely among researchers working on future computers.
The historical term therefore endured.
Calling it von Neumann architecture remains perfectly legitimate today,
provided we remember that the birth of the modern computer was the
result of a collective effort.
The five major functions of a computer
In a simplified representation, a von Neumann-type machine contains
several essential elements:
an arithmetic and logic unit;
a control unit;
memory;
input devices;
output devices.
The arithmetic and logic unit, usually called the ALU, performs the
requested operations: additions, subtractions, comparisons, and logical
operations.
The control unit coordinates the machine. It determines which
instruction must be executed and directs the other components.
In modern computers, these two functions are part of the processor,
or CPU.
Memory stores the information the machine needs. It can contain both the
data being processed and the program instructions.
Finally, input and output allow the computer to communicate with the
outside world through keyboards, displays, storage devices, networks,
sensors, and many other peripherals.
This representation is deliberately simplified, but it still provides an
excellent framework for understanding how a computer works.
The decisive idea: instructions and data in memory
The model’s most famous characteristic concerns how memory is used.
In a classic von Neumann architecture, data and instructions can be
stored in the same memory.
Consider an extremely simple program that adds two numbers.
Memory might contain:
the two numbers to add;
the instruction requesting the addition;
the instruction specifying where the result should be stored;
and then the result itself.
For the machine, an instruction is therefore also represented as
numerical information.
This opens up enormous possibilities.
Changing programs no longer necessarily requires rebuilding or rewiring
the computer. New instructions simply need to be placed in memory.
The same physical machine can therefore perform accounting, scientific
calculations, run a game, or operate a text editor simply by using
different programs.
This is one of the principles that make the general-purpose computer
possible.
How does the processor execute a program?
The process can be represented by a cycle commonly known as
fetch-decode-execute.
Imagine that a program has already been loaded into memory.
1. Fetch the instruction
The processor first needs to know which instruction to execute.
A special register, generally called the program counter, contains
the address of the next instruction.
The processor fetches that instruction from memory.
2. Decode the instruction
Once loaded, the instruction must be interpreted.
The control unit determines the requested operation: perform an
addition, compare two values, move data, read a memory location, or
change the program’s execution flow.
3. Execute the operation
The operation is then carried out.
If a calculation is required, the arithmetic and logic unit may be
involved. If the instruction requires data, the processor can retrieve
it from memory.
4. Store the result
The result may be placed in a register, written to memory, or sent
to another component.
The processor then moves on to the next instruction.
With some modern processors operating at billions of cycles per second,
this succession of operations is invisible to the user.
Registers: memory as close as possible to computation
Main memory is not the only place where the processor stores
information.
It also contains very small, extremely fast storage locations called
registers.
They can temporarily hold:
values used in calculations;
memory addresses;
intermediate results;
the current instruction;
the address of the next instruction.
Their capacity is tiny compared with main memory, but their proximity to
the processing units makes them much faster.
This difference illustrates a problem that becomes increasingly
important as processors get faster: computation can become faster than
access to the data it needs.
The von Neumann bottleneck
In the classic model, instructions and data share memory and the
communication paths to the processor.
The processor must therefore continually retrieve new instructions and
the data needed to execute them, and may then need to send results back
to memory.
Even if the processor itself is extremely fast, performance can be
limited by the rate at which information moves between memory and the
processing units.
This phenomenon is known as the von Neumann bottleneck.
The expression was notably popularized by computer scientist John Backus
in the 1970s.
The problem has not disappeared from modern computers. The performance
gap between processors and memory has long been one of the central
challenges of computer architecture.
Caches bring data closer to the processor
One response to this problem is to add several levels of cache
memory.
A cache is much smaller than main memory, but also much faster.
The processor tries to keep instructions and data there that it expects
to use soon.
Modern processors generally contain several levels:
L1 cache, very small and extremely fast;
L2 cache, larger;
L3 cache, larger still and often shared by several cores.
The objective is simple: avoid waiting for main memory whenever
possible.
This hierarchy illustrates how far modern machines have moved beyond the
elementary diagrams of the 1940s while still addressing a difficulty
directly related to the original model.
Von Neumann architecture and Harvard architecture
Another important organization is Harvard architecture.
In a strict Harvard architecture, instructions and data use separate
memories and may have separate communication paths.
This can make it possible to fetch an instruction and data
simultaneously.
The theoretical difference can therefore be summarized as follows:
von Neumann: instructions and data share a memory space.
Harvard: instructions and data are separated.
In practice, modern computers blur this distinction considerably.
A processor may present programmers with a unified memory space
corresponding to the von Neumann model while internally using separate
caches for instructions and data.
This is sometimes called a modified Harvard architecture.
Many microcontrollers and specialized processors also use different
variations of this organization.
It would therefore be inaccurate to imagine that every modern computer
fits perfectly into one model or the other.
Modern processors no longer work strictly one instruction at a time
The fetch-decode-execute cycle is an excellent teaching model, but a
modern processor is far more sophisticated.
To improve performance, it can begin processing a new instruction before
the previous one has completely finished. This is the principle of
instruction pipelining.
It may also contain several execution units capable of performing
different operations simultaneously.
Some processors even rearrange the execution order of instructions when
doing so allows their resources to be used more efficiently, while
ensuring that the program still produces the expected result.
Speculative execution allows a processor to anticipate the path a
program is likely to take and begin certain computations before knowing
whether they will actually be needed.
Modern processors also commonly contain multiple cores, each capable
of executing its own streams of instructions.
A modern computer is therefore a long way from the elementary
processor-memory-input/output diagram.
Yet at the software level, the fundamental idea remains: stored
instructions direct a general-purpose machine that manipulates data.
A program can itself become data
The stored-program principle has a particularly important consequence:
because a program is represented numerically in memory, one program
can manipulate another program.
A compiler, for example, can read source code and produce an executable
program.
An operating system can load a program from storage into memory.
An editor can modify a file containing code.
A program can even generate new instructions automatically.
The boundary between “program” and “data” therefore depends partly on
how the information is interpreted.
This property became essential to the development of operating systems,
compilers, programming languages, and the software industry more
broadly.
From specialized hardware to the universal machine
The stored-program concept contributed to a major transformation.
Instead of building a different machine for every problem, it became
possible to build a general-purpose machine and change its behavior
through software.
This idea has a strong conceptual connection with the work of Alan
Turing.
In 1936, several years before EDVAC, Turing described an abstract
machine capable of carrying out symbolically defined operations. He
notably showed that a universal machine could simulate many other
machines when given their descriptions.
The Turing machine is a mathematical
model, whereas von Neumann architecture concerns the practical
organization of electronic computers.
The two concepts should therefore not be confused.
Nevertheless, they belong to the same intellectual revolution: a
machine does not have to be built for a single task; its behavior can be
determined by the information it is given.
Why does von Neumann architecture still matter?
Today’s computers contain GPUs, multiple cores, complex cache
hierarchies, specialized controllers, artificial intelligence
accelerators, and many mechanisms that did not exist in the 1940s.
Calling a modern computer simply “a von Neumann machine” would therefore
be highly reductive.
But the model remains extremely useful.
It helps explain why a computer has memory and a processor, how a
program is executed, why data must move between different components,
and why memory speed affects performance.
It also represents a major stage in computing history: the point at
which a program became information that could be stored and modified
rather than merely a hardware configuration.
The idea seems so natural today that it is easy to forget how
significant it was.
Whenever we install an application, launch a game, load a web page, or
execute a few lines of code, we are still relying on this fundamental
property: the same machine can become something different simply
because we give it new instructions.
Key takeaways
Von Neumann architecture is not an exact blueprint for modern computers.
It is primarily a historical and conceptual model.
Its essential principles nevertheless remain fundamental:
a machine contains computation and control units;
it uses memory to store information;
program instructions can be stored in memory;
those instructions direct operations performed on data;
the same machine can therefore execute many different programs.
Its influence extends far beyond the classic diagram of a processor
connected to memory.
The stored-program concept helped turn the computer into a versatile
machine defined as much by its software as by its hardware.
Frequently asked questions
Did John von Neumann invent this architecture by himself?
No. Von Neumann played a major role in formalizing and disseminating the
concept, particularly through the 1945 First Draft of a Report on the
EDVAC. But the ideas associated with EDVAC emerged from collective work
involving, among others, J. Presper Eckert and John Mauchly.
What is the main idea behind von Neumann architecture?
The essential principle is the stored program: instructions can be
represented numerically and kept in memory, allowing the same machine to
execute different programs.
What is the difference between von Neumann and Harvard architecture?
In the classic von Neumann model, instructions and data share memory. In
a Harvard architecture, they use separate memories or paths. Many modern
processors use a hybrid organization.
What is the von Neumann bottleneck?
It is the performance limitation caused by communication between the
processor and memory. A very fast processor may still have to wait for
the instructions or data required for its calculations.
Do modern computers still use von Neumann architecture?
They retain several of its fundamental principles, especially the
stored-program concept, but use many additional optimizations such as
caches, pipelines, parallel execution, multiple cores, and sometimes
internal separation of instructions and data.
