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
| Item | Small-Scale Experimental Machine |
|---|---|
| First program run | 21 June 1948 |
| Builders | F.C. Williams, Tom Kilburn, Geoff Tootill |
| Word length | 32 bits |
| Main store | 32 words (1,024 bits) on one Williams tube |
| Store tube | CV1131, 12-inch |
| Other tubes | Accumulator, control (current instruction), display |
| Instructions | 7 (JMP, JRP, LDN, STO, SUB, CMP, STP) |
| Hardware arithmetic | Subtraction and negation only |
| Word access time | 360 microseconds |
| Speed | About 700 instructions per second |
| Valves | 550 (300 diodes, 250 pentodes) |
| Power | 3,500 watts |
| Size | 5.2 m long, 2.24 m tall, almost 1 ton |
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.
- 1Pick a divisor. Start one below the number and count down.
- 2Subtract it repeatedly from the number until the result drops below zero.
- 3Check what is left. Nothing left over means the divisor is a factor, and the machine stops.
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.
