Introduction
Before the von Neumann model, early computers had their instructions wired into the hardware, so reprogramming meant physically rewiring the machine. Von Neumann architecture instead stores both program instructions and the data they operate on in the same read-write memory, and the CPU fetches instructions from that memory just as it fetches data. This single insight, that a program is just data that can be loaded, changed, and stored like any other data, is what makes general-purpose, reprogrammable computers possible.
Cricket analogy: Instead of a bowler being permanently wired to only ever bowl one delivery type, a modern captain reads the game plan from a shared playbook and changes the plan between overs, just as von Neumann machines read reprogrammable instructions from memory instead of fixed wiring.
Explanation
The classic von Neumann model consists of a CPU with an arithmetic logic unit and control unit, a single memory unit holding both instructions and data, and input/output mechanisms, all connected by a shared bus. Because instructions and data travel over that same shared bus and reside in the same memory space, the CPU cannot fetch an instruction and read or write a data operand at exactly the same instant; it must do them sequentially. This limitation is known as the von Neumann bottleneck, and it is one reason processor design has evolved techniques like caching, pipelining, and separate instruction and data caches, which give the appearance of parallel access without abandoning the underlying stored-program principle.
Cricket analogy: A ground with a single access tunnel for both players and equipment carts means only one can pass at a time, forcing sequential movement, similar to how a shared bus forces sequential instruction and data fetches in von Neumann machines, the so-called bottleneck.
A key consequence of storing programs as data is self-modifying and loadable code: an operating system can load an executable file from disk into memory, and the CPU treats that loaded region as instructions to execute, without any hardware reconfiguration. This is also why software can be updated simply by writing new bytes to memory or storage, and why malicious code exploiting memory corruption can sometimes trick a CPU into executing attacker-supplied bytes as instructions, which is why modern systems enforce protections such as marking memory pages non-executable unless explicitly needed.
Cricket analogy: Handing a substitute a new tactics sheet before they walk on lets them play a different role without changing the ground itself, just as loading new instructions into memory lets a CPU run different programs without hardware changes.
Example
# A tiny stored program: bytes that are both 'data' on disk and 'instructions' once loaded
# x86-64 machine code for: return 42
# b8 2a 00 00 00 mov eax, 42
# c3 ret
echo -n '\xb8\x2a\x00\x00\x00\xc3' > prog.bin
xxd prog.binKey Takeaways
- Instructions and data are stored in the same read-write memory and fetched over the same bus.
- This shared-bus design is called the von Neumann bottleneck, forcing sequential access.
- Caching, pipelining, and separate instruction/data caches mitigate the bottleneck without abandoning the model.
- Because programs are stored as data, software can be loaded, modified, and updated without hardware changes.
- The same self-modifying property is why non-executable memory protections exist to prevent code injection attacks.
Practice what you learned
1. What defining feature separates von Neumann architecture from earlier fixed-wiring machines?
2. What is the 'von Neumann bottleneck'?
3. What technique helps reduce the practical impact of the von Neumann bottleneck?
4. Why can software updates be applied without rewiring hardware in a von Neumann machine?
Was this page helpful?
You May Also Like
Registers Explained
The small, extremely fast storage locations built directly into the CPU that hold data and addresses the processor is actively working with.
Buses & Ports
How internal buses move data, address, and control signals between CPU, memory, and devices, and how external ports expose those pathways to peripherals.
Computer Generations
The five generations of computing hardware, from vacuum tubes through transistors, integrated circuits, microprocessors, and AI-driven systems.