Manchester Baby facts for kids
Replica of the Baby at the Science and Industry Museum in Castlefield, Manchester
|
|
| Also known as | Small-Scale Experimental Machine |
|---|---|
| Developer | Frederic Calland Williams Tom Kilburn Geoff Tootill |
| Product family | Manchester computers |
| Release date | 21 June 1948 |
| Memory | 1 kilobit (1,024 bits) |
| Successor | Manchester Mark 1 |
The Manchester Baby, also known as the Small-Scale Experimental Machine (SSEM), was a super important computer. It was the first one that could store its own instructions (a 'stored-program computer'). It was built at the University of Manchester by Frederic C. Williams, Tom Kilburn, and Geoff Tootill. It ran its very first program on June 21, 1948.
The Baby wasn't made to be a computer for everyday use. Instead, it was built to test a new kind of memory called the Williams tube. This was the first true random-access memory, meaning it could quickly find any piece of information. Even though it was described as "small and primitive" later, the Baby was the first machine to have all the key parts of a modern electronic digital computer.
Once the Baby proved its design worked, the university started building a bigger, more powerful machine called the Manchester Mark 1. This Mark 1 then became the model for the Ferranti Mark 1, which was the world's first computer sold to businesses.
The Baby used 32-bit "words" (like chunks of data) and could store 32 of these words in its memory. This was about 1 kilobit, or 1,024 bits. It was designed to be the simplest stored-program computer possible. So, it could only do subtraction and change a number to its opposite (negation) using its hardware. Other math, like addition, had to be done using software instructions.
The first program for the Baby found the largest number that could divide 218 (which is 262,144) without leaving a remainder. It did this by trying every number from 218 downwards. This program took a long time to run, about 52 minutes, and performed about 3.5 million operations. This showed how reliable the computer was. It found the correct answer, 131,072.
Contents
How Computers Started
The idea for a computer that could follow a program came from Charles Babbage in the 1830s. Later, in 1936, a mathematician named Alan Turing described a theoretical machine called a Turing machine. This was a concept to understand how far mechanical calculations could go. Turing imagined a person, called a "computer," who would follow instructions from a tape. He proved that if you could write down steps to solve a math problem, a Turing machine could do it.
The Konrad Zuse's Z3 was the world's first working computer that could be programmed and worked automatically. It used binary numbers (0s and 1s) for its math. However, it stored its program on an external tape and used electrical switches, not electronics. Other early electronic computers, like the Atanasoff–Berry computer (ABC) from 1942 and the Colossus from 1943, were not "stored-program" machines. This means they couldn't keep their instructions in their own memory.
The ENIAC (1946) was the first electronic computer that was both automatic and general-purpose. It could solve many different problems. But, changing its program meant manually rewiring switches, which could take days! Researchers like Turing and Zuse thought about using the computer's own memory to hold the program as well as the data. John von Neumann wrote a famous paper describing this idea, which is still used in almost all computers today.
Building a von Neumann computer needed a good way to store the program. During World War II, scientists working on radar developed a type of memory called a delay line. The first practical one was the mercury delay line. Radar sends out quick bursts of radio energy. To filter out reflections from still objects, each received pulse was compared to the one before it. To do this, the pulse was delayed by sending it through a special line.
After the war, many projects started to build stored-program computers. Alan Turing joined the National Physical Laboratory (NPL) in 1945 and designed a computer called the Automatic Computing Engine (ACE). Other projects included EDVAC in the US and EDSAC in Cambridge, UK.
The NPL didn't have the skills to build ACE, so they asked for help from other experts. Frederic C. Williams was working on a different type of memory using cathode-ray tubes (CRTs) for radar. He was about to become a professor at the University of Manchester. The NPL agreed to let some technicians work with Williams at the university.
The Williams–Kilburn Tube
Some early computers used mercury delay-line memory, but it had problems. It was heavy, expensive, and couldn't access data quickly. Also, because data was stored as sound waves in mercury, the temperature had to be controlled very carefully. Williams had seen an experiment showing that CRTs could be used instead of delay lines.
Before joining the University of Manchester in 1946, Williams and Tom Kilburn developed a new electronic memory using a standard CRT. This was called the Williams tube or Williams–Kilburn tube. It was the first electronic memory that could access data randomly. The Baby was designed to show that this new memory could reliably store and retrieve data fast enough for a computer.
For a binary computer, the tube needed to store either a 0 or a 1 at each spot. It did this by showing a dash or a dot on the screen. A dash created a positive electrical charge, and a dot created a negative charge. A detector plate in front of the screen could pick up these charges. A negative charge meant 0, and a positive charge meant 1. The charge would fade in about 0.2 seconds, but the computer could automatically refresh it.
The Williams tube in the Baby used a 12-inch CRT. A smaller 6-inch tube was used in the later Mark I computer.
Starting the Project
After working on the Colossus computer during World War II, Max Newman wanted to build a computer that combined Alan Turing's ideas with the stored-program concept from John von Neumann. In 1945, Newman became a professor at Manchester University. He brought some of his Colossus team with him and recruited F. C. Williams to work on a new computer project. Newman got money for the project from the Royal Society.
"With the university's support, funding from the Royal Society, and a great team of mathematicians and engineers, Newman had everything ready for his computer-building plan. Like he did at Bletchley Park, Newman let his team handle the detailed work while he managed the whole project."
—David Anderson, historian
After becoming a professor at Manchester University, Williams brought his colleague Tom Kilburn to work with him. By late 1947, they had made the Williams tube store more information – 2,048 bits arranged in a 64 by 32-bit grid. They showed it could hold these bits for four hours. Engineer Geoff Tootill joined the team in September 1947.
"Let's be clear, neither Tom Kilburn nor I knew anything about computers when we arrived at Manchester University... Newman explained how a computer works to us."
Kilburn found it hard to remember where he got his ideas for the machine's design:
"[I]n that period, somehow or other I knew what a digital computer was . . . Where I got this knowledge from I’ve no idea."
Historian Jack Copeland explains that Kilburn's first design was influenced by Turing. But he later switched to a design that used an "accumulator" (a special storage area for calculations), which was an idea von Neumann supported.
The Baby's instruction set (the basic commands it understood) had seven operations. This was a simpler version of a twelve-operation set suggested by Jack Good in 1947. Good's document was the first known place where the machine was called "Baby."
Building and Design
Even though Newman didn't help build the Baby, he was very supportive. He helped get old war supplies for its construction, including metal racks and parts from two Colossus computers.
By June 1948, the Baby was built and working. It was about 17 feet long and 7 feet 4 inches tall. It weighed almost 1 ton. The machine had 550 vacuum tubes (also called valves) and used 3500 watts of power.
The Baby used one Williams tube for its main memory (32 by 32-bit words). A second tube held a 32-bit accumulator, where temporary results were stored. A third tube held the current program instruction and its memory address. A fourth CRT, without the storage parts, was used to show the results.
Each 32-bit word in memory could be either a program instruction or data. In an instruction, bits 0–12 told the computer where to find the data it needed. Bits 13–15 told it what operation to do, like storing a number. The other 16 bits were not used. The Baby's design meant that most operations only needed one piece of information from memory. The other piece was already in the accumulator or the program counter.
Reading, writing, or refreshing a word in memory took 360 microseconds. An instruction took four times longer to execute. This meant the Baby could perform about 700 instructions per second. The main memory was constantly refreshed, which took 20 milliseconds to complete for all 32 words.
The Baby used a system called two's complement for negative numbers, which many computers still use. In this system, the first bit tells you if the number is positive (0) or negative (1). So, each 32-bit word could hold numbers from about -2.1 billion to +2.1 billion.
Programming the Baby
The Baby's instruction format had a three-bit "operation code," which allowed it to have up to eight different instructions. Unlike modern computers, the Baby read numbers from left to right, starting with the smallest digits. So, the number one was "100" instead of "001."
| Binary code | Original notation | Modern name | What it does |
|---|---|---|---|
| 000 | S, Cl | JMP S | Jump to the instruction at the memory address S (go to a specific instruction) |
| 100 | Add S, Cl | JRP S | Jump to an instruction that is a certain number of steps away from the current one (relative jump) |
| 010 | -S, C | LDN S | Take the number from memory address S, make it negative, and put it in the accumulator |
| 110 | c, S | STO S | Store the number from the accumulator into memory address S |
| 001 or 101 |
SUB S | SUB S | Subtract the number at memory address S from the accumulator, and put the result back in the accumulator |
| 011 | Test | CMP | If the accumulator has a negative number, skip the next instruction |
| 111 | Stop | STP | Stop the computer |
The Baby could only subtract and negate numbers directly. Adding two numbers, X and Y, needed four instructions:
LDN X // load negative X into the accumulator SUB Y // subtract Y from the value in the accumulator STO S // store the result at S LDN S // load negative value at S into the accumulator
Programs were put into the Baby by setting each bit (0 or 1) using 32 buttons and switches. The Baby didn't have a way to read paper tapes or punch cards.
First Programs
Three programs were written for the Baby. The first one, with 17 instructions, was written by Kilburn. It ran on June 21, 1948. It was designed to find the largest number that could divide 218 (262,144) evenly. It did this by repeatedly subtracting numbers. The Baby took 3.5 million operations and 52 minutes to get the answer, which was 131,072.
Geoff Tootill made a changed version of the program the next month. In mid-July, Alan Turing submitted the third program, which performed long division. Turing had joined the mathematics department at Manchester University in September 1948.
What Came Next
Williams and Kilburn wrote about the Baby in a letter to the journal Nature, published in September 1948. The Baby's success quickly led to building a more practical computer, the Manchester Mark 1. Work on it started in August 1948. The first version was working by April 1949. This then led directly to the Ferranti Mark 1, which was the world's first computer sold for general use.
Lasting Impact
In 1998, a working copy of the Baby was built to celebrate 50 years since its first program ran. This replica is now on display at the Museum of Science and Industry in Manchester. You can often see demonstrations of the machine working there.
In 2008, an original wide photograph of the entire machine was found at the University of Manchester. This photo was taken on December 15, 1948, by a student named Alec Robinson. It was later shown in The Illustrated London News in June 1949.
