Hubbry Logo
Stored-program computerStored-program computerMain
Open search
Stored-program computer
Community hub
Stored-program computer
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Stored-program computer
Stored-program computer
Stored-program computer
View on Wikipedia
from Wikipedia

A stored-program computer is a computer that stores program instructions in electronically, electromagnetically, or optically accessible memory.[1] This contrasts with systems that stored the program instructions with plugboards or similar mechanisms.

The definition is often extended with the requirement that the treatment of programs and data in memory be interchangeable or uniform.[2][3][4]

Description

[edit]

In principle, stored-program computers have been designed with various architectural characteristics. A computer with a von Neumann architecture stores program data and instruction data in the same memory, while a computer with a Harvard architecture has separate memories for storing program and data.[5][6] However, the term stored-program computer is sometimes used as a synonym for the von Neumann architecture.[7][8] Jack Copeland considers that it is "historically inappropriate, to refer to electronic stored-program digital computers as 'von Neumann machines'".[9] Hennessy and Patterson wrote that the early Harvard machines were regarded as "reactionary by the advocates of stored-program computers".[10]

History

[edit]

The concept of the stored-program computer can be traced back to the 1936 theoretical concept of a universal Turing machine.[11] Von Neumann was aware of this paper, and he impressed it on his collaborators.[12]

Many early computers, such as the Atanasoff–Berry computer, were not reprogrammable. They executed a single hardwired program. As there were no program instructions, no program storage was necessary. Other computers, though programmable, stored their programs on punched tape, which was physically fed into the system as needed, as was the case for the Zuse Z3 and the Harvard Mark I, or were only programmable by physical manipulation of switches and plugs, as was the case for the Colossus computer.

In 1936, Konrad Zuse anticipated in two patent applications that machine instructions could be stored in the same storage used for data.[13]

In 1948, the Manchester Baby, built at University of Manchester,[14] is generally recognized as world's first electronic computer that ran a stored program—an event on 21 June 1948.[15][16] However the Baby was not regarded as a full-fledged computer, but more a proof of concept predecessor to the Manchester Mark 1 computer, which was first put to research work in April 1949. On 6 May 1949 the EDSAC in Cambridge ran its first program, making it another electronic digital stored-program computer.[17] It is sometimes claimed that the IBM SSEC, operational in January 1948, was the first stored-program computer;[18] this claim is controversial, not least because of the hierarchical memory system of the SSEC, and because some aspects of its operations, like access to relays or tape drives, were determined by plugging.[19] The first stored-program computer to be built in continental Europe was the MESM, completed in the Soviet Union in 1950.[20]

The first stored-program computers

[edit]

Several computers could be considered the first stored-program computer, depending on the criteria.[3]

  • IBM SSEC, was designed in late 1944 and became operational in January 1948 but was electromechanical[21]
  • In April 1948, modifications were completed to ENIAC to function as a stored-program computer, with the program stored by setting dials in its function tables, which could store 3,600 decimal digits for instructions. It ran its first stored program on 12 April 1948 and its first production program on 17 April[22][23] This claim is disputed by some computer historians.[24]
  • ARC2, a relay machine developed by Andrew Booth and Kathleen Booth at Birkbeck, University of London, officially came online on 12 May 1948.[25] It featured the first rotating drum storage device.[26][27]
  • Manchester Baby, a developmental, fully electronic computer that successfully ran a stored program on 21 June 1948. It was subsequently developed into the Manchester Mark 1, which ran its first program in early April 1949.
  • Electronic Delay Storage Automatic Calculator, EDSAC, which ran its first programs on 6 May 1949, and became a full-scale operational computer that served a user community beyond its developers.
  • EDVAC, conceived in June 1945 in First Draft of a Report on the EDVAC, but not delivered until August 1949. It began actual operation (on a limited basis) in 1951.
  • BINAC, delivered to a customer on 22 August 1949. It worked at the factory but there is disagreement about whether or not it worked satisfactorily after being delivered. If it had been finished at the projected time, it would have been the first stored-program computer in the world. It was the first stored-program computer in the U.S.[28]
  • In 1951, the Ferranti Mark 1, a cleaned-up version of the Manchester Mark 1, became the first commercially available electronic digital computer.
  • The Bull Gamma 3 (1952) and IBM 650 (1953) were the first mass produced commercial computers, respectively selling about 1200 and 2000 units.
  • Manchester University Transistor Computer, is generally regarded as the first transistor-based stored-program computer having become operational in November 1953.[29][30]

Telecommunication

[edit]

The concept of using a stored-program computer for switching of telecommunication circuits is called stored program control (SPC). It was instrumental to the development of the first electronic switching systems by American Telephone and Telegraph (AT&T) in the Bell System,[31] a development that started in earnest by c. 1954 with initial concept designs by Erna Schneider Hoover at Bell Labs. The first of such systems was installed on a trial basis in Morris, Illinois in 1960.[32] The storage medium for the program instructions was the flying-spot store, a photographic plate read by an optical scanner that had a speed of about one microsecond access time.[33] For temporary data, the system used a barrier-grid electrostatic storage tube.

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Stored-program computer

View on Grokipedia
from Grokipedia
A stored-program computer is a digital computer architecture in which both instructions (the program) and data are stored in the same modifiable memory, enabling the machine to treat programs as data that can be altered during operation, a foundational concept for modern computing. This design, often associated with the , contrasts with earlier program-controlled machines where instructions were fixed via wiring or plugs, limiting flexibility. The concept was theoretically outlined by in his 1936 description of the universal , but it gained practical prominence through John von Neumann's 1945 report, First Draft of a Report on the , which proposed storing programs in electronic memory for the project. The first working stored-program electronic digital computer was the Manchester Small-Scale Experimental Machine (SSEM), known as the "Baby," which successfully executed its initial program on June 21, 1948, at the , using Williams-Kilburn tube memory. Subsequent implementations, such as the in 1949 at the , demonstrated practical utility by running useful programs for scientific computation, solidifying the architecture's role in enabling , compilers, and the evolution of general-purpose computing.

Core Concepts

Definition and Principles

A stored-program computer is a type of machine in which both program instructions and are stored in the same addressable unit, allowing the to access and manipulate instructions in the same manner as . This design enables instructions to be treated as modifiable , facilitating dynamic program alteration during execution. The serves as a primary embodiment of this principle, emphasizing the unified storage of code and . The core operational principles revolve around the separation of hardware functionality from software, where the hardware executes instructions stored in without inherent task-specific wiring. Central to this is the fetch-execute cycle, in which the retrieves an instruction from using an instruction pointer or , decodes it, and carries out the operation before incrementing the pointer for the next instruction. This cycle allows for simply by loading new instructions into , eliminating the need for physical hardware reconfiguration to change tasks. This architecture underpins computational universality, enabling the stored-program computer to simulate any other computing device or perform arbitrary computable functions, provided sufficient memory is available—a property conceptually aligned with . By representing instructions as , the can implement loops, conditionals, and recursive procedures, mirroring the capabilities of a . Key components include the (CPU), which encompasses the (ALU) for computations, registers for temporary , and the instruction pointer; the unit, which holds both instructions and data in addressable locations; and the , a that orchestrates the fetch-execute cycle by generating signals to coordinate operations across the CPU and memory.

Distinction from Other Architectures

Fixed-program computers, such as mechanical calculators and early electromechanical devices, operate with instructions that are hardwired into the machine's circuitry or configured via physical means like plugs, switches, or punched tapes. For instance, the (1944), an electromechanical calculator developed by Howard Aiken and , relied on punched paper tapes for instruction sequences and plugboards for wiring connections, making it inherently limited to predefined tasks without modifiable program storage. This design restricts flexibility, as altering the machine's behavior requires manual reconfiguration of hardware components, often involving extensive rewiring or replacement of tapes, which is time-consuming and error-prone. In contrast, stored-program computers treat instructions as data stored in the same modifiable memory, enabling dynamic changes to the program without hardware intervention. This allows for , where programs can alter their own instructions during execution, and facilitates easier debugging and adaptation by simply loading new instruction sets into memory. Fixed-program systems, however, demand physical rewiring or redesign for any functional changes, prohibiting such runtime modifications and tying the machine's capabilities to its initial engineering. The exemplifies an alternative design with physically separate memory spaces and pathways for instructions and data, which in its pure form—as seen in the —does not support stored programs since instructions reside in non-modifiable storage like tapes rather than shared, alterable memory. The , foundational to stored-program computers, employs a unified memory for both, allowing seamless access but introducing the von Neumann bottleneck, where the shared bus limits concurrent instruction fetching and data operations, potentially constraining performance as processing speeds increase. While Harvard designs avoid this bottleneck through parallel access paths, they increase hardware complexity and cost compared to the simpler unified approach. Stored-program architectures offer key advantages in and generality, as programs can be distributed and executed as binary files across compatible machines without hardware alterations, promoting widespread reusability and rapid iteration. This shifts development costs from expensive physical reconfigurations to more efficient software modifications, enabling broader applicability in diverse computational tasks.

Historical Development

Precursors and Theoretical Foundations

The , conceived by in the 1830s, represented an early conceptual precursor to programmable computing, though it was never constructed during his lifetime. Babbage's design incorporated punched cards— inspired by the Jacquard loom—for inputting both data and operation sequences, allowing the machine to perform a variety of calculations under user-defined instructions rather than fixed mechanical paths. This separation of from hardware wiring laid foundational ideas for flexibility in computation, even as programs were externally supplied via cards rather than stored internally. In the early , Konrad Zuse advanced programmable machines with the Z3, a relay-based digital computer completed in 1941, which executed instructions read from in a sequential manner. Unlike earlier fixed-wiring calculators, the Z3 featured a program interpretation unit that processed binary instructions for arithmetic operations, including floating-point calculations, enabling it to solve complex problems like differential equations. However, its programs were not stored in modifiable memory but fed externally without support for conditional jumps, limiting it to linear execution and distinguishing it from fully stored-program systems. Alan Turing's 1936 paper, "On Computable Numbers, with an Application to the Entscheidungsproblem," provided a rigorous theoretical foundation by introducing the universal Turing machine, a hypothetical device capable of simulating any other Turing machine given a description of its rules encoded on an infinite tape. This model demonstrated that a single machine could read and execute arbitrary instructions from its tape—functioning as both memory and program storage—proving the universality of computation and paving the way for machines where software and data shared the same medium. As Turing described, "It is possible to invent a single machine which can be used to compute any computable sequence," with the tape holding the "standard description" of the target machine's behavior. John von Neumann's 1945 "First Draft of a Report on the " formalized the stored-program principle for electronic computers, proposing that instructions and data be encoded in and stored interchangeably in high-speed , allowing programs to be modified during execution. Drawing on Turing's universality, von Neumann outlined a that fetched and decoded instructions from , enabling efficient reprogramming without hardware alterations—a key evolution from tape or card-based inputs. This architecture emphasized the equivalence of instructions and data, stating that "the logical control [would] be so entirely disconnected from the specific arithmetic processes that, with suitable instructions, any of the arithmetic organs can be used for any type of arithmetic process."

First Practical Implementations

The , officially known as the Small-Scale Experimental Machine (SSEM), was the world's first electronic stored-program computer to successfully execute a program from its electronic memory. Built by Frederic C. Williams, Tom Kilburn, and at the , it ran its inaugural program on June 21, 1948, which involved finding the highest proper factor of the number 2^{18} (262144) by trial division, testing every integer downwards from 2^{18} - 1 until a was found. This demonstration proved the viability of storing both data and instructions in the same modifiable electronic memory, a key departure from earlier machines like that required physical reconfiguration for reprogramming. The Baby's design centered on a single Williams-Kilburn tube for , capable of storing 1,024 bits organized as 32 words of 32 bits each. Instructions were 32-bit words, featuring a simple format with 3 bits for the and 13 bits for addressing, enabling basic operations like , , and conditional jumps across its limited 32-word store. Though not intended for practical , the machine's success validated the Williams-Kilburn tube's reliability for electronic program storage, paving the way for larger systems. Following the Baby, the Electronic Delay Storage Automatic Calculator (EDSAC) emerged as the first practical general-purpose stored-program computer, operational at the under . Completed in 1949 and running its first program on May 6 of that year, EDSAC performed scientific calculations such as generating tables of squares and primes, marking the transition from experimental prototypes to usable tools for . Its design incorporated initially 512 words of mercury (later upgraded to 1024 words in 1952) and subroutines for , enabling efficient handling of complex numerical tasks in fields like physics and . Concurrent developments included the , completed in 1949 by and for the Northrop Aircraft Company, which became the first operational stored-program computer in the United States with dual processors and for input. In parallel, the Soviet Union's MESM (Small Electronic Calculating Machine), developed by Sergei Lebedev and completed in 1950, represented an independent effort as the first stored-program electronic computer in , used initially for rocketry and nuclear research calculations. These implementations overcame significant challenges from prior designs like , which lacked stored programs and relied on manual wiring and switches for reconfiguration, making reprogramming time-consuming and error-prone. The shift required innovations in reliable, random-access electronic memory—such as the and delay lines—to enable instructions and data to coexist dynamically, inspired by John von Neumann's 1945 report outlining the stored-program architecture. This evolution addressed ENIAC's limitations in flexibility, allowing machines like the Baby and to execute programs electronically without hardware alterations.

Expansion and Commercialization

The transition from experimental prototypes to commercial viability marked a pivotal phase in the development of stored-program computers during the early 1950s. Building on foundational systems like the , which became operational in as the first practical general-purpose stored-program electronic computer, manufacturers began producing machines for sale to government and private entities. This shift enabled broader application beyond academic and military research, with companies investing in scalable designs that emphasized reliability and efficiency. A landmark in this expansion was the , developed by Eckert and Mauchly and completed by after acquiring their company in 1950. Delivered to the U.S. Census Bureau on March 31, 1951, it was the first commercial stored-program computer placed into production, featuring drives for input and output to handle large datasets efficiently. The system, which used 5,200 vacuum tubes and weighed 29,000 pounds, was sold for over $1 million per unit, with 46 ultimately delivered to customers including utilities, insurance firms, and the U.S. military. entered the market the following year with the 701 Defense Calculator, its first production stored-program computer targeted at scientific computing. Announced in 1952, the 701 incorporated punched-card readers and punches for data handling, marking IBM's significant corporate commitment to the technology and resulting in 19 units rented primarily to national laboratories, the Weather Bureau, and defense contractors. The commercialization extended globally, with the producing early examples based on academic designs. The , a refined commercial version of the , was delivered to the in February 1951 as the world's first commercially available general-purpose stored-program computer; nine units were sold between 1951 and 1957, including exports to , the , and . Similarly, LEO I, developed by J. Lyons & Co. and inspired by the , ran its first business application—a bakery valuation program—on November 17, 1951, establishing it as the first stored-program computer dedicated to commercial processes like production scheduling. By the late 1950s, advancements incorporated transistors for improved performance, as seen in the 7090, announced in 1958 and deployed starting in 1959 as the company's first commercial transistorized stored-program system, offering six times the speed of its vacuum-tube predecessor for scientific and administrative tasks. Stored-program computers saw rapid adoption across defense, scientific, and business sectors in the 1950s, driven by their versatility in handling diverse workloads without hardware rewiring. In defense, systems like the supported calculations for national laboratories and military applications, while aided census and intelligence processing for the U.S. government. Scientific use expanded through machines like the 701 for engineering simulations at aircraft manufacturers and weather agencies, and business applications emerged with LEO I automating clerical tasks at Lyons and UNIVAC deployments in insurance and utilities. The inherent flexibility of stored-program architectures—allowing software modifications to adapt to new needs—facilitated iterative improvements, contributing to reductions in physical size, power consumption, and overall costs as integration progressed in the decade. This flexibility extended to telecommunications by the mid-1960s, where stored-program control revolutionized switching systems. Bell Labs introduced the No. 1 Electronic Switching System (1ESS) in Succasunna, , on May 30, 1965, as the first large-scale stored-program-controlled , replacing electromechanical relays with a computer directing call routing via programmable instructions. Capable of handling up to 80,000 calls per hour and supporting features like , the 1ESS used 731,000 bytes of program memory and marked a shift toward software-defined networks in .

Technical Aspects

Memory and Instruction Storage

In the stored-program computer architecture, instructions and are stored in a unified space, allowing the same hardware to access both without distinction between program code and operands. This model treats as a linear of addressable locations, where each location holds a fixed-size word—typically 32 or 40 bits in early designs—that encodes both instructions and in . An instruction word generally consists of an (a few bits specifying the operation, such as or branching) followed by fields (bits indicating addresses or immediate values), enabling programs to be loaded, modified, and executed dynamically from the same storage as variables and constants. Early implementations relied on innovative but limited storage technologies to realize this unified model. The Manchester Baby (1948), the first functional stored-program computer, used Williams tube memory—cathode-ray tubes storing bits as electrostatic charges on the screen's phosphor coating, refreshed periodically to prevent decay. This provided random access to 32 words of 32 bits each (1,024 bits total, equivalent to 128 bytes), sufficient for simple programs but prone to interference from nearby tubes. Similarly, the EDSAC (1949) employed mercury delay-line memory, where ultrasonic pulses circulated in tubes of liquid mercury to represent bits serially, offering non-random access but higher density; its 32 delay lines stored 512 words of 35 bits (approximately 17.9 kilobits). Advancements in the shifted toward more reliable and faster media. Magnetic , introduced around 1950 in machines like the ERA 1103, used a rotating cylinder coated with ferromagnetic material to store bits magnetically, providing with capacities up to several kilobytes and serving as auxiliary storage for instructions in some designs. By mid-decade, magnetic core memory—tiny ferrite rings wired in a grid, magnetized to represent bits—became dominant, offering true with access times under 1 microsecond; it was employed in systems like the series from the late 1950s, with initial capacities of 1,000 to 12,000 words (approximately 36 to 432 kilobits for 36-bit words). This technology persisted into the 1970s until the advent of RAM, exemplified by Intel's 1103 DRAM chip (1970), which packed 1,024 bits per chip using MOS transistors for volatile storage, enabling rapid scaling to megabyte-level main memories in commercial machines. Memory addressing in these systems evolved from basic absolute schemes, where operands directly specified fixed locations in the unified space, to relative addressing for modularity, particularly in larger programs. In the , absolute addressing used the full 5-bit address field (supporting 32 locations) to reference any word for instructions or . Capacities started small—hundreds to thousands of bits in prototypes like the Baby and —but grew exponentially; by the 1960s, core-based systems routinely offered 64 to 256 kilobits, reaching scales with integration by the mid-1970s, vastly expanding programmable complexity. The unified storage of instructions and data introduced inherent security risks, as programs could inadvertently or maliciously overwrite code via address errors, akin to conceptual buffer overflows where data spills into instruction space. Early designers recognized this vulnerability in the von Neumann model, where modifiable instructions enabled self-altering code but risked system instability from erroneous writes. This shared access also contributed to the von Neumann bottleneck, limiting throughput as the processor serially fetched both code and data over a single bus.

Programming and Execution

In stored-program computers, instructions typically consist of an (opcode) specifying the desired action and one or more fields indicating the locations of or results in . For example, in the , the world's first operational stored-program computer completed in , each 32-bit instruction included a 5-bit field for the (, supporting up to 32 storage lines), a 3-bit function for the (enabling eight possible operations such as or storage), and additional bits for control or sign, with unused bits ignored by the decoder. Addressing modes in these early systems were limited but essential for flexibility; common modes included immediate (where the operand value is embedded directly in the instruction, though rare in initial designs), (using the field to access directly), and indirect (where the field points to a location containing the effective , often used in jump instructions like the Baby's JMP, which loaded an indirect into the ). These formats allowed instructions to treat uniformly for and , enabling dynamic program behavior. The execution of programs follows the fetch-execute cycle, orchestrated by the to process instructions sequentially from . In the first step, the fetches the instruction at the address stored in the (PC), incrementing the PC to point to the next instruction; this mirrors the design outlined in John von Neumann's 1945 report, where the central arithmetic part and coordinate to retrieve binary-coded orders from a buffer. The fetched instruction is then decoded to identify the and operands, determining the operation (e.g., or branching) and resolving addresses via the specified mode. Execution performs the operation, such as adding values from to the accumulator or storing results back to , with any updates to registers or the PC occurring as needed; finally, results are written if required, and the cycle repeats. This iterative process, with instruction execution times of about 1.2 milliseconds (approximately 800 ) in the , enabled automatic computation without manual reconfiguration, distinguishing stored-program systems from prior wired-program machines. Early programming for stored-program computers relied on low-level assembly languages, where human-readable mnemonics were translated into machine code via rudimentary assemblers or loaders. In the EDSAC (1949), programmers wrote code using symbolic opcodes (e.g., "A" for add to accumulator, "S" for subtract) on paper, converting them to 17-bit binary instructions (5-bit opcode, 10-bit address, 1-bit long/short modifier) punched onto paper tape; the machine's "initial orders"—a fixed 31-instruction bootstrap loader stored in the first 32 memory words—automatically assembled and loaded the program by scanning the tape, substituting symbols for binary values, and placing instructions in memory starting at word 32. This sub-routine library approach, detailed by Maurice Wilkes, minimized manual binary coding errors and supported reusable code blocks for common tasks like square roots, marking an early step toward systematic software development. A key feature of these systems was self-modification, where programs could alter their own instructions in to adapt during runtime, exploiting the uniformity of and . For instance, in programs, a loop might modify the field of a subsequent instruction to increment a pointer, as in vector arithmetic where an add instruction's is updated mid-execution to process elements sequentially without redundant jumps, saving precious in the 1K-word limit. This technique, while efficient for optimization in resource-constrained environments, introduced complexity and bugs, as seen in early applications where self-modifying jumps facilitated conditional branching but required careful tracking of locations. Debugging and testing in early stored-program computers involved manual intervention and basic output mechanisms due to the absence of sophisticated tools. Programmers used single-step execution modes, such as EDSAC's "Single E.P." button, to advance one instruction at a time while observing indicator lights for register states or memory contents; for deeper analysis, operators halted the machine to read core (or equivalent delay-line) memory via console switches or generated dumps by printing selected memory words onto teleprinter output. In practice, errors like the 1949 Airy disk diffraction program for EDSAC were identified through tape re-punching after manual code reviews, with jumps logged on paper to trace execution paths, highlighting the labor-intensive nature of verifying programs in these pioneering systems.

Impact and Legacy

Influence on Modern Computing

The stored-program paradigm, as articulated in John von Neumann's 1945 EDVAC report, established the foundational architecture for modern general-purpose computers by enabling instructions and data to reside in the same memory, a principle that underpins dominant instruction set architectures (ISAs) like x86 and . This von Neumann model allows processors to fetch, decode, and execute programs dynamically from memory, providing the flexibility that defines contemporary computing systems from desktops to embedded devices. x86, prevalent in servers and personal computers, and , which powers most mobile processors, both implement this shared-memory approach, ensuring compatibility with a vast array of software while evolving through generations of hardware improvements. The paradigm's influence extends to the software ecosystem, where treating programs as modifiable data in memory facilitated the creation of high-level languages and supporting tools. , introduced by in 1957, was among the first such languages, allowing programmers to write in mathematical notation that compilers could translate into stored and executed in memory, revolutionizing scientific computing. This enabled the development of operating systems like UNIX in the 1970s, which manage memory allocation for both data and executable programs, supporting multitasking and resource sharing across diverse hardware. Compilers and interpreters, integral to modern programming, rely on this stored-program concept to generate and load code dynamically, fostering portability and abstraction layers that separate application logic from hardware specifics. By decoupling program functionality from fixed hardware wiring, the stored-program approach has driven scalability across computing scales, from 1950s mainframes to today's infrastructures, where virtual machines emulate the on distributed hardware to handle in processing demands. This flexibility aligns with , as density increases primarily benefit software optimization rather than requiring architectural overhauls, allowing systems to scale performance through layered hierarchies like caches and SSDs. Consequently, the permeates ubiquitous applications: smartphones execute stored apps via processors, servers run workloads on x86 clusters, and IoT devices process in constrained , all leveraging the same core principle for efficient, reprogrammable operation. The standardization of ISAs around this model, whether RISC's simplified instructions in or CISC's complex ones in x86, ensures and in both hardware and software domains.

Challenges and Limitations

The stored-program design, while revolutionary, introduced the Von Neumann bottleneck, where instructions and data share the same memory bus, leading to contention and delays during access. This shared pathway limits overall system throughput, as the processor must serially fetch instructions and data, creating a fundamental performance constraint that has persisted despite advances in hardware speed. Such delays are inherent to the fetch-execute cycle in this architecture. Early implementations of stored-program computers relied on , which suffered from high failure rates, often causing sudden program crashes and operational downtime. For instance, the , an influential early electronic computer with precursors to stored-program concepts, experienced vacuum tube failures approximately every two days due to overheating and wear, highlighting the reliability challenges of the era. To address these issues, engineers introduced basic error detection methods, such as parity bits appended to data words to detect single-bit errors during transmission or storage, to improve without correcting errors automatically. The unified memory for and in stored-program systems also created vulnerabilities by allowing instructions to be easily modified like ordinary , facilitating and enabling precursors to modern such as viruses and worms. This architectural feature made it possible for erroneous or malicious alterations to instructions, compromising system integrity; for example, exploits, rooted in this design, were demonstrated in the 1988 , which infected thousands of computers by injecting and executing in memory areas. Power and size constraints further limited early stored-program computers, as vacuum tube-based designs required substantial energy and physical space, restricting scalability until . The , one of the first practical stored-program machines, utilized around 3,000 tubes and consumed several kilowatts of power while occupying a room-sized footprint, illustrating how tube heat dissipation and needs imposed practical barriers to larger systems. To mitigate the Von Neumann bottleneck, alternatives like modified Harvard architectures—featuring separate memory buses for instructions and data—have been explored, particularly in digital signal processors (DSPs) for real-time applications. These designs, such as the Super Harvard Architecture in ADI SHARC DSPs, allow parallel access to code and data, reducing contention and improving performance in bandwidth-sensitive tasks without fully abandoning stored-program principles.

References

  1. https://plato.stanford.edu/entries/computing-history/
  2. https://engineering.purdue.edu/~eigenman/reports/vN.pdf
  3. https://cs.carleton.edu/faculty/jondich/courses/cs208_s19/assignments/16_files/edvac.pdf
  4. https://www.computerhistory.org/revolution/birth-of-the-computer/4/87
  5. https://ethw.org/Milestones:Manchester_University_%2522Baby%2522_Computer_and_its_Derivatives%2C_1948-1951
  6. https://courses.cs.duke.edu/summer07/cps001/Lectures/CS_History.pdf
  7. https://www.cs.hmc.edu/~keller/cs60book/13%20Stored-Program%20Computers.pdf
  8. https://people.computing.clemson.edu/~mark/330/chap1.pdf
  9. https://www.turing.org.uk/scrapbook/computer.html
  10. https://computerscience.chemeketa.edu/cs160Reader/HistoryOfComputers/Generation1.html
  11. https://www.computerhistory.org/revolution/birth-of-the-computer/4/86/350
  12. https://www.uvm.edu/~cbcafier/cs2210/content/02_basics_of_architecture/stored_program.html
  13. https://courses.cs.washington.edu/courses/cse490h1/19wi/exhibit/john-von-neumann-1.html
  14. https://www.cs.umd.edu/~meesh/411/CA-online/chapter/computer-architectureintroduction/index.html
  15. https://computerhistory.org/blog/the-analytical-engine-28-plans-and-counting/
  16. https://dl.acm.org/doi/pdf/10.1145/290590.290591
  17. https://www.cs.virginia.edu/~robins/Turing_Paper_1936.pdf
  18. http://web.mit.edu/sts.035/www/PDFs/edvac.pdf
  19. https://curation.cs.manchester.ac.uk/computer50/www.computer50.org/mark1/new.baby.html
  20. https://www.icsa.inf.ed.ac.uk/research/groups/hase/models/ssem/index.html
  21. https://www.tnmoc.org/edsac
  22. https://www.cst.cam.ac.uk/news/70-years-first-computer-designed-practical-everyday-use
  23. https://www.historyofinformation.com/detail.php?id=661
  24. https://www.historyofinformation.com/detail.php?id=698
  25. https://computerhistory.org/blog/programming-the-eniac-an-example-of-why-computer-history-is-hard/
  26. https://ethw.org/UNIVAC
  27. https://www.computerhistory.org/timeline/1951/
  28. http://www.columbia.edu/cu/computinghistory/701.html
  29. https://curation.cs.manchester.ac.uk/digital60/www.digital60.org/birth/manchestercomputers/mark1/ferranti.html
  30. https://ieeemilestones.ethw.org/Milestone-Proposal:LEO:_First_Application_of_Digital_Computing_to_Business_Processes_%28November_1951%29
  31. http://www.columbia.edu/cu/computinghistory/7090.html
  32. http://aturing.umcs.maine.edu/~meadow/courses/cos335/COA02.pdf
  33. http://tikalon.com/blog/2015/1ESS.html
  34. https://www.computerhistory.org/timeline/memory-storage/
  35. https://hackaday.com/2016/03/08/thanks-for-the-memories-touring-the-awesome-random-access-of-old/
  36. https://research.ibm.com/blog/why-von-neumann-architecture-is-impeding-the-power-of-ai-computing
  37. https://diveintosystems.cs.swarthmore.edu/book/C5-Arch/hist.html
  38. https://edoras.sdsu.edu/doc/fortran/ch1-1.html
  39. https://www.purdue.edu/hla/sites/varalalab/wp-content/uploads/sites/20/2019/01/IDAB_Lecture1_2019.pdf
  40. https://textbooks.cs.ksu.edu/cc110/i-concepts/08-architecture/06-von-neumann/
  41. https://www.cs.cornell.edu/courses/cs3410/2019sp/schedule/slides/09-isa-notes.pdf
  42. https://www.cs.miami.edu/home/odelia/teaching/csc419_spring20/syllabus/backusPaper.pdf
  43. https://ieeexplore.ieee.org/document/6657923/
  44. https://ubiquity.acm.org/article.cfm?id=1920826
  45. https://almanac.upenn.edu/archive/v42/n18/eniac.html
  46. https://www.cs.cmu.edu/~rdriley/research/pubs/TDSC10.pdf
  47. https://cset.georgetown.edu/article/memory-safety-an-explainer/
  48. https://people.computing.clemson.edu/~mark/edsac.html
  49. https://people.duke.edu/~BCL15/teachdir/ece252_fall11/Hill.pdf
  50. https://vtechworks.lib.vt.edu/bitstream/handle/10919/32196/Fayez_AS_T_2011_1.pdf?sequence=2
  51. https://my.ece.utah.edu/~ece6580/21161_Hardware.pdf
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.