Sheet 101 001 Machines

The Manchester Baby Computer: Its History and How It Worked

On 21 June 1948 a rack of war-surplus valves in a Manchester university laboratory ran a program stored in its own memory. It took 52 minutes to find one number.

First run
21 June 1948
Place
Victoria University of Manchester
Memory
32 words of 32 bits
Valves
550
Engraved pen-and-ink drawing of the Manchester Baby: tall steel racks of valves and wiring with a round cathode ray tube display at the centre
Fig. 1 / MANCHESTER BABYSheet 101
On this sheet / 7 parts

The Manchester Baby computer was never meant to be famous. Its formal name, the Small-Scale Experimental Machine, describes what it was: a test rig, built in a laboratory at the Victoria University of Manchester to find out whether a cathode ray tube could hold numbers reliably enough to be a computer's memory. On 21 June 1948 it answered that question by running a program stored in that memory, and so became the first stored-program computer to work.

Frederic Williams, Tom Kilburn and Geoff Tootill built it in about six months. Construction started in December 1947. It was working by June.

Why a memory was the hard part

By 1946 several groups knew how to make valves count. Colossus and ENIAC had shown that electronic circuits could do arithmetic at speed, but each job on them was set up with switches and plugged connections. The idea that a program could sit in the same fast memory as its data, and be changed as easily, was understood on paper. What nobody had was a memory that was fast, reasonably cheap and big enough.

Williams's answer was the face of a cathode ray tube, which can hold a pattern of electric charge. He recruited Kilburn on secondment from the Telecommunications Research Establishment, the wartime radar laboratory, to make it work. By autumn 1947 they had stored 2,048 bits on a single tube and kept them for about four hours, which was long enough to justify building a machine around it.

A short history of the build

Max Newman, who held the Fielden Chair of Pure Mathematics, had secured Royal Society funding for computing work at Manchester. He also arranged war-surplus supplies, including Post Office metal racks and parts from two Colossi. Tootill came on loan from the Telecommunications Research Establishment in September 1947 and stayed until April 1949. Seen as a piece of history, the Baby is less a finished product than a proof that the memory worked.

The result was 17 feet (5.2 metres) long, 7 feet 4 inches (2.24 metres) tall and weighed almost a ton. It used 550 valves, 300 of them diodes and 250 pentodes, and drew about 3,500 watts. Williams and Kilburn described it in a letter to Nature published on 25 September 1948.

Alan Turing, appointed a reader at Manchester in September 1948, sent in a program for long division in the middle of July that year, one of the earliest programs written for the machine.

How it worked: the Williams tube

How it worked is easiest to follow on the display tube, where every bit of memory showed as a dot or a dash. A Williams tube is a cathode ray tube used as a store. When the electron beam strikes a spot on the inside of the screen it leaves a tiny electric charge, and the shape of the spot can stand for a 1 or a 0. A metal pickup plate over the front of the tube senses that charge when the beam comes back to the same spot. Reading disturbs the charge and it fades anyway, so the machine rewrites every spot over and over; on the Baby a full refresh took 20 milliseconds.

The Small-Scale Experimental Machine had three of these tubes. One, a 12-inch CV1131, held the main store of 32 words, each 32 bits long. A second held the accumulator, where results were built up, and a third held the instruction currently being obeyed. A fourth tube showed the contents of the store as a grid of dots, so the operators could literally watch the memory.

Arithmetic was minimal. The hardware could subtract and negate, and nothing else. Addition had to be done by subtracting a negative number. The instruction set had seven orders: two kinds of jump, load negative, store, subtract, a test that skipped the next instruction if the accumulator was negative, and stop. A word took 360 microseconds to reach, and the machine managed roughly 700 instructions a second.

You set a program by entering it bit by bit on a row of switches, one line of the store at a time. Then you pressed start and watched the display tube.

The highest-factor program

Kilburn wrote the first program. It looked for the highest proper factor of 2 to the power 18, which is 262,144, by trying each whole number downwards from one less than that and checking whether it divided exactly. With no divide instruction, each check was a long run of repeated subtractions. The program was 17 instructions long and filled 25 words of the store including eight words of working space. It ran for about 52 minutes, carried out about 3.5 million operations, and stopped with 131,072 on the display.

The answer was obvious in advance, which was the point. A known result proved that the store had held its contents correctly for nearly an hour while the machine hammered it. Tootill wrote an amended version the following month.

Manchester Baby computer specifications

ItemSmall-Scale Experimental Machine
First program run21 June 1948
BuildersF.C. Williams, Tom Kilburn, Geoff Tootill
Word length32 bits
Main store32 words (1,024 bits) on one Williams tube
Store tubeCV1131, 12-inch
Other tubesAccumulator, control (current instruction), display
Instructions7 (JMP, JRP, LDN, STO, SUB, CMP, STP)
Hardware arithmeticSubtraction and negation only
Word access time360 microseconds
SpeedAbout 700 instructions per second
Valves550 (300 diodes, 250 pentodes)
Power3,500 watts
Size5.2 m long, 2.24 m tall, almost 1 ton
Tool / Run the first program

Watch the Baby find a factor

In June 1948 the Baby was asked one question: what is the largest number that divides 218 = 262,144 exactly? It could not divide, only subtract. So it tried every number downwards from 262,143 and, for each, subtracted it again and again to see whether anything was left over. Press Run to watch it work.

Question
Now trying262,144Press Run
0% of the search
  1. 1Pick a divisor. Start one below the number and count down.
  2. 2Subtract it repeatedly from the number until the result drops below zero.
  3. 3Check what is left. Nothing left over means the divisor is a factor, and the machine stops.
Instructions0
At 1948 speed0 s
Answer-

On the tube each row is one 32-bit word: a long dash is a 1, a dot is a 0. The red row is the instruction being carried out; the bright row lower down is the divisor being tested. Times assume about 1,100 instructions a second, the rate of the first run (some 3.5 million operations in 52 minutes). This program uses the Baby's seven instructions and Kilburn's method, though not his exact listing.

From the Baby to the Ferranti Mark 1

The Manchester Baby computer was quickly enlarged. The Manchester Mark 1 was working by April 1949 and used the smaller 6-inch CV1097 tube. Ferranti, whose works were at Hollinwood near Oldham, then turned the design into a product, and the first Ferranti Mark 1 was delivered to the university in February 1951 and shown to the public in July. It was the first electronic general-purpose stored-program computer offered for sale, with eight Williams tubes in its main store and a magnetic drum behind them. Towards the end of 1951 the BBC recorded it playing a medley that included God Save the King and In the Mood, programmed by Christopher Strachey. The later history of the design runs through these two machines rather than through the Baby itself.

The same university group went on to the transistor computer that Metropolitan-Vickers adopted for its Metrovick 950 in 1956. For the wider setting of Manchester's machine builders, see the Machines section; for the electricity that kept a 3,500-watt machine running, the story of the region's power stations is a useful companion.

Common misconceptions

Most mistakes about how it worked come from treating it as a smaller version of a modern computer. The Manchester Baby computer is sometimes called the first computer of any kind. It was not, and the claim does it no favours: what makes it matter is that it was the first stored-program computer, the arrangement every phone and laptop still relies on. Another misreading is that Turing built it. He arrived at Manchester after it had run, wrote programs for it and its successors, and had no part in the hardware.

A working replica was built in 1998 for the fiftieth anniversary of that first run in June 1948.

Questions readers ask.

Notes / 05
Q01

What was the Manchester Baby?

The Manchester Baby, formally the Small-Scale Experimental Machine (SSEM), was an electronic computer built at the Victoria University of Manchester by Frederic Williams, Tom Kilburn and Geoff Tootill. On 21 June 1948 it became the first computer to run a program held in its own electronic memory. It was built mainly to test the Williams tube as a form of random-access storage.

Q02

Why was it called the Baby?

It was a deliberately small machine, built to prove that the cathode ray tube store worked before a full-size computer was attempted. Its official name, Small-Scale Experimental Machine, says the same thing. The larger Manchester Mark 1 that followed it was working by April 1949.

Q03

Was the Manchester Baby the first computer?

No. Electronic machines such as Colossus and ENIAC came earlier, but they were set up for each job with switches and plug connections. The Baby was the first to keep its program in the same electronic memory as its data, which is why it is described as the first stored-program computer.

Q04

How much memory did the Manchester Baby have?

Its main store held 32 words of 32 bits each, 1,024 bits in total, on a single Williams tube. By autumn 1947 the team had stored 2,048 bits on one tube and kept them for about four hours in tests, but the Baby itself used the 32-word arrangement.

Q05

What did the first program on the Baby do?

Tom Kilburn's program found the highest proper factor of 2 to the power 18 (262,144) by trying every integer downwards from one below that number. Because the machine could only subtract, each division was done by repeated subtraction. The program used 17 instructions, ran for about 52 minutes and gave the answer 131,072.