WhatComputingIs

ENIAC, built between 1943 and 1945 at the University of Pennsylvania to calculate wartime artillery trajectory tables, was the first large-scale computer capable of running at electronic speed, with no mechanical parts slowing it down. By the standards of anything that came before it, it was extraordinary. By the standard this chapter is about to introduce, it was still missing something fundamental.

ENIAC had no way to store a program in memory. To make it solve a different problem, technicians physically reconfigured it, connecting patch cables between components and setting hundreds of switches by hand, one specific physical layout per computation. The Computer History Museum’s own account of the machine is direct about the cost of this: "Designing the correct configuration for each new problem, and then connecting the wires and setting the switches, took many days."

Read that sentence carefully, because it is the whole chapter in one line. Changing what ENIAC computed was not a software decision made in minutes, it was a physical rewiring project measured in days, performed by people who had to think through the entire computation as a literal wiring diagram before touching a single cable.

Computer History Museum, ENIAC, https://www.computerhistory.org/revolution/birth-of-the-computer/4/78.

The fix that made ENIAC-style reprogramming obsolete is called the stored-program concept: instead of representing a program as a physical arrangement of wires, represent it as data (the same kind of binary data the machine already stores and manipulates) and keep that data in the computer’s own memory, right alongside whatever numbers or text the program is meant to work on.

Once instructions are just data in memory, "changing the program" stops being a hardware task and becomes a data-loading task: load different binary values into memory, and the computer runs a different program, in the time it takes to read that memory rather than the time it takes to rewire a room full of equipment. This single idea is why a modern computer can run a word processor in the morning and a video game in the afternoon without anyone touching its internal wiring at all.

It is worth sitting with how strange this idea actually is, because familiarity has worn the strangeness off. A program that is stored as data can, in principle, be examined, copied, modified (even modify itself) using exactly the same operations the computer already uses to examine, copy and modify any other data. Instructions and data are not two different kinds of thing to a stored-program computer; they are the same kind of thing, distinguished only by how the processor currently happens to be interpreting them.

The architecture built around the stored-program concept (now called the von Neumann architecture, after mathematician John von Neumann, who described it in an influential 1945 report) organises a computer into a small number of cooperating parts: a central processing unit containing a control unit and an arithmetic logic unit, a memory shared between instructions and data, and input/output mechanisms connecting the machine to the outside world.

What those parts actually do, over and over, is called the fetch-decode-execute cycle. Fetch: the control unit reads the next instruction from memory, at the address held in a register called the program counter. Decode: the control unit interprets that instruction’s binary pattern to determine which operation it specifies. Execute: the arithmetic logic unit performs that operation, and the result is stored back to memory or sent to output.

Then the cycle repeats, continuously, for as long as the computer runs, which is a genuinely complete description of what is happening, at the lowest level, inside literally every general-purpose computer built on this architecture, from a 1950s mainframe to the device this course is being read on. Everything more complicated a computer does is this cycle, running an enormous number of times, on instructions and data that were themselves produced by earlier runs of the same cycle.

Von Neumann architecture and the fetch-decode-execute cycle, https://diveintosystems.org/book/C5-Arch/von.html.

Binary (a number system using only 0 and 1) is not an arbitrary choice made for convenience. It maps directly onto the two stable electrical states a digital circuit can reliably distinguish: a voltage that reads as "on" or "off," "high" or "low." A computer built to reliably distinguish ten different voltage levels for a decimal system would be far more sensitive to electrical noise than one built to distinguish just two, which is the practical, physical reason binary won out as the representation nearly every digital computer actually uses internally.

Because both instructions and data are ultimately stored as binary patterns in the same memory, the stored-program concept this chapter opened with becomes concrete: a sequence of 0s and 1s in memory might represent the number 12, the letter "A," or an instruction telling the processor to add two registers together, and which interpretation applies depends entirely on how the currently running program treats that particular memory location, not on anything intrinsic to the bits themselves.