Stored-Program Computer

A stored-program computer is a machine that keeps its instructions in the same modifiable electronic memory as its data, so that changing what the machine does means changing the contents of memory rather than moving cables or setting switches. The idea sounds obvious now, but it separates the general-purpose computer from the calculating machine: a program becomes just another body of numbers that can be loaded, copied, edited, and even generated by other programs. Every phone, laptop and data-center server is a descendant of this arrangement, and the entire software industry, from assemblers to compilers to operating systems, exists because instructions are data.

The idea entered the public record through the "First Draft of a Report on the EDVAC," a document dated 30 June 1945 and circulated from the Moore School of the University of Pennsylvania, which set out the logical design of a machine holding both numbers and orders in one memory. The text carried only John von Neumann's name, who had been consulting on the EDVAC project with the ENIAC team of J. Presper Eckert, John Mauchly, Herman Goldstine and others, and Goldstine distributed it widely. It described a central arithmetic unit, a control unit, a memory, and input and output, and it borrowed a notation from the neuron networks of McCulloch and Pitts to describe its logical elements. The authorship question has been contested ever since, and it is treated in the entry on von Neumann architecture; what matters here is that the report turned a set of project discussions into a portable blueprint that laboratories on both sides of the Atlantic could build from. Alan Turing's separate 1945 design report for the ACE at Britain's National Physical Laboratory reached a similar conclusion by a different route, and his 1936 universal machine had already shown, on paper, that one fixed mechanism can run any program supplied as data.

ENIAC, the machine that made the contrast necessary, was programmed by rewiring. Completed at the Moore School and publicly announced in February 1946, it was an electronic marvel for numerical work such as artillery tables, but setting up a new problem meant plugging cables and setting switches on its function units, a job that took days and was done largely by a small group of women programmers, among them Kay McNulty, Jean Jennings Bartik and Betty Snyder Holberton. The electronics ran in thousandths of a second while the reconfiguration ran in days, so the bottleneck was the human act of changing the program. In 1948 ENIAC was itself modified so that it could run sequences of instructions read from its function-table switches, a retrofit that traded some speed for far faster setup and is often described as turning it into a stored-program machine of a restricted kind.

The first working demonstrations came from Britain, not from the machine named in the report. On 21 June 1948 the Small-Scale Experimental Machine at the University of Manchester, soon nicknamed the Baby, ran its first program: a search by Tom Kilburn for the highest proper factor of 2^18, which took about 52 minutes. The machine, designed by Frederic C. Williams, Kilburn and Geoff Tootill, held 32 words of 32 bits in a Williams–Kilburn cathode-ray-tube store, which was the first random-access electronic memory, and it was built as a test bed for that memory rather than as a practical computer. At Cambridge, Maurice Wilkes's EDSAC, using mercury delay lines, ran its first programs in May 1949 and soon provided a real service to university researchers, along with a subroutine library developed by Wilkes, David Wheeler and Stanley Gill. Wheeler's work on subroutines is an early example of the stored program paying off: code written once and reused as data-like building blocks.

The conceptual gain was that a machine could operate on its own instructions, which brought both enormous power and a standing risk. Address modification, loading a program from tape into memory, assemblers that translate symbols into numbers, and later compilers, interpreters and just-in-time translators all rely on treating code as something a program can read and write. The same property is the root of a whole family of security problems: if an attacker can get bytes written into memory that the processor will later treat as instructions, as in buffer-overflow exploits, the machine will faithfully execute them. Modern systems answer with memory protections that mark regions as writable or executable but not both, a partial restoration of the separation the original design collapsed.

A common misconception is that the stored-program idea is the same thing as the computer, or that it was a single inventor's flash of insight. Earlier machines such as the Harvard Mark I, the Zuse Z3 and ENIAC were programmable and in some cases quite capable, but did not hold their programs in a rewritable memory; and the idea was assembled from Turing's theory, the Moore School discussions and the practical constraint that fast electronic computation made manual setup intolerable. Another pitfall is to equate the Baby with the first useful computer: it was deliberately small, and its significance was proving that the memory and the principle worked. Today the idea is so pervasive that it is easy to miss in AI work, where a model's weights, the code that runs it and the prompts that steer it all live in the same kind of memory and are all, at the lowest level, data.

Read the stored-program computer as the moment computation became editable: once the instructions sit in memory beside the numbers, a general machine is made specific by software alone, and every later layer of programming, including the training and serving of AI models, inherits that move.