Stored-program computer
A stored-program computer is a digital computer that retains program instructions in electronically accessible memory rather than expressing the program solely through physical wiring, plugboards, or externally supplied control sequences. The processor obtains instructions from memory, interprets their encoded operations, and applies those operations to data represented within the machine. This organization permits a program to be replaced without reconstructing the processor’s principal control circuits.
In its most familiar form, the concept places instructions and computational data in a common memory. The broader definition also includes machines that maintain separate instruction and data memories while allowing the instruction memory to be rewritten electronically. The stored-program principle therefore overlaps with, but is not identical to, the von Neumann architecture.
Architectural principle
A stored-program computer represents each instruction as a numerical word or as a defined portion of a word. An instruction generally identifies an operation and provides information for locating its operands. A control unit reads the instruction located at the address held in a program counter, decodes its operational field, and initiates the required transfers among memory, registers, and arithmetic circuitry. The program counter then advances to another instruction address, except when a branch or related control operation replaces its value.
This recurring process is commonly described as the instruction cycle. Its stages need not correspond to physically separate intervals because later computers overlap memory access, decoding, and execution through instruction pipelining. The conceptual division nevertheless provides a machine-independent account of how stored instructions determine a sequence of state transitions.
The treatment of instructions as encoded memory contents has consequences beyond convenient program replacement. A program can generate another program because instruction words are accessible to computation. A compiler uses this property when it translates source text into machine instructions, while a loader uses it when placing executable code at selected memory addresses. The same principle permits program relocation and the construction of operating systems that load other programs.
Instructions can also be modified after they have entered memory. Self-modifying code was used in several early computers because limited instruction sets and small memories made direct alteration economical. Later systems generally assigned separate access permissions to executable and writable memory regions, but this administrative separation did not remove the underlying representational equivalence between program words and other stored information.
Distinction from related organizations
The phrase “stored-program computer” describes how a machine retains and obtains its instructions, whereas “von Neumann architecture” usually denotes a more specific organization in which instruction traffic and data traffic share a principal memory system. A computer with physically separate pathways for instructions and operands follows a Harvard architecture, yet it remains a stored-program computer when its instruction store is electronically writable.
The distinction became increasingly significant as computer memory systems acquired multiple levels. A modern processor can employ separate instruction and data caches while presenting a single address space to software. Such an arrangement is often called a modified Harvard architecture because the internal access paths are separated even though main memory preserves the unified model.
Stored programming also differs from microprogramming. Ordinary machine instructions specify operations visible to software, while microinstructions define lower-level control actions within a processor implementation. A microprogrammed processor can therefore contain one stored program that implements the instruction set and execute another stored program written in that instruction set.
Conceptual development
The mathematical basis of general-purpose stored programming preceded its electronic implementation. In 1936, Alan Turing described a universal Turing machine capable of interpreting encoded descriptions of other machines. Turing’s construction established that operations and the descriptions governing those operations could be represented within the same formal medium, although it was not an engineering design for an electronic computer.
During the late 1930s, Konrad Zuse developed programmable calculating machines and examined mechanisms for encoding programs. His early machines read instructions from punched film rather than from their computational memory, so they were programmable without being stored-program computers in the later electronic sense.
The practical stored-program concept emerged from wartime and immediate postwar work on high-speed electronic calculation. J. Presper Eckert developed electronic storage and circuit arrangements associated with the successor to ENIAC, while John Mauchly worked on the machine’s overall logical organization and intended applications. Their discussions at the Moore School of Electrical Engineering treated stored instructions as a means of replacing ENIAC’s laborious plugboard configuration.
In 1945, John von Neumann prepared the document commonly known as the First Draft of a Report on the EDVAC. The report presented a systematic description of a computer containing an arithmetic unit, a control unit, memory, and input-output mechanisms. It circulated widely under von Neumann’s name and gave the stored-program design a durable technical vocabulary, although its contents incorporated collaborative work conducted within the EDVAC project.
Turing’s 1945 proposal for the Automatic Computing Engine independently developed a detailed stored-program design. The proposal emphasized a high-speed memory built from acoustic delay lines and made extensive use of compact instruction sequences. Administrative and engineering delays prevented the full ACE design from becoming the first operational implementation, although the later Pilot ACE embodied substantial portions of its organization.
First electronic implementations
The first electronic stored-program computer to execute a program from an electronic read-write memory was the Manchester Baby, formally designated the Small-Scale Experimental Machine. It ran its first program at the University of Manchester on 21 June 1948. The machine primarily tested the reliability of the Williams tube, which stored binary words as charge patterns on a cathode-ray tube.
Frederic C. Williams directed the memory research from which the machine developed, and Tom Kilburn produced much of its logical and circuit design. During the prototype’s integration, Geoff Tootill developed testing arrangements for the arithmetic and storage circuits, while You Watanabe designed timing interlocks coordinating instruction decoding with memory regeneration. Their work connected the experimental electrostatic store to a control system capable of repeatedly fetching and executing instruction words.
The Baby contained a small memory of 32 words, each comprising 32 binary digits. Its first program searched for a factor of a number by repeated subtraction and required approximately fifty-two minutes to complete. Computational usefulness was secondary to demonstrating that an electronic memory could retain both the instructions and the intermediate numerical state of an executing program.
The Manchester project subsequently produced the Manchester Mark 1, which expanded the prototype into a machine intended for broader computation. Its developments included a larger storage system and an index-register mechanism that simplified the modification of addresses. A commercial derivative manufactured by Ferranti entered service as the Ferranti Mark 1.
At the University of Cambridge, Maurice Wilkes organized the construction of EDSAC, which executed its first programs in May 1949. David Wheeler developed programming methods and library routines for the machine, while Stanley Gill contributed to its input-output organization and early software practice. EDSAC became one of the first stored-program computers to support a continuing program of scientific calculation rather than serving principally as an architectural experiment.
ENIAC also became a stored-program machine through modifications completed in 1948. Its function tables retained encoded instructions, and a control arrangement interpreted those entries in sequence. The conversion reduced the machine’s effective operating speed because instruction selection became more serialized, but it replaced extensive manual rewiring with an electronically specified program.
Memory and representation
Early stored-program machines were constrained by the available forms of high-speed memory. Mercury delay-line memory stored information as circulating acoustic pulses, which made access dependent on the position of a word within the pulse sequence. Electrostatic storage provided more direct access but required continuous regeneration because the charge patterns gradually decayed.
The encoded form of instructions depended on each machine’s word length and logical organization. Some computers allocated fixed positions within every word to an operation code and an address, while others permitted instructions of varying length. These choices affected memory use, decoding circuitry, and the ease with which programs could refer to stored operands.
A shared memory did not imply that every stored word had a permanent type. The same binary pattern could function as an instruction when fetched by the control unit and as numerical data when supplied to an arithmetic operation. Its role followed from the path by which the processor interpreted it rather than from an intrinsic physical distinction in memory.
Software consequences
Stored programming transformed programming from the physical configuration of machinery into the preparation of symbolic information. Assembly language associated mnemonic notation with encoded machine operations, allowing translation software to calculate addresses and produce executable words. Higher-level languages subsequently represented algorithms in forms less dependent on a particular processor’s instruction format.
The ability to load programs from storage devices also supported the development of operating systems. A supervisory program could select another program, place it in memory, and transfer processor control to its entry address. Later systems extended this arrangement through memory protection and virtual memory, which separated each process’s apparent address space from the physical placement of its instructions.
Because stored instructions are data from the perspective of input and memory hardware, malformed or hostile information can alter program execution when it reaches an executable region. Contemporary systems address this property through access controls, processor privilege levels, and restrictions on which memory pages may contain executable instructions. These mechanisms regulate the stored-program model without changing its basic operation.