Manchester Mark 1 facts for kids
The Manchester Mark 1 was one of the world's first stored-program computers
|
|
| Product family | Manchester computers |
|---|---|
| Predecessor | Manchester Baby |
| Successor | Ferranti Mark 1 |
The Manchester Mark 1 was one of the very first stored-program computers. It was built in England at the Victoria University of Manchester. This amazing machine grew out of an earlier computer called the Manchester Baby, which started working in June 1948.
Work on the Mark 1 began in August 1948. The first version was ready by April 1949. A special program designed to find Mersenne primes (a type of prime number) ran perfectly for nine hours straight on the night of June 16/17, 1949.
News of the computer's success spread quickly in the British newspapers. They often called it an "electronic brain." This description led to a big discussion about whether computers could ever truly be creative, a debate that continues even today!
The main goal for the Mark 1 was to give the university a powerful computer for research. It also helped scientists learn how to use computers in real life. But it quickly became much more! It served as a blueprint for Ferranti to build the world's first computer that people could buy.
Development on the Mark 1 stopped at the end of 1949. The machine was taken apart in late 1950. In February 1951, it was replaced by the Ferranti Mark 1.
The Manchester Mark 1 is super important in history because it was one of the first to use index registers. This clever invention made it much easier for programs to read lists of numbers (called "words") stored in the computer's memory.
Thirty-four patents (special rights for inventions) came from building this machine. Many of its ideas were used in later computers, like the IBM 701 and 702, as well as the Ferranti Mark 1. The main designers, Frederic C. Williams and Tom Kilburn, learned from the Mark 1 that computers would be great for science, not just pure math. In 1951, they started working on Meg, the Mark 1's next version, which would be even better at math.
The Manchester Mark 1 was also known as the Manchester Automatic Digital Machine (or MADM).
Contents
How Computers Began
In 1936, a smart mathematician named Alan Turing described a "universal computing machine." This was a theoretical computer that could store its program and data on a tape. Turing showed that such a machine could solve any math problem if you could write clear steps (an algorithm) for it.
During the 1940s, Turing and others, like Konrad Zuse, thought about storing programs and data in the computer's own memory, not just on tape. But it was mathematician John von Neumann who is often given credit for clearly defining this "stored-program computer" idea. The Manchester Mark 1 was built using his ideas.
Building a von Neumann computer needed a good memory device. The University of Manchester's Manchester Baby was the world's first electronic stored-program computer. It proved that the stored-program idea worked. It also showed how useful the Williams tube was. This was an early type of computer memory that used a standard cathode-ray tube (like an old TV screen). The Baby ran its first program on June 21, 1948.
Early electronic computers were usually programmed by changing their wires or using special plugs. They didn't store a separate program in memory like modern computers. For example, it could take days to reprogram a computer like ENIAC. Other researchers were also working on stored-program computers, such as the National Physical Laboratory's Pilot ACE and Cambridge University's EDSAC. The Baby and the Mark 1 were special because they used Williams tubes for memory, instead of slower mercury "delay lines."
Around August 1948, the Baby was improved a lot to become a test version for the Manchester Mark 1. The first goal was to give the university a more useful computer. In October 1948, a government scientist named Ben Lockspeiser saw a demonstration of the Mark 1. He was so impressed that he quickly arranged a contract with a local company called Ferranti. They were to build a commercial version of the machine, which became the Ferranti Mark 1.
From that moment on, the Mark 1 had two main goals: to be a university computer and to provide Ferranti with a design for their commercial machine.
Building the Mark 1
The Baby computer was designed by a team including Frederic C. Williams, Tom Kilburn, and Geoff Tootill. For the Mark 1, two more students, D. B. G. Edwards and G. E. Thomas, joined them. Serious work started in August 1948.
The project had two purposes: to give Ferranti a working design for their commercial Ferranti Mark 1, and to build a computer that would help researchers learn how to use such a machine. The first version of the Manchester Mark 1, called the Intermediary Version, was working by April 1949.
However, this first version couldn't easily move data between its main memory and its new magnetic storage. This had to be done by stopping the machine and manually starting the transfer. These missing features were added to the Final Specification version, which was fully working by October 1949.
The machine used 4,050 valves (like old light bulbs) and used 25 kilowatts of power. To make it more reliable, special CRTs (screens) were used for memory instead of the standard ones used in the Baby.
The Baby used 32-bit "words" (groups of data). The Mark 1 increased this to 40 bits. Each word could hold one 40-bit number or two 20-bit program instructions. The main memory started with two Williams tubes, each holding two groups of 32 x 40-bit words (called "pages"). It also had a magnetic drum that could store 32 more pages.
The Final Specification version increased the main memory to eight pages on four Williams tubes. It also had 128 magnetic drum pages for extra storage. The 12-inch wide drum had many magnetic tracks, each with its own read/write head. Each track held 2,560 bits. The drum spun around in 30 milliseconds. Data was recorded onto the drum using a method called Manchester coding.
The computer's instruction set (the list of commands it understood) grew from 7 in the Baby to 26 in the Mark 1. This included multiplication done directly by the hardware. It later increased to 30 instructions. Ten bits of each word were used for the instruction code. A standard instruction took 1.8 milliseconds, but multiplication was slower.
The most important new feature of the Mark 1 was its index registers. These are common in modern computers. The Baby had two main memory areas: the accumulator (A) and the program counter (C). The Mark 1 added a third area (B) for the two index registers. These registers could change program instructions, making it easy to go through a list of numbers in memory. The Mark 1 also had a fourth area (M) to help with multiplication.
How to Program the Mark 1
Each program instruction used 20 bits. Ten of these bits were for the instruction code, which meant the computer could understand 1,024 (210) different commands. It started with 26 commands, and later had 30 when commands were added to move data between the magnetic drum and the main memory.
On the first version of the Mark 1, programs were put in using key switches. The results were shown as dots and dashes on a screen, just like on the Baby. But the Final Specification machine, finished in October 1949, got a teleprinter with a paper-tape reader and punch.
Alan Turing, who worked at the University of Manchester, created a special base 32 code for the paper tape. This code was based on the standard ITA2 5-bit teleprinter code. It allowed programs and data to be written to and read from paper tape. The ITA2 system uses 5 bits to represent 32 different characters. For example, "10010" meant "D." Turing changed only a few of the standard codes. For instance, "00000" (which usually means "no effect") was shown as "/" (forward slash).
Since the Mark 1 used 40-bit words, it needed eight 5-bit teleprinter characters to encode each word. So, a binary word like "10001 10010 10100 01001 10001 11001 01010 10110" would be written on paper tape as ZDSLZWRF. You could also type numbers into the computer using the teleprinter's keyboard, and the computer could print out results. The machine worked using binary numbers inside, but it could change numbers between decimal (our normal numbers) and binary for input and output.
There was no special programming language like assembly language for the Mark 1. Programs had to be written in binary code. Programmers were encouraged to learn Turing's special code to make their work easier. The Mark 1 didn't have hardware interrupts. This meant that after starting a read or write operation, the program would keep going until it hit another input/output command. Then, it would wait for the first operation to finish.
The Mark 1 didn't have an operating system like computers today. Its only system software was a few basic routines for input and output. Like the Baby, the Mark 1 stored numbers with the least important digits on the left. So, the number one was "10000" in five bits, not "00001." Negative numbers were stored using a method called two's complement, which many computers still use today. In this system, the first bit tells you if the number is positive (0) or negative (1). This meant a 40-bit word could hold numbers from -549,755,813,888 to +549,755,813,887.
First Programs Run
The first important program run on the Mark 1 was a search for Mersenne primes. This happened in early April 1949. The program ran without any errors for nine hours on the night of June 16/17, 1949.
The idea for the program came from Max Newman, who was the head of the Mathematics Department at the University of Manchester. The program itself was written by Kilburn and Tootill. Later, Alan Turing wrote an even faster version of the program, which he called the Mersenne Express.
The Manchester Mark 1 kept doing useful math work until 1950. This included looking into the Riemann hypothesis (a famous math problem) and doing calculations for optics (the study of light).
What Happened Next
Tootill temporarily moved from the University of Manchester to Ferranti in August 1949. He spent four months helping Ferranti with the design of their Ferranti Mark 1. The Manchester Mark 1 was taken apart and scrapped in August 1950. A few months later, the first Ferranti Mark 1 took its place. This was the world's first general-purpose computer that was sold to businesses.
Between 1946 and 1949, the team designing the Mark 1 and the Baby had about four people. During this time, 34 patents were filed based on their work. In July 1949, IBM invited Williams to the United States to talk about the Mark 1's design. IBM later bought licenses for several of the patented ideas from the Mark 1, including the Williams tube. They used these ideas in their own 701 and 702 computers. Perhaps the most important idea from the Manchester Mark 1 was its use of index registers. The patent for this was given to Williams, Kilburn, Tootill, and Newman.
Kilburn and Williams realized that computers would be used more for science than just pure math. So, they decided to build a new machine that would be even better at complex math. Work started in 1951. The new machine, which ran its first program in May 1954, was called Meg. It was smaller, simpler, and much faster for math problems than the Mark 1. Ferranti later made a version of Meg that used more reliable core memory instead of Williams tubes. They sold this as the Ferranti Mercury.
How the Mark 1 Changed Things
The success of the Manchester Mark 1 and the Baby was big news in the British press. Newspapers often called these machines "electronic brains." Lord Louis Mountbatten had used this term earlier in a speech in 1946. He wondered how the simple computers of his time might grow and change.
The excitement around the Mark 1 in 1949, which was seen as the first truly modern computer, surprised its creators. Sir Geoffrey Jefferson, a professor of brain surgery at the University of Manchester, gave a famous speech on June 9, 1949. He chose "The Mind of Mechanical Man" as his topic. His goal was to "debunk" (show the flaws in) the idea of the Manchester computer project. In his speech, he said:
Not until a machine can write a sonnet or compose a concerto because of thoughts and emotions felt, and not by the chance fall of symbols, could we agree that machine equals brain – that is, not only write it but know that it had written it. No machine could feel pleasure at its success, grief when its valves fuse, be warmed by flattery, be made miserable by its mistakes, be charmed by sex, be angry or miserable when it cannot get what it wants.
The Times newspaper reported on Jefferson's speech the next day. They added that Jefferson believed "the day would never dawn when the gracious rooms of the Royal Society would be converted into garages to house these new fellows." This was seen as a direct insult to Newman, who had received money from the Royal Society to continue the Manchester team's work.
In response, Newman wrote an article for The Times. He argued that the Mark 1's structure was very similar to the human brain. His article included an interview with Turing, who added:
This is only a foretaste of what is to come, and only the shadow of what is going to be. We have to have some experience with the machine before we really know its capabilities. It may take years before we settle down to the new possibilities, but I do not see why it should not enter any of the fields normally covered by the human intellect and eventually compete on equal terms.
Images for kids
-
Functional schematic showing the Williams tubes in green. Tube C holds the current instruction and its address; A is the accumulator; M is used to hold the multiplicand and the multiplier for a multiply operation; and B contains the index registers, used to modify instructions.
-
Section of punched tape showing how one 40-bit word was encoded as eight 5-bit characters
See also
- History of computing hardware
- List of vacuum tube computers
- Manchester computers
