← all systems · see it in The System
Stored-program principle (instructions held in the same memory as data)
A stored-program computer is a computer that reads the program instructions it is executing directly from fast electronic storage ... The definition is often extended with the requirement that the treatment of programs and data in memory be interchangeable or uniform.
Properties published scienceour proposal
Sourced fields, and our own readings.
| aliases | The stored-program computer |
| arrives | concept 1936 (Turing; Zuse's patent applications); first stored program run by the Manchester Baby, 21 June 1948 (ENIAC modified, 12 April 1948) |
| boundary | Inside: the generative rule (a program's instructions are words held in the same fast store as its data, read and written by the same mechanism, so programs can be read, written, copied and run by programs), its quanta (the stored instruction word and the instruction set it is written in) and its shell (restrictions on which stored words may be modified or executed: von Neumann's address-field-only overwrite, tagged descriptors, non-executable pages). Outside: the machines that carry it (the computer's organs, the memory devices), the code alphabet (binary or decimal), and everything it unpacks (programs, languages, compilers, operating systems, viruses, virtual machines, evolutionary computation). |
| nested level | A rule first written as mathematics (Turing 1936: the action table on the same tape as the data), run on machines from 1948 (ENIAC function tables 12 April; Manchester Baby 21 June). Built from the instruction word and the instruction set, with a shell. Embedded in the stored-program computer and its memory (mercury delay lines, Williams tubes), and SEED_WITHIN writing (the description is a written record that a reader acts on). Its words are usually binary (positional notation), but ENIAC's were decimal. |
| quantum | the program held as data in the same fast memory, so instructions are copyable, editable symbols (traced to the 1936 universal Turing machine) |
| scale | technological |
Measures (22) published science
| concept: universal machine with instructions on the data tape (Turing) | 1936-1937 date |
| instructions in data storage anticipated in two patent applications (Zuse) | 1936 year |
| Eckert and Mauchly write about the stored-program concept | December 1943 date |
| First Draft of a Report on the EDVAC | 1945 year |
| first electronic stored program run (Manchester Baby) | 21 June 1948 date |
| ENIAC first stored program run | 12 April 1948 (src:wp:stored-program-computer); demonstrated 16 September 1948 (src:wp:von-neumann-architecture) date |
| gap from concept to first run | about 12 (1936 to 1948) years |
| Baby store | 32 words of 32 bits (1,024 bits) |
| Baby instruction set | 7 operations in a 3-bit field (8 possible) |
| first program | 17 instructions, about 3.5 million operations, 52 minutes instructions / operations / minutes |
| characteristic clock: Baby memory access (read, write or refresh one word) | 360 microseconds |
| characteristic clock: Baby instruction execution rate | about 700 (an instruction takes four times a word access) instructions per second |
| characteristic clock: main-store refresh cycle | 20 milliseconds |
| Williams-tube charge lifetime before refresh | about 0.2 seconds |
| Williams tube capacity, autumn 1947 | 2,048 bits held for four hours bits / hours |
| ENIAC function-table program store | 3,600 decimal digits |
| time to set up and debug a program on ENIAC before the rule | three weeks time |
| first mass-produced stored-program machines (Bull Gamma 3, IBM 650) | about 1200 and 2000 units sold |
| smallest known standard universal Turing machine (Rogozhin 4-state 6-symbol) | 22 instructions |
| programming languages created | thousands (no exact figure in the source) languages |
| Genetic Programming Bibliography | more than 10,000 entries |
| characteristic clock: memory-protection hardening after a new attack class | Burroughs 5000 tags 1961; Exec Shield 2003; Linux NX August 2004 dates |
Cross-scale patterns seen here (7) our proposal
Shapes that recur when the same kind of problem is solved at different scales, and how each shows in Stored-program principle (instructions held in the same memory as data). Each links to every other system that shows it.
- outside-to-inside (structural)
The program moved from outside the machine into it: on punched tape 'physically fed into the system as needed' or in 'switches and patch cords', then read 'directly from fast electronic storage'. - same role, different builds (structural)
One description used two ways, executed and copied: von Neumann's tape is read by the constructor and copied by the copier, which 'parallels DNA translation' and 'DNA replication' and was proposed before DNA's structure was known; a quine is built the same way, 'code used to do the actual printing a - same toolkit, independent builds (structural)
The rule was struck separately: Turing (1936), Zuse's patent applications (1936), and Eckert and Mauchly (December 1943), who 'were not aware of Turing's work'. - seed (structural)
A few instruction types plus one rule (code is data) unpack every program: every binary string is some machine, and the rule makes 'programs that write programs' possible; 'Thousands of different programming languages have been created'. - who opens the door (structural)
Whether stored data can ever run as code is set ahead of time by the shell: the operating system marks pages, and an overflow attack works only where a region is 'both writable and executable'. - red-queen (partial)
Viruses and exploits against defences: 'Viruses use complex anti-detection/stealth strategies to evade antivirus software'; overflows met by NX, layout randomisation and canaries, and Cohen showed 'there is no algorithm that can perfectly detect all possible viruses'. - same shape, opposite sign (partial)
The door between description and action runs both ways here (data becomes code, executed code rewrites code), where the central dogma runs one way ('once "information" has passed into protein it cannot get out again'). The shell then pushes the rule back toward one way: von Neumann barred programs o
Valence: what it trades, and with whom (13) published science
Each exchange with a neighbour, read from both sides: who gains, who pays, and what carries it.
- Acoustic wave (sound: pressure waves in matter) via sys:acoustic-wave · Stored-program principle (instructions held in the same memory as data) gain
- Computer memory via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) gain
- Writing (the practice of marking language on a surface, and the script plus rules it works with) via sys:written-record · Stored-program principle (instructions held in the same memory as data) gain
- Memory protection (role: shell) via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) mixed
- Software via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) gain
- Williams-Kilburn tube (the first random-access store the rule ran on) via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) gain
- Mercury delay-line memory (programs stored as sound) via sys:acoustic-wave · Stored-program principle (instructions held in the same memory as data) gain
- Computer virus (a program that writes itself into other programs) via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) loss
- Harvard architecture (rival build: separate stores for instructions and data) via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) gain
- Positional (place-value) notation with zero via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) gain
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) gain
- Algorithm (the practice of step-by-step procedures and the structure they compute) via sys:electromagnetic-field · Stored-program principle (instructions held in the same memory as data) gain
- Turing machine: the abstract machine that reads and writes one symbol at a time on an unbounded tape by a finite table of rules, the model of computation of logic and computer science via sys:written-record · Stored-program principle (instructions held in the same memory as data) gain
Partners and parts published science
Built from / builds (6)
- Stored instruction word (role: quanta)
- Instruction set (role: quanta)
- Universal Turing machine (the rule's first statement)
- Memory protection (role: shell)
- Competition for new machine designs (stored program vs fixed-program and plugboard machines)
- Competition of memory pathways (one store for code and data vs separate stores)
Sits inside / holds (4)
- Writing (the practice of marking language on a surface, and the script plus rules it works with)
- Stored-program computer (the carrier machine)
- Computer memory
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
expressed by (15)
- Generation/Synthesis
- Recombination/Composition
- Scaffolding/Enablement (Meta-Tooling)
- Templating / Standardization
- Interoperability/Transduction (Bridging)
- Encapsulation & Modularity (Abstraction)
- Amplification/Scale-Up (Manufacture & Distribution)
- Evolvability/Plasticity Engineering (Design for Future Variation)
- Trail-Marking / Externalized Memory (Stigmergy)
- Social Learning / Public Information Use
- Physical/Virtual Barrier
- Self-Monitoring
- Validation of Identity/Intention
- Enclave/Segregation
- Quality Control & Error Correction
floor filled by (7)
- Computer memory
- Software
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
- Positional (place-value) notation with zero
- Large language model
- Computer
- Algorithm (the practice of step-by-step procedures and the structure they compute)
represents (1)
seed within (2)
- Writing (the practice of marking language on a surface, and the script plus rules it works with)
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
Kinds (2)
- Von Neumann architecture (one store, one path)
- Modified Harvard architecture (one store, split caches)
wired (1)
Notes published science
- Programs were once stored as sound. EDVAC and EDSAC held instructions as 'acoustic waves propagated through a mercury column', kept alive by an amplifier re-injecting each pulse. The memory was borrowed from radar, where the delay line's job was to forget: compare each echo with the last one and cancel whatever had not moved.
- Von Neumann worked out the genetic code's logic before DNA's structure was known. His self-reproducing machine reads its description to build and copies it to pass on, which 'parallels DNA translation' and replication. A quine is built the same way: code that prints, plus data that is the code's own text. RNA had already done both jobs in one molecule.
- The shell keeps re-growing the central dogma. The stored-program door runs both ways (data can become code), while DNA's runs one way ('once information has passed into protein it cannot get out again'). Von Neumann barred programs from overwriting themselves in 1945, the Burroughs 5000 forbade data to execute in 1961, and NX pages (2004) make memory writable or executable, never both. Each step closes the reverse door a little more.
Layers
The ways it takes in its world, where they meet, and how it acts back, each from L1 (where it meets the world) up.
acoustic delay line: bits as sound pulses recirculating in mercury
- L1: Sound in a liquid metal column: 'data was stored as a sequence of acoustic waves propagated through a mercury column'; glass, quartz, steel and lead were also tried
- L2: Restoration: 'an amplifier and a pulse shaper are connected between the output of the delay line and the input ... removing any degradation due to losses in the medium'
- L3: Words as timed places in the pulse train: 'The memory capacity equals the recirculation time divided by the time to transmit one bit'; Eckert, January 1944: 'store data and programs in a new addressable memory device, a mercury metal delay-line memory'
digital electronics: words in fast electronic store (instructions and data alike)
- L1: Charge on a cathode-ray tube face: 'A dash generated a positive charge, and a dot a negative charge ... a negative charge represented 0, and a positive charge 1'; later voltages in circuits
- L2: The bit read and refreshed: 'picked up by a detector plate in front of the screen'; 'The charge dissipated in about 0.2 seconds, but it could be automatically refreshed'
- L3: The stored word, instruction or datum alike: 'Each 32-bit word of RAM could contain either a program instruction or data'; bits 0-12 operand address, bits 13-15 operation
- L4: The program: 'a set of instructions (a program) that details the computation'; the first program was 17 instructions plus eight words of working storage
- L5: Fetch and execute: 'A central control unit to sequence operations performed by the machine'; a third tube held 'the current program instruction along with its address'; conditional skip and jumps
- L6: The shell and the tool floor: tagged descriptors (Burroughs 5000, 1961) and non-executable pages; 'assemblers, compilers, linkers, loaders, and other automated programming tools'
- L7: The field's stated purpose: 'It makes "programs that write programs" possible. This has made a sophisticated self-hosting computing ecosystem flourish'
mental representation: the human computer following instructions
- L1: The human computer's states of mind: Turing compared 'a human in the process of computing a real number to a machine that is only capable of a finite number of conditions', the m-configurations
- L5: Following written instructions: 'a person he called a "computer", who acted according to the instructions provided by a tape'
written record: the machine's description on tape and the program text
- L1: A tape of squares: 'a tape on which symbols could be read and written sequentially as the tape moved under a tape head'; before the rule, programs on 'punched tape, which was physically fed into the system'
- L2: Symbols: Turing 'used seven symbols { A, C, D, R, L, N, ; } to encode each 5-tuple'; 'every Turing machine can be encoded as a string over the alphabet {0, 1}'
- L3: The action table as a string on the same tape as the input: 'placing the "action table" -- the instructions for the machine -- in the same "memory" as the input data'
- L4: Whole machine descriptions: Penrose's U-machine code 'an enormous number that spans almost 2 full pages of 1's and 0's'; Rogozhin's (4, 6) machine 'uses only 22 instructions'
- L5: Program text translated by programs: Autocode for the Manchester Mark I (1952); 'In 1957, they completed a FORTRAN compiler'
Who fills each layer
- L1: Positional (place-value) notation with zero
- L2: Positional (place-value) notation with zero
- L3: Positional (place-value) notation with zero
- L4: Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
- L5: Positional (place-value) notation with zero
- L7: Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them