Autocode is the name of a family of early British programming languages, and the first of them, written by Alick Glennie in 1952 for the Manchester Mark 1, is widely cited as Autocode, the first compiled programming language. Where earlier systems such as Short Code interpreted each operation at run time, Glennie's Autocode translated the program into machine code before it ran. Over the following decade "autocode" became the generic British term for a simplified, formula-friendly language, with versions for machines at Manchester, Cambridge and elsewhere.
Origins at Manchester
The University of Manchester was one of the first places with a working stored-program computer. Its Manchester Mark 1 led to the Ferranti Mark 1, one of the first commercially available general-purpose computers, delivered in 1951. Programming these machines was notoriously hard. Instructions were written in a base-32 notation using teleprinter characters, and memory was split between fast Williams tube storage and a slower magnetic drum.
Alick Glennie, who worked for the British armament research establishment at Fort Halstead, used the Manchester machine and wanted a more readable way to write programs. His Autocode, completed in 1952, let programmers write algebraic-style expressions and have them converted automatically into machine instructions.
Was Autocode the first compiled programming language?
By most accounts, yes. Glennie's system performed translation ahead of execution, which is the defining feature of a compiler. It was, however, still closely tied to the Mark 1's architecture. Programmers had to understand the machine's storage and registers, so it reads today more like a structured assembly language with algebraic conveniences than like Fortran. It also saw little use beyond Glennie himself, partly because it did not hide enough of the machine to justify learning it.
Tony Brooker and the later autocodes
The more widely used autocodes came from Tony Brooker at Manchester. His Mark 1 Autocode, introduced around 1954, was designed to be usable by scientists and engineers with little interest in the machine itself. It handled floating-point arithmetic and offered a small, regular set of statements. Brooker followed it with Mercury Autocode for the Ferranti Mercury in the late 1950s, and later, with Derrick Morris and others, Atlas Autocode for the Ferranti Atlas in the 1960s, by which point the language had absorbed many ideas from ALGOL.
| Version | Approximate date | Machine |
|---|---|---|
| Glennie's Autocode | 1952 | Manchester Mark 1 |
| Mark 1 Autocode (Brooker) | around 1954 | Ferranti Mark 1 |
| Mercury Autocode | late 1950s | Ferranti Mercury |
| EDSAC 2 Autocode | early 1960s | EDSAC 2 (Cambridge) |
| Atlas Autocode | mid-1960s | Ferranti Atlas |
Design and key features
The later autocodes shared a recognisable style:
- Short variable names, often single letters, with separate sets for integers and floating-point values
- Assignment statements written much like algebra
- Numbered labels and jumps for control flow, with conditional jumps for loops
- Built-in functions for common mathematics such as square roots and trigonometry
- Simple printing of numerical results
Illustrative example
Syntax varied from machine to machine, and original listings used character sets that do not map neatly onto modern keyboards. The fragment below is illustrative, written in the general style of Mercury-era autocodes, and is not an exact listing for any one compiler. It prints the squares of 1 to 10:
n = 1
1) y = n*n
PRINT y
n = n + 1
JUMP 1, n < 11
STOPCompared with the machine code of the period, that is a huge simplification: no register allocation, no address arithmetic, no manual handling of the drum.
How Autocode was used
Brooker's autocodes were used for scientific and engineering calculation at Manchester and at the organisations that bought Ferranti machines. Atlas Autocode was the main language on the Atlas, one of the most powerful computers of the early 1960s, and was used by research groups across British universities. Brooker's work on Atlas also produced the Compiler Compiler, an early tool for generating compilers from a description of a language.
Influence and legacy
Autocode shaped British computing in a way that is easy to overlook from an American perspective. Atlas Autocode was the direct ancestor of Edinburgh IMP, which was used to write the Edinburgh Multi-Access System operating system. More broadly, the autocodes showed that translating readable code ahead of time was practical on modest hardware, the same insight that drove Fortran in the United States.
Is Autocode still used today?
No. The autocodes were tied to specific Ferranti and Cambridge machines, and they were replaced by Fortran, ALGOL and later languages as those machines were retired. A few enthusiasts have built emulators that run original programs, but there is no practical use.
Whether you call Glennie's system Autocode, the first compiled programming language, or simply an early algebraic assembler, its place in history is secure, and Brooker's later versions made the idea genuinely useful.
Frequently asked questions
Who wrote the first Autocode compiler?
Alick Glennie wrote the first Autocode for the Manchester Mark 1 in 1952. It is often described as the first compiled programming language, although it remained closely tied to the machine's architecture and saw limited use.
What is the difference between Glennie's Autocode and Mark 1 Autocode?
Glennie's version still required detailed knowledge of the machine. Tony Brooker's Mark 1 Autocode, introduced around 1954, hid much more of the hardware and supported floating-point arithmetic, which made it far more practical for scientists and engineers.
Did Autocode influence any modern programming languages?
Its clearest descendant is Edinburgh IMP, which grew out of Atlas Autocode. The wider influence is conceptual: the autocodes demonstrated early that ahead-of-time compilation of readable code was workable, a lesson shared with Fortran and ALGOL.
