Coming together is a beginning; keeping together is progress; working together is success.
The world’s first stored-program electronic digital computer, the English Small Scale Experimental Machine (SSEM, nicknamed the Baby) successfully executed its first program on 21 June 1948. That program was written by Tom Kilburn, who actually built the machine, designed by his mentor—Frederic (Freddie) Williams.
Frederic Calland Williams (1911-1977) gained a BSc (1932) and MSc (1933) degrees in Engineering at the University of Manchester, and a Doctor degree at Oxford University. Then he took up the post of Assistant Lecturer in his old department at Manchester. During the next few years, Williams made many outstanding contributions to research in electronics, publishing some 20 papers. Two of these were with Prof. Blackett on an automatic curve follower for the Hartree Differential Analyser, a famous mechanical calculator constructed at the University of Manchester in the early thirties.
During WWII Williams made outstanding contributions to the electronics of radar and other military equipment, producing, amongst other things, the first operational amplifier. In June 1946 he started investigating the storage of both analog and digital information on a Cathode Ray Tube. Storage of analog information could help solve the problem of static objects cluttering the dynamic picture on a radar screen. Storage of digital data could solve the problem holding up the development of computers worldwide, i.e. lack of a storage mechanism that would work at electronic speeds. Williams demonstrated the successful operation of a single-bit memory using the anticipation pulse method in October and provisionally patented this system in December 1946.
The bit was stored in the form of a charge on the CRT screen’s phosphor, which could be controlled by the electron beam to write a 0 or a 1. Although the phosphor was an electrical insulator, the charge would leak away in the order of a second. Williams arranged to read the charge and then rewrite it continuously at electronic speeds so that information could be kept permanently; this process was called regeneration and the principle is still used today to replenish charge on modern integrated circuit RAMs.
In December 1946 Freddie Williams moved to the University of Manchester to take up a chair in Electro-Technics. He continued to work on the system, and some of his group members followed him, between them was Tom Kilburn (1921-2001), a mathematician, who had worked in his group since 1942. At the end of 1947, 2048 bits were being stored on a standard single 6-inch diameter CRT, and an internal report had been written by Tom Kilburn introducing the “dot-dash” and the “defocus-focus” methods of operation of the CRT and the design of a hypothetical computer. This report aroused considerable interest and was widely circulated in the UK and USA. The CRT storage system became known as the Williams Tube.
Though the store could remember 2048 bits, an individual bit could only be reset by hand, and it was necessary to test its capability of setting and reading any required bit at electronic speeds and remembering its value indefinitely between settings. So the next step was to build a small computer around a CRT memory, to subject it to the “most effective and searching tests possible”. Williams and Kilburn knew all about electronics, but a little about computers, so they headed for consultations with their colleagues, the famous mathematicians Alan Turing and Max Newman, the creator of Colossus. Using the advice of computer geniuses, Williams designed the computer, which was built mainly by Kilburn and his colleagues.
This computer was built in half a year—the Small Scale Experimental Machine (SSEM) included the stored-program concept so that the Random Access Memory was used not only to hold numbers involved in calculations but also to hold the program instructions. This meant that instructions could be read successively at electronic speed and that running a different program only involved resetting part of the memory using a simple keyboard rather than reconfiguring the electronic circuitry (this could take days on ENIAC).
Work on building the SSEM took place in the first half of 1948 and was mainly carried out by Tom Kilburn with the assistance of Geoff Tootill. The arithmetical device was built by vacuum tubes, while the memory, registers, and display were based on Williams Tubes. The input was a keyboard.
The Baby machine had the following properties:
• 32-bit word length
• Serial binary arithmetic using 2’s complement integer numbers
• A single address format order code
• A random access main store of 32 words initially, extendable up to 8192 words
• A computing speed of around 1.2 milliseconds per instruction
There are 4 Williams Tubes in the Baby. The main store was a 32/32-bit array on a Williams Tube. In addition, there were two other Williams tubes holding special storage “registers”: one held the accumulator A and the other the address of the current Instruction CI (“Control Instruction”) and the instruction itself PI (“Present Instruction”). The fourth tube, the Display Tube could be switched to provide a suitable display of the current contents of any of the Williams Tubes.
The instruction format was:
3-bit function field (bits 13 to 15) + 13-bit store address (0 to 12) + 16 bits unused
There were just 7 instructions (with S representing the contents of the word with address S):
• A = – S
• A = A – S
• S = A
• If A < 0, CI = CI + 1 (i.e. if A negative, skip the next instruction)
• CI = S
• CI = CI + S
• Halt the program
Note the surprising use of the minus operator and the complication/sophistication of using the contents of a store location rather than a store address itself as the operand in control jumps. CI had to be reset to the instruction before the next to be obeyed. Note also however that within two months the Baby had been enhanced to a 4-bit instruction code (not all used), including A = S, A = A + S, and A = A & S.
Input to the Baby was by setting sequences of bits at chosen addresses using a simple keyboard. The output was by reading the information on the Display Tube.
Three demonstration programs were run on the prototype, including one written by Turing, which used a long division routine.
The first program (see the nearby image) to run successfully, was executed on 21 June 1948 and was written by Tom Kilburn. It was a program to find the highest proper factor of any number a, which was done by trying every integer b from a-1 downward until one was found that divided exactly into a. The necessary divisions were done not by long division but by repeated subtraction of b (because the “Baby” only had a hardware subtractor).
The original number chosen was quite small, but within a few days the program was tried on 218; here around 130000 numbers were tested, which took about 2.1 million instructions and involved 3 and a half million store accesses. The correct answer was obtained in a 52-minute run.
Williams later said of the first successful run:
A program was laboriously inserted and the start switch pressed. Immediately the spots on the display tube entered a mad dance. In early trials it was a dance of death leading to no useful result, and what was even worse, without yielding any clue as to what was wrong. But one day it stopped, and there, shining brightly in the expected place, was the expected answer. It was a moment to remember. This was in June 1948, and nothing was ever the same again.
With the SSEM proving both the effectiveness of the Williams Tube and the basic stored-program concept, work was immediately started, with increased manpower, to design and build a more realistic and usable computer, based on the Baby. This was achieved between late 1948 and late 1949, with the Manchester Mark 1 computer, which was built and was used for a variety of purposes in 1949 and 1950, including investigation of the Riemann hypothesis and calculations in optics. Besides that, in October 1948, a request was made from the English government to Ferranti Ltd. to manufacture a commercial machine to Williams’ specifications. This was the world’s first general-purpose commercial computer, the Ferranti Mark 1.
Ferranti Mark 1
The world’s first commercially available general-purpose electronic computer was the English machine Ferranti Mark 1, launched in February 1951. It was based on the previous computers Small Scale Experimental Machine and Manchester Mark 1 of Frederic Williams and Tom Kilburn.
Only two months after the successful test run of the Small Scale Experimental Machine (aka the Baby) in June 1948, a full-scale version was underway and Ferranti was investigating commercial production, although the progress to commercial production was far from certain because of the financial risks. The first machine was delivered to the University of Manchester on 12 February 1951. Later seven updated versions were sold.
The memory of Mark 1 was based on a 20-bit word stored as a line of dots of electric charges settled on the surface of a Williams–Kilburn tube (a cathode ray tube used as a computer memory to electronically store binary data), each tube storing 64 words (lines of dots). Instructions were stored in a single word, while numbers were stored in two words (40 bits). The main (primary) memory consisted of eight tubes, each storing one such page of 64 words, thus the total main memory was 512 words.
Other Williams tubes stored the single main 80-bit accumulator (A), the 40-bit multiplicand/quotient register (MQ), and eight 20-bit B-lines, or index registers, used to modify instructions. The accumulator could also be addressed as two 40-bit words. An extra 20-bit word per tube stored an offset value in the secondary storage. Secondary storage (an extra 20-bit word per tube) was provided in the form of a 512-page magnetic drum, storing two pages per track, with about 30 milliseconds of revolution time.
The instructions (about fifty in total) had an address and an operator part and used a single address format in which operands were modified and left in the accumulator. The writing of programs was based on a numerical system to the base 32 (a five-bit value). Integer numbers were usually treated as 40-bit double words, negative numbers were represented as two’s complement.
The digit frequency is 100 KHz, giving a 10-microsecond digit-period. The drum is synchronized to the processor’s clock, allowing more than one drum to be added if required. 24 digit-periods (240 microseconds) are known as a beat.
The basic cycle time (needed for arithmetical and logical instructions) was 1.2 milliseconds (5 x 240 microseconds beats), a multiplication could be completed in about 2.16 milliseconds (9 beats), while most other instructions took 4 beats (0.96 ms). The multiplier used almost a quarter of the machine’s 4050 vacuum tubes. Several instructions were included to copy a word of memory from one of the Williams tubes to a paper tape machine or read them back in.
Ferranti Mark 1 had to be programmed by entering alphanumeric characters representing the base 32 (a five-bit) value that could be represented on the paper tape input. The engineers decided to use the simplest mapping between the paper holes and the binary digits they represented, but the mapping between the holes and the physical keyboard was never meant to be a binary mapping.
Ferranti Mark 1 contained approximately 1600 pentodes and 2000 thermionic diodes. The main CPU is contained in two bays, each 5 meters long by 2.7 meters high, and consumed 25kW of power.
The normal input/output equipment for the Ferranti Mark I consisted of paper tape readers operating at 200 characters/second, paper tape punches operating at 15 characters/second, and a teleprinter printing at six characters/second.
The Mark I’s console (see the nearby image) has two large and four small display tubes. The two large tubes at the bottom show two pages of the main memory.
The actual processing was done on four smaller tubes, which were labeled with the first four letters of the alphabet. A, the accumulator, contained the results of the arithmetical and logical operations and also temporarily stored data for the transmission from one line of the page to another. In the C tube (C for control) were the current instruction and its address. The content of auxiliary store B could be added to the current command and thus could modify it before it was carried out. D contained the multiplier in the appropriate calculations.
The remarkable Atlas computer, developed in the period 1956–1962 by a team led by Professor Tom Kilburn at the University of Manchester, was reckoned to be the world’s most powerful computer in the early 1960s and pioneered many software concepts still in common use today, including the Atlas Supervisor, considered by many to be the first recognizable modern operating system, as well as virtual memory and paging techniques.
Atlas was a second-generation machine, using discrete germanium transistors. It had a 48-bit word size and instruction pipelining. The main memory (RAM) was 16K words of the core store (equivalent to 96 KB) and 96K words of the drum store (eq. to 576 KB). It had the capability for the addition of (for the time) sophisticated new peripherals such as magnetic tape.
The concept of virtual memory was initially developed by a German physicist—Fritz-Rudolf Güntsch (1925-2012) at the Technische Universität Berlin in 1956 in his doctoral thesis, Logical Design of a Digital Computer with Multiple Asynchronous Rotating Drums and Automatic High Speed Memory Operation. The thesis described a machine with 6 100-word blocks of primary core memory (introduced by Jay Forrester in Whirlwind computer) and an address space of 1000 100-word blocks, with hardware automatically moving blocks between primary core memory and secondary drum memory.
From their beginnings in the late 1940s, electronic computers had two-level storage systems. In the 1950s, the main memory (today it is RAM) was usually magnetic cores, while the secondary memory was usually magnetic drums. The processor could address only the main memory. A major part of a programmer’s job was to devise a good way to divide a program into blocks and to schedule their moves between the levels. The blocks were called “segments” or “pages” and the movement operations were “overlays” or “swaps”. The designers of the first operating systems in the 1950s dreamt of relieving the programming burden by automating all this storage management.
After the pioneering work of Fritz-Rudolf Güntsch, it became pretty obvious to the designers of operating systems that automatic storage allocation could significantly simplify programming and thus appeared Atlas with the first working prototype of virtual memory (they called it a one-level storage system). At the heart of their idea was a radical innovation—a distinction between “address” and “memory location”. It led them to three inventions.
1. They built hardware that automatically translated each address generated by the processor to its current memory location.
2. They devised demand paging, an interrupt mechanism triggered by the address translator that moved a missing page of data into the main memory.
3. They built a replacement algorithm, a procedure to detect and move the least useful pages back to secondary memory.