Fact-checked by Grok 2 weeks ago

EDSAC

The Electronic Delay Storage Automatic Calculator (EDSAC) was the world's first practical general-purpose stored-program electronic computer, designed and built at the University of Cambridge Mathematical Laboratory under the leadership of Maurice Wilkes, and it became operational on 6 May 1949.^[1]^[2]^[3] This pioneering machine used mercury delay lines for memory storage, enabling it to hold both instructions and data electronically, and it executed approximately 650 instructions per second using thermionic valves (vacuum tubes) for processing.^[1]^[4]^[5] EDSAC's development began in 1946, inspired by John von Neumann's EDVAC report, with Wilkes assembling a team including key contributors like Bill Renwick as chief engineer and David Wheeler as a research student who helped innovate programming techniques such as subroutines.^[4]^[1] Initially equipped with 512 17-bit words of memory (expandable to 1024), it accepted input via punched paper tape and produced output on a teleprinter, supporting 18 basic operation codes for arithmetic and control functions.^[1]^[2] Its first program, written by Wilkes, computed a table of squares, while Wheeler's early effort generated prime numbers, demonstrating its utility for scientific calculations.^[3] The machine's significance lay in transforming computational research at Cambridge, where it ran continuously until 1958 and supported groundbreaking work, including simulations for Nobel Prize-winning discoveries in molecular biology by John Kendrew and Max Perutz, as well as in astronomy by Antony Hewish and Martin Ryle.^[1]^[4] EDSAC also pioneered practical software innovations, such as relocatable subroutines in 1951, which facilitated code reuse and influenced the design of later systems like LEO I, the first commercial computer.^[4]^[1] By providing a reliable service for university users from early 1950, it established stored-program computing as a viable paradigm, paving the way for modern digital computers.^[2]^[5]

History and Development

Origins and Inspiration

The development of EDSAC originated in 1946 at the University of Cambridge Mathematical Laboratory, led by Maurice Wilkes, who had been profoundly influenced by his attendance at the Moore School lectures in the United States during the summer of 1946. These lectures, organized by the University of Pennsylvania, covered the principles of electronic computing exemplified by ENIAC and introduced the stored-program concept detailed in John von Neumann's First Draft of a Report on the EDVAC. Upon his return to Cambridge in late 1946, Wilkes obtained a copy of von Neumann's report through a colleague, which catalyzed his decision to pursue the construction of a practical stored-program computer despite the laboratory's constrained resources and postwar limitations on materials and expertise.^[4]^[6]^[2] Wilkes assembled a small team to realize this vision, including chief engineer Bill Renwick, graduate students David Wheeler and Stanley Gill, who contributed significantly to the design and early programming efforts.^[1] The project emphasized creating a reliable computing machine tailored for mathematical and scientific calculations within the Cambridge academic community, prioritizing dependability and ease of use over raw computational speed. This approach contrasted with more ambitious but resource-intensive American projects, reflecting the practical constraints at Cambridge.^[6]^[7] Initial planning focused on a minimalist architecture, including the adoption of mercury delay lines for memory storage—a technology inspired by the work of J. Presper Eckert and John Mauchly on acoustic delay lines for radar applications during World War II. This choice allowed for economical implementation of the stored-program paradigm outlined in the EDVAC report, enabling instructions and data to be held in the same memory system. The effort was supported by external grants, notably from J. Lyons & Company, which sought computing solutions for business applications and helped sustain the project through its early phases.^[4]^[1]^[8]

Construction and Initial Operation

The construction of EDSAC began in early 1947 at the University of Cambridge Mathematical Laboratory, led by Maurice Wilkes. The project spanned roughly two years, during which the team designed and assembled the machine's components from basic principles, including custom electronic circuits and storage mechanisms. By May 1949, the hardware was sufficiently complete to attempt initial operations, marking the transition from theoretical planning to a functional stored-program computer.^[2] A major engineering effort focused on procuring around 3,000 thermionic valves to power the logic and arithmetic units, arranged across 12 chassis racks, while post-war shortages complicated component availability. Equally demanding was the fabrication of 32 mercury delay line tanks for the main memory, each consisting of a 5-foot steel tube filled with mercury to circulate acoustic pulses representing data bits. These tanks, maintained at a constant temperature to ensure signal stability, formed the core of EDSAC's 512-word storage capacity and required meticulous construction to minimize attenuation and reflections.^[9]^[10] EDSAC achieved its first successful program execution on 6 May 1949, when it computed and printed a table of squares for the integers from 0 to 99, validating the integration of its serial binary processing at a 500 kHz clock speed. The machine drew approximately 12 kW of power during operation, supporting continuous use for computational tasks. It remained in service for nearly a decade, contributing to various research efforts until its decommissioning on 11 July 1958 to make way for the more advanced EDSAC 2.^[10]^[11]^[12]

Technical Design

Hardware Architecture

EDSAC was designed as a serial binary computer utilizing one-address instructions, fully implementing the stored-program concept to enable automatic execution of sequences of operations stored in memory.^[13] The architecture emphasized simplicity and reliability, with the central processing unit (CPU) handling basic arithmetic operations efficiently for its era; addition and subtraction required 1.5 milliseconds, while multiplication took approximately 4.5 milliseconds, and division was implemented in software over longer durations.^[13] Fixed-point arithmetic was employed throughout, using two's complement representation for signed integers to facilitate straightforward handling of negative values in computations.^[14] The hardware relied on approximately 3,000 thermionic valves, derated to operate below their maximum ratings for enhanced reliability and reduced failure rates, supplemented by relays for auxiliary control functions.^[13] These components were mounted on 12 racks, resulting in a physical footprint occupying a roughly 4.5 by 4.5 meter space within the Cambridge Mathematical Laboratory.^[15] Natural air cooling sufficed for the valve-based logic, achieved through strategic rack arrangement to promote airflow, while the system drew about 12 kW of power during operation.^[15]^[13] This configuration prioritized practical construction over maximal speed, allowing EDSAC to become operational by 1949 for early scientific programming experiments.^[13]

Memory System and Instructions

EDSAC's memory system utilized mercury delay line technology, which stored data as acoustic pulses traveling through mercury-filled tubes at the speed of sound. Initially configured with 16 such delay lines, the system provided a capacity of 512 17-bit words, where each line held 32 short words (or 16 long 35-bit words) plus additional circulation time for signal refresh to prevent data loss.^[16]^[10] In 1952, the memory was expanded by adding another 16 delay lines, increasing the total capacity to 1,024 17-bit words while maintaining the same per-line structure.^[1] This acoustic storage medium operated serially, circulating bits continuously, and required temperature stabilization to ensure reliable pulse propagation and minimize errors from environmental variations.^[17] The instruction set featured around 18 basic orders, supporting a one-address architecture centered on an accumulator register for arithmetic operations. Instructions were encoded in short words but could specify either short (17-bit) or long (35-bit) operands via a dedicated length bit, enabling flexible handling of numbers with precisions equivalent to approximately 5 and 10 decimal digits, respectively; arithmetic instructions like addition and subtraction typically used the one-address format to fetch an operand from memory and apply it to the accumulator, while branch instructions employed the address field to transfer control to a specified location.^[18]^[19] Short instructions sufficed for branches due to their single-word addressing needs, whereas long instructions accommodated extended precision for computations by spanning two consecutive memory words.^[14] Each 17-bit word included a sign/length bit (most significant bit), a 5-bit operation code specifying the order type, a 1-bit spare field, and a 10-bit address field capable of referencing up to 1,024 memory locations.^[20] The machine executed instructions serially bit-by-bit, with an average cycle time of 1.5 milliseconds, though serial processing allowed for parallel addition in the arithmetic unit to optimize performance where possible; multiplication, however, required multiple cycles and took about 4.5 milliseconds.^[10]^[21] To enhance reliability, the delay line system incorporated checks for control errors during data recirculation, aiding in the detection of storage anomalies common to early acoustic memories.^[22]

Input and Output Mechanisms

EDSAC's primary input mechanism was a five-hole punched paper tape reader, which loaded programs and data into the machine's memory. Initially operating at 6⅔ characters per second using a teleprinter-style reader, it was upgraded in October 1949 to 16 characters per second and further improved in early 1950 with a photoelectric reader achieving 50 characters per second. Programs were entered as binary-encoded instructions on the tape, read sequentially by the initial orders routine—a short bootstrap program that transferred the content into the mercury delay line memory. The paper tape employed a five-hole Baudot-derived code to represent EDSAC's 17-bit words, with each word typically encoded across five characters for compatibility with the 32 possible hole combinations. Synchronization during reading was maintained by a central sprocket hole that advanced the tape at a uniform speed, ensuring precise alignment of the photoelectric sensors over the data holes. Output was generated via a Creed Model 7B teleprinter, which produced printed results at 6⅔ characters per second. In 1951, an additional punched paper tape output unit was installed, operating at 16 characters per second to enable offline data storage and transfer. For auxiliary storage and intermediate data handling, EDSAC relied on additional punched paper tapes prepared and read manually, as no magnetic tape system was available at launch; an experimental magnetic tape auxiliary store was added in 1952 but suffered from reliability issues and saw limited use. These input and output mechanisms imposed significant limitations on EDSAC's performance, as the I/O rates were orders of magnitude slower than the processor's execution speed of approximately 650 instructions per second, often causing idle time during data loading and result printing. Moreover, tape preparation demanded skilled human operators using keyboard perforators or manual punches, increasing the risk of errors such as missed holes, which required on-the-spot corrections.

Software Ecosystem

Initial Orders and System Software

The initial orders for EDSAC constituted a hardwired bootstrap routine designed to load the first user program from punched paper tape into the machine's mercury delay line memory. Developed by David Wheeler in May 1949, this routine was implemented using uniselectors—telephone-style switches wired to generate the necessary machine instructions—and occupied the first 31 memory locations (0 to 30). Upon powering on EDSAC, the routine began execution at location 0, reading 20 segments of 5-track paper tape containing the program in a symbolic form, assembling 17-bit binary instructions from operation codes and addresses, and storing them starting at location 31 before transferring control to the loaded program.^[23]^[24] The initial orders effectively served as EDSAC's rudimentary loader, combining basic assembly and loading functions without the need for a separate operating system. This loader translated tape codes into executable form, allowing modifications via symbolic letters on the tape to adjust addresses or parameters dynamically during input, which facilitated efficient program preparation and reduced manual errors. No comprehensive operating system existed; instead, these initial orders provided the foundational control mechanism for initiating computations.^[24]^[20] EDSAC's system software encompassed essential utilities for input, tape management, and diagnostics, all developed in machine code to ensure reliability on the nascent hardware. Basic input routines handled the reading of punched tape, synchronizing with the tape reader's mechanical speed and verifying character codes before assembly, while tape handling utilities managed multi-segment loading and error recovery during reads. Error diagnostics, pioneered by Stanley Gill, included innovative checking routines that interrupted execution to inspect memory states, a "peeping" tool for real-time monitoring, and postmortem analysis to trace faults after crashes, significantly aiding early debugging efforts.^[10]^[25] The core system elements were crafted by Maurice Wilkes, David Wheeler, and Stanley Gill, emphasizing modularity to enhance reusability and fault tolerance in an era of unreliable components. A landmark feature was EDSAC's first practical subroutine library, which stored reusable code segments on dedicated tapes for mechanical copying onto user programs, enabling complex calculations through modular assembly; by 1951, this library comprised 87 subroutines covering arithmetic, input/output, and utility functions. This approach, detailed in their seminal 1951 text The Preparation of Programs for an Electronic Digital Computer, the first book on programming, prioritized conceptual efficiency over exhaustive customization, laying groundwork for structured programming practices.^[26]^[27]

Programming Techniques

Programming for the EDSAC initially involved direct binary coding, where instructions were calculated by hand and punched onto paper tape in binary form for the machine's 17-bit word format. This labor-intensive process was used for the very first demonstration program run on May 6, 1949, which computed a table of squares, requiring programmers to manually convert operations into binary sequences without automated aids.^[26]^[10] To alleviate the tedium of binary punching, David Wheeler developed an early symbolic assembly scheme integrated into the EDSAC's Initial Orders, allowing programmers to use alphanumeric notations for operations and addresses, such as single letters for opcodes (e.g., 'A' for addition) followed by decimal digits for addresses. This system, operational from the machine's inception in 1949, enabled relocatable code through symbolic address labels like code-letters (e.g., θ denoting the program origin), marking one of the first practical assemblers and reducing errors in code preparation. Programs were still punched on paper tape but in this symbolic form, which the Initial Orders translated into binary during loading.^[10]^[28]^[26] A key innovation in EDSAC programming was the systematic use of subroutines, facilitated by the "Wheeler jump" technique, which allowed calls to library routines for common tasks like multiplication or input/output without hardware support for return addresses. In this method, a calling instruction such as A m F (add the contents of location m to the accumulator and jump if negative) was modified in place to store the return address, enabling the subroutine to compute and jump back to the subsequent instruction; returns used a similar jump like G n F. This approach structured programs as a main routine linked to relocatable subroutines via punched tape segments separated by control combinations (e.g., T m K for tape marks), promoting code reuse from a growing library that reached 87 routines by 1951.^[10]^[28]^[26] The assembly process combined manual symbolic notation with the machine's Initial Orders as a rudimentary assembler and linker, loading the main program and subroutines into memory starting from fixed locations like 0 or 56, while adjusting addresses for relocation. Programmers prepared tapes by hand-punching or using a keyboard perforator, then concatenated library subroutine tapes—duplicated in advance for efficiency—with the main routine tape before submission.^[28]^[10] Debugging relied on manual verification and machine-assisted traces output to the teleprinter, including "peeping" for single-step execution and post-mortem routines like PM5 to print orders from a specified location. Checking subroutines such as C7 provided execution traces by printing control flow and register states after a halt, while C10 offered arithmetical traces of numerical operations; these were appended to programs via tape for automated logging, though systematic bug tracking remained anecdotal rather than formalized.^[10]^[28] EDSAC's programming techniques pioneered practical subroutine libraries and modular code organization, influencing subsequent systems by demonstrating how reusable components could streamline development and reduce redundancy in early computing.^[26]^[10]

Library and Application Programs

The EDSAC featured a substantial library of subroutines that formed the foundation for efficient program development, allowing users to reuse tested code segments for common operations. Initiated in autumn 1949 by staff at the Cambridge University Mathematical Laboratory, the library expanded to 87 routines by 1951, covering essential categories such as arithmetic operations—including square roots and division—and statistical functions for data analysis. These subroutines were stored on paper tapes and organized in a dedicated filing system, enabling programmers to link them seamlessly into custom applications without rewriting basic algorithms from scratch.^[10] The library's maintenance and distribution were handled directly by laboratory personnel, who tested and updated routines based on user feedback and operational experience; copies were provided to external users via punched paper tapes, fostering a collaborative computing environment. This approach not only accelerated program creation but also ensured reliability, as subroutines underwent rigorous validation before inclusion.^[10] Complementing the subroutine library were early assembly tools, notably the system developed by David Wheeler in 1949, which translated symbolic instructions into EDSAC machine code and represented a pioneering precursor to modern assemblers. While EDSAC lacked high-level languages, Wheeler's assembler streamlined coding by reducing the need for manual binary entry, marking an initial step toward more abstracted software development.^[29]^[27] Among the application programs built atop this ecosystem were those addressing numerical challenges, such as solvers for differential equations and methods for numerical integration, which leveraged library routines for precision and speed.^[30]^[4]

Applications and Usage

Scientific Computations

EDSAC served as a vital tool for university researchers at the University of Cambridge, enabling numerical solutions to differential equations and simulations in physics and engineering fields. Primary applications encompassed orbital calculations for astronomical research and fluid dynamics problems, including analyses of double diffusion processes in oceanic and stellar environments. These computations advanced scientific inquiry through automated processing of complex mathematical models.^[4]^[31]^[32] EDSAC's contributions included calculations supporting three Nobel Prizes: in Chemistry (1962, for the molecular structures determined by Max Perutz and John Kendrew using X-ray crystallography simulations) and in Physics (1974, for radio astronomy work by Antony Hewish and Martin Ryle).^[4] A prominent example of EDSAC's impact occurred in 1950, when statistician Ronald Fisher collaborated with Maurice Wilkes and David Wheeler to solve a differential equation modeling gene frequencies, representing an early application of computing to biological simulations. This work significantly accelerated research timelines, as manual calculations would have required months, whereas EDSAC completed the task in hours, contributing to foundational advancements in population genetics. The machine's capabilities extended to supporting theses, such as those by D.H. Shinn on radio wave propagation and Jack Harwood on related atmospheric studies, as well as publications in journals like the Journal of Atmospheric and Terrestrial Physics and Proceedings of the Royal Society.^[4]^[31] EDSAC operated in batch processing mode, with users submitting jobs via punched paper tape read at 50 characters per second, resulting in queued execution that limited interactivity but ensured reliable throughput. Despite these constraints, the system operated about 35 hours per week, sustaining continuous academic use from its operational start in May 1949 until decommissioning in 1958. Researchers leveraged library routines for standard numerical tasks, such as integration and equation solving, to streamline scientific computations without reinventing core algorithms.^[33]^[34]^[31]^[30]

Early Games and Demonstrations

One of the earliest recreational programs developed for the EDSAC was OXO, a graphical implementation of noughts and crosses (tic-tac-toe), created by Cambridge University PhD student Alexander S. Douglas in 1952.^[35] This program allowed a human player to compete against the computer on a 35 by 16 dot-matrix display rendered on a cathode ray tube (CRT), marking positions with crosses while the machine responded with noughts.^[35] Input was provided via a rotary telephone dial connected to the system, enabling turn-based interaction that simulated strategic gameplay.^[35] OXO represented an unbeatable opponent through its programmed logic, making it the first known strategy game on a computer.^[36] Beyond OXO, EDSAC supported other demonstration programs focused on visual output, such as pattern generation and simple animations to showcase the machine's graphical capabilities. For instance, a now-lost program called "Highland Dancer" animated a dancing figure on the CRT monitor during the early 1950s, providing an engaging visual test of the system's display potential.^[10] Another example was a visualization of the Sieve of Eratosthenes algorithm, which dynamically displayed the elimination of non-prime numbers on the CRT, illustrating computational processes in a graphical format around 1950.^[10] These programs utilized the CRT for direct visual feedback, distinct from the standard teleprinter output that handled textual results at a rate of about 6.67 characters per second.^[10] Such early games and demonstrations served dual purposes: boosting staff morale within the Mathematical Laboratory and facilitating public showcases of EDSAC's versatility during events like the 1950-1951 summer schools for programmers.^[31] They highlighted the computer's ability to go beyond numerical computations, though interaction was not real-time due to the system's processing speed and sequential input-output mechanisms.^[35] This marked an initial step toward interactive computing, demonstrating how EDSAC could engage users in non-scientific, illustrative applications.^[36]

Legacy and Successors

EDSAC 2 and Further Evolutions

EDSAC 2, the successor to the original EDSAC, was commissioned in 1958 at the University of Cambridge Mathematical Laboratory and remained in operation until 1965, when it was replaced by the Titan computer.^[37] Designed under the leadership of Maurice Wilkes, it marked a significant advancement over its predecessor by adopting a parallel architecture and replacing the mercury delay-line memory with magnetic core storage, enabling faster access times and greater reliability.^[38] The machine was constructed using vacuum tubes for logic circuitry and featured an initial main memory capacity of 2 × 1024 words, each 40 bits long, which was later expanded with additional core memory modules.^[39] Key design innovations in EDSAC 2 included its status as the first full-scale microprogrammed computer, utilizing a bit-sliced organization for the control unit with a microprogram of 1024 steps stored in read-only core memory.^[38] This allowed for flexible instruction execution and easier modification of the instruction set compared to the serial architecture of EDSAC 1. Input and output were handled via high-speed paper tape readers and punches, supplemented by magnetic tape units for bulk storage, while the system's performance supported more demanding computational tasks, including complex scientific simulations that built upon routines from the original EDSAC.^[38] Programs from EDSAC 1 were adapted and migrated to EDSAC 2, leveraging compatibility in programming concepts to facilitate the transition for users.^[40] Prior to the full deployment of EDSAC 2, the original EDSAC underwent intermediate upgrades to extend its utility, notably the experimental introduction of magnetic tape storage in 1952, which improved data handling for larger datasets and paved the way for enhanced I/O capabilities in the successor machine.^[40] EDSAC 2 also supported advanced programming environments, including Autocode, a high-level language with features inspired by early ALGOL developments, enabling more sophisticated software for scientific and engineering applications.^[41] These evolutions at Cambridge represented a transitional phase in early computing, bridging vacuum-tube technology toward more modular and efficient systems.

Replica Project and Modern Reconstructions

The EDSAC Replica Project was launched on 13 January 2011 by the Computer Conservation Society at The National Museum of Computing (TNMOC) in Bletchley Park, UK, with the aim of constructing a functional reconstruction of the original EDSAC as it operated around 1951, relying primarily on surviving photographs, diagrams, and archival documents due to the scarcity of complete original blueprints.^[42]^[1] Significant progress milestones included the powering on of the first hardware modules in November 2014, marking the start of the commissioning phase, followed by steady advancements through 2024, when the project neared physical completion, incorporating simulations for core memory and central processing unit verification to ensure fidelity to the 1949 design.^[43]^[44] The effort was driven by a volunteer team led by project manager Dr. Andrew Herbert, comprising mostly retired engineers and computer scientists, who adhered closely to the original specifications while substituting unavailable period components—such as mercury delay lines—with modern equivalents like magnetostrictive steel wire delay lines to achieve operational authenticity without compromising safety or practicality.^[1]^[45] As of late 2025, the replica is close to physical completion and in an intense commissioning phase, with the aim of executing original programs such as the inaugural square-sum calculation that ran on the first EDSAC in 1949, serving as a cornerstone for educational exhibits on early computing history at TNMOC.^[1] Videos documenting the reconstruction and demonstrations became available online, facilitating public access and outreach, while the project's dedicated company was dissolved in August 2025.^[46]^[47] These reconstructions underscore the replica's role in preserving hands-on insights into mid-20th-century computing innovations, with ongoing maintenance ensuring its longevity for future generations of researchers and visitors.^[1]

Influence on Computer Science

EDSAC's innovations in stored-program computing marked a pivotal advancement in computer architecture and software engineering. As the first practical electronic stored-program computer to enter regular service in May 1949, it demonstrated the viability of reliable, general-purpose computation for scientific and mathematical applications, shifting computing from experimental prototypes to operational tools.^[4]^[48] EDSAC pioneered the use of subroutine libraries, enabling modular program design by allowing reusable code segments for common operations like arithmetic and input/output, which reduced development time and promoted software reusability—a foundational concept in modern programming.^[49]^[50] This approach, implemented through initial orders that facilitated library integration, influenced subsequent systems by emphasizing structured programming over ad-hoc coding.^[51] A key contribution to computer science education and practice was Maurice Wilkes' 1951 publication, The Preparation of Programs for an Electronic Digital Computer, co-authored with David Wheeler and Stanley Gill. This work served as the first comprehensive textbook on programming, detailing techniques for EDSAC including subroutine usage and program preparation, and exerted profound influence on early software development methodologies worldwide.^[27]^[52] The book's emphasis on systematic program design helped standardize practices that informed the evolution of high-level languages and compilers. In historical context, EDSAC was the second electronic digital stored-program computer to achieve regular operation, following the Manchester Mark 1 in 1949, and preceded the UNIVAC I by two years in 1951, underscoring its role in the rapid maturation of von Neumann-style architectures.^[53] It directly inspired British computing developments, notably the LEO I, the world's first business computer built by J. Lyons & Co. based on EDSAC's design principles for commercial data processing.^[54]^[55] EDSAC's design, rooted in von Neumann's 1945 EDVAC report, provided an early, working exemplar of the stored-program paradigm, serving as a foundational case study for understanding sequential instruction execution and memory-program integration in computer science curricula today.^[56] Despite its academic origins yielding no direct institutional commercial spin-offs, EDSAC's emphasis on practical reliability fostered enduring intellectual impacts, though it remains underrecognized relative to ENIAC's publicity as the first general-purpose electronic computer.^[49]^[57]

References

[1]
EDSAC - Electronic Delay Storage Automatic Calculator
The EDSAC Replica Project aims to reconstruct one of the most important early British digital computers. Designed in 1947 by a team lead by Maurice Wilkes.
[2]
Maurice V. Wilkes - A.M. Turing Award Laureate - ACM
Professor Wilkes is best known as the builder and designer of the EDSAC, the first computer with an internally stored program. Built in 1949, the EDSAC used a ...
[3]
Maurice Wilkes's EDSAC, the First Easily Used Fully Functional ...
The EDSAC was the first easily used, fully functional stored-program computer to run a program. The phrase "delay storage" in its name reflected the delay-line ...
[4]
The EDSAC and Computing in Cambridge - Whipple Museum |
In 1945 its sole full-time employee, Maurice Wilkes, assumed its directorship. Wilkes was captivated when a friend visiting Cambridge in 1946 brought a ...
[5]
Sir Maurice V. Wilkes - CHM - Computer History Museum
In 1945, he became the first head of the computer laboratory at Cambridge and the following year, began working on the groundbreaking EDSAC computer, which ...
[6]
Maurice V. Wilkes 1913-2010 | Memorial Tributes: Volume 15
Eckert and Mauchly, together with John von Neumann, subsequently produced a proposal for the EDVAC, the blueprint of the modern stored-program digital computer.Missing: origins | Show results with:origins
[7]
David Wheeler - IEEE Computer Society
Experience with writing programs for Edsac led Wheeler and his colleagues Maurice Wilkes and Stanley Gill to publish the first book for programmers, The ...
[8]
EDSAC runs its first program - Event - Computing History
EDSAC was built by Maurice Wilkes at the University of Cambridge Mathematical Laboratory. ... Ltd., a British firm, helped fund the EDSAC project with a grant of ...Missing: source | Show results with:source
[9]
Short mercury delay tube from the electronic computer EDSAC ...
It was built in the Cambridge University Mathematics Laboratory, and contained 3,000 valves arranged on 12 racks, using tubes of mercury for memory. Delay lines ...Missing: construction | Show results with:construction
[10]
[PDF] Tutorial Guide to the EDSAC Simulator
Checking routines were invented by Stanley Gill - the third author of Wilkes, Wheeler and Gill; he was then a research student and was later Professor of ...
[11]
EDSAC Architecture
The system ran at a clock speed of 500kHz, but since the EDSAC was a serial computer, and because of the memory design, it managed about 600 instructions per ...Missing: 11 | Show results with:11
[12]
The History of the Computer Lab - University of Cambridge
Aug 11, 2004 · EDSAC I was shut down on 11th July 1958. Its successor, EDSAC II (1958-1965), was the first full-scale microprogrammed machine, also the first ...Missing: construction timeline
[13]
Some EDSAC statistics - University of Cambridge
The EDSAC (electronic delay storage automatic calculator) is a serial electronic calculating machine working in the scale of two and using ultrasonic tanks for ...Missing: clock 11
[14]
About EDSAC - BREDSAC Project
Negative numbers use two's-complement representation. Additions, subtractions and logical operations operate on the most significant 17 or 35 bits of the ...
[15]
https://www.cl.cam.ac.uk/UoCCL/misc/EDSAC99/booklet.pdf
[16]
1949: EDSAC computer employs delay-line storage
In May 1949, Maurice Wilkes built EDSAC (Electronic Delay Storage Automatic Calculator), the first full-size stored-program computer.
[17]
Delay line storage in EDSAC - pick your poison
Mar 31, 2020 · In the original EDSAC, the delay lines were constructed from long steel tubes ('tanks') filled with mercury. It was not practical to ...Missing: 32 | Show results with:32
[18]
The EDSAC Instruction Set 1949
Although the basic word size of the EDSAC was 18 bits, only 17 bits could actually be used due to circuit set-up times. The opcode (i.e. one of the ...
[19]
EDSAC - Clemson University
EDSAC contained 3,000 vacuum tubes and used mercury delay lines for memory. Programs were input using paper tape and output results were passed to a ...
[20]
An EDSAC Simulator using SIMPL | Thoughts from the Towpath
Apr 23, 2017 · It could address up to 1024 words of mercury delay line memory and had an instruction cycle time of about 1.5mS but represented a 1000 fold ...
[21]
[PDF] Tutorial Guide to the EDSAC Simulator
The EDSAC subroutine library began to take shape from autumn 1949 onwards. Subroutines were classified by a letter indicating the group to which they ...Missing: construction | Show results with:construction
[22]
[PDF] EDSAC Initial Orders and Squares Program
EDSAC's main memory used mercury delay lines to hold 512 words of 35 bits. We will use the notation: w[0], w[2],...,w[1022] to refer to these words of ...
[23]
Programme organization and initial orders for the EDSAC - Journals
Orders for the machine are presented to it in coded form on punched tape, and are translated by the machine itself into the form in which they are held in ...
[24]
[PDF] edsac programming and applications
David Wheeler's Initial Orders – wired on to uniselectors. Page 3. Wilkes' Airy Program June-July 1949. Page 4. Wilkes' Airy Program June-July 1949. Page 5 ...
[25]
The Preparation of Programs for an Electronic Digital Computer
Feb 8, 2013 · The Preparation of Programs for an Electronic Digital Computer. by ... PDF download · download 1 file · SINGLE PAGE ORIGINAL JP2 TAR ...
[26]
In Praise of 'Wilkes, Wheeler, and Gill' - Communications of the ACM
٠١‏/٠٩‏/٢٠١١ · Maurice Wilkes, David Wheeler, and Stanley Gill produced the first textbook on programming: The Preparation of Programs for an Electronic Digital Computer.ناقصة: team | عرض نتائج تتضمّن:team
[27]
[PDF] Programming the EDSAC
Apr 18, 2024 · Order field in instruction is the bit pattern of the order character, i.e., A = 11101. Note conventions for typing Greek letters when using ...
[28]
David John Wheeler - CHM - Computer History Museum
David Wheeler was born in Birmingham, England, in 1927. He was awarded a ... " His wired-in EDSAC assembler of 1949, creating a simple system for users ...
[29]
70 years since the first computer designed for practical everyday use
May 3, 2019 · EDSAC was superseded by a more advanced machine, EDSAC 2, in 1958. EDSAC 2 was built by Maurice Wilkes and the same team who had created the ...Missing: timeline | Show results with:timeline
[30]
[PDF] THE BIRCH AND SWINNERTON-DYER CONJECTURE
A polynomial relation f(x, y) = 0 in two variables defines a curve C0. If the coefficients of the polynomial are rational numbers, then one can ask for ...
[31]
EDSAC 1 and after
I got to know Maurice Wilkes, David Wheeler, Stan Gill and many others. I continued to attend colloquia after I went down, when I was employed at Elliott ...
[32]
[PDF] Programming the EDSAC - IET EngX®
The methods of preparing programs for the EDSAC were developed with a view to reducing to a minimum the amount of labour required, and hence of making it.
[33]
[PDF] The Progress of Computing - EliScholar
Sep 1, 2001 · Applying this formula to a machine that can perform 20 million additions per second, with 32 bit words, a multiplication time five time slower ...
[34]
1952 | Timeline of Computer History
Alexander Douglas writes OXO for EDSAC ... Alexander Douglas was a Cambridge University PhD candidate when he designed one of the earliest computer games, a ...
[35]
First strategy game - Guinness World Records
The first strategy game on a computer was OXO, a version of Noughts and Crosses (known in the US as Tic-Tac-Toe), which was recreated on the EDSAC.
[36]
Computing History - TCM - University of Cambridge
The first computer at the University of Cambridge was EDSAC 1, a computer designed and built by the University's Mathematical Laboratory. It ran its first ...Missing: statistics | Show results with:statistics
[37]
The Relics Project: Virtual exhibition
EDSAC II (1958-1965), was the first full-scale microprogrammed machine, also the first bit-sliced machine. It used fast paper tape for I/O, magnetic tapes. A ...Missing: construction timeline<|control11|><|separator|>
[38]
[PDF] An EDSAC 2 emulator
The alternative which has been adopted is to emulate the 100 or so machine instructions as described in 'Programming for EDSAC 2'. This does not contain all the.
[39]
A brief informal history of the Computer Laboratory
' 1946 October Work began on the EDSAC (Electronic Delay Storage Automatic Calculator, later referred to as EDSAC 1), following Wilkes' visit to the US in ...Missing: timeline | Show results with:timeline
[40]
An Introduction to ALGOL Programming by J.M. Watt. 1st Deuce ...
The EDSAC 2 Autocode Translator by D.F. Hartley. June 1962. NPL/H3/4/3 A guide to ALGOL programming by Daniel D. McCracken. NPL/H3/4/4 ...
[41]
EDSAC to be recreated - University of Cambridge
Jan 13, 2011 · The project is expected to take three to four years and is being funded by a consortium led by the computing entrepreneur, Hermann Hauser. David ...Missing: initiated 1947 Royal
[42]
Museum switches on historic computer - BBC News
Nov 26, 2014 · The first recreated parts of the re-built Edsac machine have been switched on, external at The National Museum of Computing. The Electronic ...Missing: modules | Show results with:modules
[43]
In Defense of Model-Makers: Adding a New Point to the Computer ...
The TNMOC EDSAC rebuild (still in progress in 2024) is described in. 8Simh is an open source, retargetable instruction set simulator project, described at https ...
[44]
[PDF] EDSAC Replica Project - Hal-Inria
Feb 3, 2017 · The main store of EDSAC and its internal registers were constructed using mercury delay lines. This was a technology familiar to Wilkes from his.
[45]
EDSAC Videos - The National Museum of Computing
Oct 15, 2019 · What store for the EDSAC reconstruction? Peter Linington explains. Jul 2013, Clocking in the Digital Age: Wilkes Centenary and first working parts of EDSAC ...Missing: pattern generation
[46]
EDSAC REPLICA PROJECT filing history - Companies House
12 Aug 2025, GAZ2(A), Final Gazette dissolved via voluntary strike-off ; 15 Apr 2025, SOAS(A), Voluntary strike-off action has been suspended ; 11 Mar 2025, GAZ1( ...
[47]
Marking a cultural shift in computing with EDSAC
May 6, 2013 · In May 1949 EDSAC became the world's first general purpose stored program computer to enter regular service, transforming scientific research.
[48]
Rebuilding EDSAC: The first real computer - Data Center Dynamics
Aug 19, 2021 · Built by Professor Maurice Wilkes at Cambridge University's Mathematical Laboratory, EDSAC was supported by a small team of technicians, and ...
[49]
Computer Resurrection Issue 103
The simulator uses three Ferranti Argus 700 processors a GX and two GLs. Maintaining the Argus 700 and other electronic assemblies that have been abandoned to ...<|control11|><|separator|>
[50]
Programming the EDSAC: Early Programming Activity at the ...
This had considerable influence on the development of programming systems elsewhere—notably through the publication of the classic textbook on programming, The ...Missing: influence science
[51]
The First Published Book on Computer Programming | CMU Libraries
Wilkes' Preparation is considered the first printed book on computer programming and is therefore an important artifact from the early history of computer ...<|separator|>
[52]
1951 | Timeline of Computer History
The Mark 1 was a refinement of the experimental Manchester “Baby” and Manchester Mark 1 computers, also at Manchester University.<|separator|>
[53]
Meet LEO, the world's first business computer - Science Museum
Nov 9, 2018 · EDSAC duly delivered, and in 1949 John Pinkerton, a Cambridge engineer hired by Lyons to head the project, began to build LEO with a small team.
[54]
Milestone-Proposal:LEO: First Application of Digital Computing to ...
The University of Cambridge project was called EDSAC [6] (Electronic Delay Storage Automatic Calculator) and was the second electronic digital stored-program ...
[55]
EDSAC – Knowledge and References - Taylor & Francis
The room-sized EDSAC I was the world's first fully operational, stored-program computer (the first von Neumann machine) and went online in 1949. EDSAC II became ...
[56]
ENIAC, EDSAC and Colossus... and the Difference Engine
Jan 31, 2017 · ENIAC was for calculations, Colossus for code-breaking, and EDSAC was the first stored-program computer. ENIAC was programmable by rewiring, ...Missing: underrecognized | Show results with:underrecognized