The Staffordshire University Computing Futures Museum Cambridge Page

Back to the Computing Futures Museum Collections Page

The Computer Laboratory is the computer science department of the University of Cambridge. In 1936 a General Board Report on the Establishment of a Computing Laboratory (02.12.36) referred to "recent developments in mechanical and electrical aids to computation" and types of machine, stating that great use was now made of them in all branches of science, and that the important feature of these machines was the speed with which definite answers could be produced. The Laboratory was intended to provide a computing service for general use, and to be a centre for the development of computational techniques in the University. It was founded as the Mathematical Laboratory under the leadership of John Lennard-Jones on 14 May 1937, the only staff member being Maurice V. Wilkes, appointed as a University Demonstrator. The laboratory was to be housed in the North Wing of the former Anatomy School, on the New Museums Site, and was to be used for mechanical computation with a differential analyser, desk machines, etc. However, the Laboratory was not yet opened when it was taken over by Ministry of Supply for use during the war. Wilkes worked at Malvern on radar, and later on operational research.

After the war, on 24.07.46, a General Board Report on the Organisation of the Laboratory reported that the Laboratory had been equipped with a number of the most modern calculating machines, library and workshop facilities had been built up and assistants appointed. Wilkes, who had proposed projects of research work "that would be of great value to the science of computation", was appointed Director with "the duty to advance knowledge of the science of mathematical computation, to promote and direct research in it, and to supervise the work of the Laboratory under the general control of the Mathematical Laboratory Committee." In October 1946 work began on EDSAC 1 (Electronic Delay Storage Automatic Calculator), which subsequently became the world’s first fully operational and practical stored program computer when it ran its first program on 6 May 1949.

In 1947 the Lyons Eelectronic Office (LEO, Messrs J. Lyons and Company, the tea shop company) gave a grant of £3000 for research in the Laboratory, with no attached conditions, and support for an assistant for one year (in practice this was extended to a much longer period).

During 1948 - 1949 research was conducted on programming methods under Wilkes, including definition and refinement of Initial Orders, closed subroutines, and building of a library of subroutines. Professor D.R. Hartree from outside the laboratory also took part in this.


On 06.05.49 the first logged program ran on EDSAC 1 (computing squares of 0-99). This was the first complete and fully operational regular electronic digital stored program computer (the University of Manchester's first machine was the 1948 Small Scale Experimental Machine, built to validate innovative CRT memory technology, and both the Cambridge and Manchester machines were running before the first US machines appeared.

In 1950 a program service began on semi-formal basis, with an operator to run programs (except at night, when authorised users were entitled to run the machine until a valve blew up, a tradition that continued with EDSAC 2). Significant addition to the library routines were the Runge-Kutta-Gill program, and an interpretive floating point routine. An interpreter also became available. X-ray crystallography programs were run.

The department introduced a Summer School in computing in 1950, but a Report noted that it dealt only with "programming", rather than the general theory of the numerical methods which were programmed. The department first taught the Cambridge Diploma in Numerical Analysis and Automatic Computing ("automatic computing" being what would now be called "computer science") from 1953, although this was not an undergraduate degree course. This was a one-year course, and it would be considered a conversion MSc course in modern parlance. The introduction of this graduate course was motivated by a University of Cambridge Mathematics Faculty Board Report on the "demand for postgraduate instruction in numerical analysis and automatic computing" without which "the application to scientific research of the machines now being built will be hampered". It was noted that the Diploma would include theoretical and practical work, and also instruction about the various types of "computing-machine" and the principles of design on which they were based." It was also stated that with only a few students initially, no extra staff would be needed. In its final version, the Diploma was a 10-month course, evaluated two-thirds on examination and one-third on a project dissertation. Most of the examined courses were shared by the second year ("Part IB") of the undergraduate Computer Science Tripos course. There were some additional lectures specifically for the Diploma students, and four of the third year undergraduate ("Part II") lecture courses were also included. There were three grades of result from the Diploma: distinction (roughly equivalent to first class honours), pass (equivalent to second or third class honours), and fail. The Diploma attracted students with degrees in mathematics, science and engineering. At its peak, there were 50 students on the course. However, UK government (EPSRC) funding was withdrawn in 2001, and student numbers then dropped dramatically. In 2007, the University took the decision to withdraw the Diploma at the end of the 2007-08 academical year, after 55 years of service.

In 1951 a film was made of EDSAC 1, and Wilkes, Wheeler, and Gill published the world's first book on programming, The preparation of programs for an electronic digital computer (Addison-Westley 1951). The department inspired the world’s first business computer LEO I, developed by LEO and based on EDSAC 1, which began operation in 1951. Wilkes' paper On the best way to design an automatic calculating machine introduced the idea of microprogramming and bit-slicing. Work also began on EDSAC 2, with a grant from Nuffield Foundation.

In 1952 magnetic tapes were introduced experimentally for EDSAC 1, and there was continuing development of programs and methods e.g. hash tables, recursion with stack, program labels, and Fourier transforms.

In 1953 the Diploma course was started (see above) and there was heavy use of EDSAC 1 for (among other subjects) theoretical chemistry, X-ray molecular biology, numerical analysis, atmospheric oscillations, and early work on radioastronomy. A Priorities Committee was established for the approval of computing projects and resource allocation.

During 1956 - 57 EDSAC 1.5 (with the small control matrix) was running, and in 1958 this was replaced by EDSAC 2, the first microprogrammed and bitsliced computer. On 11.07.58 EDSAC 1 was shut down. EDSAC 2 used fast paper tape for I/O, and magnetic tapes. A small number of basic library subroutines were wired into a ROM.

In 1961 David F. Hartley developed Autocode, one of the first high-level programming languages, for EDSAC 2. Also in that year, proposals for Titan, based on the Ferranti Atlas machine, were developed. There was some automated hardware design done at Cambridge, while the operating system was developed jointly by Cambridge and Ferranti. The Titan machine was designed originally for multi-processing, and the design was modified after Wilkes' visit to MIT in 1963 to support multiple-access, with provision for up to 64 terminals. Titan had a "slave store" (instruction cache) and was designed for very rapid response to interrupts, with more operating system scheduling than was then usual. Work began on the design of CPL, a higher-level language intended for Titan, jointly with the University of London Institute for Computer Science.

In 1962 there was a (then considered large) memory addition of 16K words to EDSAC 2. Titan became fully operational in 1964, with a Temporary Supervisor operating system, and magnetic tapes. In 1965 EDSAC 2 was switched off. Autocode was the first higher-level language on Titan, followed later, under pressure from scientific users, by Fortran. Fifteen years of CAD research began, using a DEC PDP 7 and DEC Type 340 display (the first outside the USA) connected by data-link to the Titan. It later involved a highly innovative numerically-controlled machine for cutting models of metal parts in plastic foam. In 1965 the Diploma was renamed Diploma in Computer Science.

In 1967 a full multi-user time-shared service for up to 64 users was inaugurated on Titan.

In 1968 M. Richards returned from MIT and continued work on BCPL, a language with roots in CPL he had developed, and an ancestor of C. In 1969 there was research on screen editing using the PDP 7.

In 1970 the Mathematical Laboratory was renamed the Computer Laboratory, with separate departments for Teaching and Research and the Computing Service, providing computing services to the university and its colleges. The two did not fully separate until 2001, when the Computer Laboratory moved out to the new William Gates building in West Cambridge, off Madingley Road, leaving behind an independent Computing Service.

In 1973 Titan was switched off. In 1974 the Cambridge RING project was initiated.

In 1980 Professor M.V. Wilkes retired. Development work on the Fast Ring began. In 1981 the BCS Technical Award was mde to the Computer Laboratory for "The Cambridge Digital Communication Ring".

Members of the Computer Laboratory have been involved in the creation of many successful UK IT companies such as Acorn, ARM, nCipher and XenSource. Past members of the Laboratory are now be found in prominent positions all over the US and the UK, in companies and universities. Honours for members of the Laboratory have included two Turing Awards and fellowships of the Royal Society, the Royal Academy of Engineering and the British Academy.

Appendix 1: EDSAC



The 1947 Electronic Delay Storage Automatic Calculator (EDSAC) was inspired by
John von Neumann's seminal First Draft of a Report on the EDVAC, and was the first practical stored-program electronic computer in the world.


Later the project was supported by the Lyons Electronic Office (J. Lyons & Co. Ltd), who produced the first commercially applied computer, the 1951 LEO I, based on the EDSAC design. EDSAC ran its first programs on 6 May 1949, when it calculated a table of squares and a list of prime numbers.

As soon as EDSAC was constructed, it began serving the University's research needs. None of its components were experimental.


It used mercury delay lines for memory, and derated vacuum tubes for logic. Input was via 5-hole punched paper tape and output was via a teleprinter. Initially registers were limited to an accumulator and a multiplier register.

The EDSAC's memory consisted of 1024 locations, though only 512 locations were initially implemented. Each contained 18 bits, but the first bit was unavailable due to timing restrictions, so only 17 bits were used. An instruction consisted of a five-bit instruction code (designed to be represented by a mnemonic letter, so that the Add instruction, for example, used the bit pattern for the letter A), one unused spare bit, ten bits for a memory address, and one bit to control whether the instruction operated on a number contained in one word or two.

Internally, the EDSAC used two's complement binary numbers. These were either 17 bits (one word) or 35 bits (two words) long. Unusually, the multiplier was designed to treat numbers as fixed-point fractions in the range -1 ? x < 1, i.e. the binary point was immediately to the right of the sign. The accumulator could hold 71 bits, including the sign, allowing two long (35-bit) numbers to be multiplied without losing any precision.

The instructions available were: add, subtract, multiply, shift left, shift right, load multiplier register, store (and optionally clear) accumulator, conditional skip, read input tape, print character, round accumulator, no-op and stop. There was no division instruction (though a number of division subroutines were available) and no way to directly load a number into the accumulator (a “store and zero accumulator” instruction followed by an “add” instruction were necessary for this).

The initial orders were hard-wired on a set of uniselector switches and loaded into the low words of memory at startup. By May 1949, the initial orders provided a primitive relocating assembler taking advantage of the mnemonic design described above, all in 31 words. This was the world's first assembler.

The machine was used by other members of the University to solve real problems, and many early techniques were developed that are now included in operating systems. Users prepared their programs by punching them (in assembler) onto a paper tape. They soon became good at being able to hold the paper tape up to the light and read back the codes. When a program was ready it was hung on a length of line strung up near the paper tape reader. The machine operators, who were present during the day, selected the next tape from the line and loaded it into EDSAC. This is of course well known today as a job queue. If the program printed something then the tape and the printout were returned to the user, otherwise the user was informed at which memory location the program had stopped.


Debuggers had not yet been developed, but a CRT screen could be set to display the contents of a particular piece of memory. This was used to see if a number was converging, for example. After office hours certain "Authorised Users" were allowed to run the machine for themselves, which went on late into the night until a valve blew, which was the usual outcome.

The early programmers had to make use of techniques frowned upon today, especially directly altering the program code in memory, e.g. there was no index register until much later the only way of accessing an array was to alter the memory location that a particular instruction referenced. David Wheeler, who earned the world's first Computer Science PhD working on the project, is credited with inventing the concept of the subroutine. The user wrote a program that called a subroutine by jumping to the start of the subroutine, leaving the contents of the program counter plus one in the single register. By convention the subroutine expected this and the first thing it did was to overwrite its final jump instruction with that address so that it would return to the user program. Multiple and nested subroutines could be called so long as the user knew the length of each one in order to calculate the location to jump to. The user then copied the code for the subroutine from a master tape onto their own tape following the end of their own program. The subroutine concept lead to the availability of a substantial subroutine library. By 1951 many subroutines were available for general use, e.g. floating point arithmetic; arithmetic operations on complex numbers; division; exponentiation; differential equations; power series; logarithms; print and layout; read (input); nth root; trigonometric functions; counting operations (simulating “repeat”, “while” and “for” loops); vectors and matrices.

Appendix 2: EDSAC 2


1960 user queue for programming the EDSAC 2. In this queue is Dr Hedley Martin, in the beard, future Head of Mathematics and Statistics at North Staffordshire Polytechnic (later Staffordshire University).

The 1960 EDSAC 2 was the first computer to have a
microprogram control store and a bit slice hardware architecture.

Appendix 3: Atlas

The 1962 Atlas was a joint development between the
University of Manchester and the computer firms Ferranti and Plessey. Officially commissioned in 1962, it was one of the world's first supercomputers, considered to be the most powerful computer in the world at that time. It was said that whenever Atlas went offline half of the United Kingdom's computer capacity was lost. It was a second-generation machine, using germanium transistors rather than vacuum tubes.

Two other Atlas machines were built: one for British Petroleum and the University of London, and one for the Atlas Computer Laboratory at Chilton near Oxford. A derivative system was built by Ferranti for Cambridge University, called the Titan, or Atlas 2. It had a different memory organisation, and ran a time-sharing operating system developed by Cambridge Computer Laboratory. Two further Atlas 2s were delivered: one to the CAD lab at Cambridge, finally switched off on 21 December 1976, and the other to UKAWE, Aldermaston. The University of Manchester's Atlas was decommissioned in 1971. Parts of the Chilton Atlas are preserved by the National Museums of Scotland in Edinburgh.

Appendix 3: Titan


1964 Titan (Atlas 2)

The 1964 Titan was the name given to the prototype Atlas 2 computer developed by
Ferranti and the University of Cambridge Mathematical Laboratory. It was in operation from 1964 to 1973. Titan differed from the Manchester Atlas by having a real, but cached, main memory, rather than the paged (or virtual) memory used in the Manchester machine. The Titan's main memory had 128K of 48-bit words and was implemented using ferrite magnetic core store rather than the part core, part rotating magnetic drum store used on the Manchester Atlas. It also had two large hard disk drives and several magnetic tape decks. As with the Manchester Atlas, it used discrete components, in particular germanium transistors. As a prototype it had a reputation for technical excellence and ran an early and very successful multi-user time-sharing system; but it was also often highly unreliable, and indeed some wiring anomalies were still being discovered several years after it was first commissioned. One of its most intensive uses was to compute the inverse Fourier Transforms of data from the One-Mile Radio Telescope.

Back to Top


Send all comments, updates and queries for The Staffordshire University Computing Futures Museum Cambridge Page to Dr John Wilcock

Version: 02 18 July 2010 updated by Dr John Wilcock