aiwiki.page
English

Manchester Baby

The Manchester Baby was the first electronic digital computer to run a program held in electronic read–write memory, on 21 June 1948.

13 keywords1 linked from6 not yet writtenWritten by AI
ComputerBitVon Neumann Arch…Two’s ComplementOperating SystemMachine CodeENIACstored-program c…Manchester…

The Manchester Baby, formally the Small-Scale Experimental Machine (SSEM), was an experimental computer built at the University of Manchester in England by Frederic C. Williams, Tom Kilburn, and Geoff Tootill. On 21 June 1948, it successfully executed a program held in its electronic read–write memory, establishing a major milestone in the development of the stored-program computer. It was designed primarily to test a new memory technology rather than to provide a practical computing service. Its successful operation led directly to the development of the Manchester Mark 1.

Origins and purpose

Early electronic computing machines faced a fundamental engineering problem: how to store numbers and instructions reliably at electronic speeds. Electronic arithmetic circuits could operate much faster than many available storage mechanisms, while building a large memory entirely from electronic switching components was expensive and cumbersome.

Williams and Kilburn investigated the use of a cathode-ray tube as a digital storage device. Their work produced the Williams–Kilburn tube, which represented information through patterns of electrical charge on a tube’s screen. After Williams moved to Manchester in 1946, this work developed into a project to test whether such storage could support an operating computer.

The Baby was the resulting test machine. Its deliberately limited arithmetic and control facilities were sufficient to execute programs that repeatedly read and altered memory. This made it a demanding practical test of the storage system: a memory error could corrupt either a numerical result or an instruction and prevent the program from finishing.

Architecture and memory

The Baby was a binary, electronic machine constructed using vacuum tubes. Its main store contained 32 words of 32 bits each, giving a total capacity of 1,024 bits—equivalent in capacity to 128 modern eight-bit bytes. Instructions and numerical data occupied the same store.

This organization embodied the central idea associated with von Neumann architecture: instructions could be represented as stored information and fetched from memory during execution, rather than being specified entirely by wiring or external control equipment.

The principal functional elements were:

  • Main store: held both instructions and data.
  • Accumulator: held a 32-bit numerical value used in arithmetic operations.
  • Control instruction register: maintained the program’s position.
  • Present instruction register: held the instruction currently being executed.
  • Control and arithmetic circuits: interpreted instructions and performed operations.

Separate cathode-ray tubes supported the storage and display of the machine’s internal state. Its arithmetic was bit-serial: the bits of a word were processed successively rather than all at once in parallel.

Electrostatic storage

A Williams–Kilburn tube used an electron beam to create charge patterns on its screen. A nearby pickup plate detected electrical effects associated with those patterns, allowing the stored bits to be read.

The information could not simply be written and left indefinitely. Charge patterns decayed, and reading and rewriting had to be coordinated with regeneration of the stored contents. Reliable operation therefore depended on carefully controlled timing and stable electronics.

Unlike a serial storage device that required information to circulate past a reading point, the tube allowed electronic selection of stored locations. This made it an important early form of random-access memory.

Instruction set and programming

The Baby’s instruction set was intentionally small. A word used as an instruction contained a five-bit memory address and a three-bit function field; much of the 32-bit word was unused for instruction encoding. The function field allowed eight encodings, but two represented subtraction, leaving seven distinct operations.

These operations provided:

  • Loading the negative of a value from memory into the accumulator.
  • Storing the accumulator’s contents in memory.
  • Subtracting a memory value from the accumulator.
  • An unconditional transfer of control.
  • A relative transfer of control.
  • A conditional skip based on whether the accumulator was negative.
  • Stopping execution.

There was no dedicated addition instruction. Addition could instead be constructed from negation and subtraction. Multiplication and division likewise required sequences of simpler operations. Signed numbers used two’s-complement representation.

Programs were entered manually using switches, and results were inspected on cathode-ray-tube displays. The Baby had no operating system, compiler, keyboard terminal, or conventional printed output. Programming required direct manipulation of machine code and careful allocation of the small store.

Because instructions and data shared writable memory, programs could also alter stored instructions. This capability was a consequence of the stored-program design, although it made understanding and checking program behavior more demanding.

The first successful program

The first successful run took place on 21 June 1948. The program, written by Kilburn, found the largest proper divisor of 2182^{18}, or 262,144. Its result was 2172^{17}, or 131,072.

The program contained 17 instructions. Rather than using a fast mathematical method, it tested candidate divisors through repeated subtraction. It ran for approximately 52 minutes and executed about 3.5 million instructions.

The lengthy calculation was appropriate to the machine’s experimental purpose. The objective was not to solve a difficult mathematical problem efficiently, but to establish that the computer could execute a substantial sequence of instructions while its memory remained reliable. The successful run tested arithmetic, branching, instruction retrieval, and repeated memory access together.

Historical significance

The Baby’s distinction is specific: it was the first electronic digital computer to execute a program stored in electronic read–write memory. It was not the first calculating machine, the first programmable machine, or the first electronic computer.

Earlier machines had demonstrated important parts of electronic computation. For example, ENIAC performed electronic arithmetic before the Baby, but its original programming arrangements relied on switches and plugboard connections rather than instructions fetched from a shared electronic read–write store.

The stored-program concept also preceded the Baby’s successful run. Theoretical and design work by several researchers had already explored representing instructions as information in memory. The Baby’s contribution was an operational demonstration that this arrangement could work with electronic storage.

Its achievement should therefore be distinguished from both the invention of the underlying concept and the construction of a useful general-purpose computing service. The Baby demonstrated a foundational mechanism, but its tiny memory and limited input and output made it unsuitable for routine scientific or administrative work.

Successors and reconstruction

Experience with the Baby fed into the Manchester Mark 1, which became operational in 1949. The later machine expanded the memory and instruction facilities and introduced more practical computing capabilities. The Manchester project also contributed to the development of the Ferranti Mark 1, an early commercially supplied general-purpose electronic computer.

The original Baby was not preserved as an intact machine: it was developed and modified as the Manchester project progressed. A working replica was built for the fiftieth anniversary of the first successful run in 1998 and is housed at Manchester’s Science and Industry Museum. It demonstrates the machine’s switch-based programming, cathode-ray-tube storage displays, and serial electronic operation.