Autocode
Autocode is the name given to a family of early high-level programming languages developed at the University of Manchester in the United Kingdom during the 1950s and 1960s, primarily for use with the university's custom-built computers such as the Manchester Mark 1, Ferranti Mark 1, Mercury, and Atlas.[1] The inaugural version of Autocode was created by British computer scientist Alick Glennie in 1952 specifically for the Manchester Mark 1 computer, where it served as the first implemented compiler to translate high-level instructions into machine code, operational by September of that year.[2] This innovation distinguished Autocode from prior assembly-like systems by enabling programmers to write in a more abstract, formulaic notation rather than direct machine instructions, thereby reducing the complexity of coding for scientific computations on early stored-program computers.[2] Building on Glennie's work, subsequent iterations advanced the concept significantly. In 1954, R. A. (Tony) Brooker introduced Mark 1 Autocode for the Ferranti Mark 1, a commercial derivative of the Manchester machine, which incorporated subroutine libraries, floating-point arithmetic support, and input-output facilities to facilitate numerical analysis and data processing tasks.[1] By 1957, Mercury Autocode extended these capabilities for the Ferranti Mercury computer, adding features like string handling and improved modularity, while the later Atlas Autocode, developed around 1965 by Brooker and Derrick Morris as a variant of ALGOL 60, introduced explicit typing, dynamic arrays, and range-checking for safer array operations on the powerful Atlas supercomputer.[3][4] These Autocodes played a pivotal role in the evolution of programming paradigms, bridging the gap between low-level machine code and modern high-level languages by demonstrating practical compilation techniques and promoting reusable code structures.[2] Their development at Manchester not only supported academic research in fields like mathematics and physics but also contributed to the broader advancement of abstracted programming for general-purpose computing.[1]Overview
Definition and Characteristics
Autocode refers to a family of simplified coding systems, developed primarily in the 1950s and 1960s, that represented early high-level programming languages designed to facilitate easier program creation compared to direct machine coding. These systems emerged as a response to the post-WWII demand for more accessible computing tools in scientific and engineering applications, evolving from assembly-like instructions toward greater abstraction by allowing programmers to express computations in symbolic, problem-oriented terms rather than hardware-specific details. Unlike contemporary universal languages, Autocodes were typically tailored to particular computing environments, emphasizing practicality over portability.[5] Key characteristics of Autocodes include their machine-oriented nature, which positioned them as an intermediate layer above assembly language while remaining higher-level through features like symbolic notation for variables and operations, reduced need for manual memory addressing, and support for common mathematical constructs such as arithmetic expressions and loops. They were generally compiled into machine code, translating user statements into efficient executable instructions, often with built-in handling for floating-point arithmetic and subroutine calls to enhance readability and productivity. Limited to specific hardware platforms, such as those from Manchester and Ferranti, these languages prioritized ease of use for scientists and engineers by minimizing boilerplate code related to hardware management, including automatic allocation of storage and error checking.[5] In terms of syntax, Autocodes employed straightforward declarative statements for assignments and computations, such asX = Y + Z for basic arithmetic or Xi = 3 \cos(yi) (for i = 0, 1, \dots, 5) to define iterative evaluations, alongside simple function-like definitions that abstracted repetitive tasks without delving into low-level control flow. This approach used alphabetic symbols for variables and mnemonic operators, fostering a more intuitive notation than the numeric opcodes of assembly.[5]
Autocodes distinguished themselves from low-level languages by shifting emphasis from binary or hexadecimal machine instructions and explicit register manipulations to symbolic representations that mirrored mathematical or logical intent, thereby reducing programming errors and development time while maintaining close ties to the underlying machine architecture. This focus on readability and abstraction marked a foundational step toward modern high-level languages, though their hardware specificity limited broader adoption.[5]
Historical Significance
Autocode represents a pivotal milestone in the evolution of programming languages, serving as one of the earliest compiled high-level languages and predating FORTRAN's release in 1957. Developed initially by Alick Glennie in 1952 for the Manchester Mark 1 computer at the University of Manchester, it marked the first practical implementation of a compiler that translated algebraic statements into machine code, thereby abstracting the complexities of low-level programming. This innovation facilitated a crucial transition from labor-intensive machine code and assembly languages to more intuitive, human-readable forms, laying foundational principles for modern software development.[6] In the context of 1950s computing, Autocode directly tackled prevalent challenges such as frequent errors in memory addressing and numerical scaling, which plagued early programmers working on unreliable hardware with limited resources. By introducing symbolic notation and built-in routines for floating-point arithmetic and indexing, it minimized manual calculations and debugging efforts, allowing scientists and engineers—often non-experts in machine-level details—to author complex mathematical and scientific computations with greater reliability and speed. This accessibility broadened participation in computational tasks, shifting programming from a specialized craft to a more democratized tool for problem-solving.[6] Autocode's development at the University of Manchester exerted significant influence on British computing infrastructure, particularly through its adaptation for Ferranti's commercial machines like the Mark 1, which entered production in 1951. The subsequent Mark 1 Autocode, refined by R.A. Brooker and completed in 1955, became a cornerstone for university computing services, handling extensive workloads in numerical analysis and supporting practical applications across academic and industrial domains. By 1955, it was utilized for approximately 12 hours per week as the primary basis for a dedicated computing service, underscoring its rapid adoption and role in sustaining early high-performance calculations on Ferranti hardware.[6]Early Developments
Glennie's Autocode
Glennie’s Autocode, developed by Alick Glennie at the University of Manchester, represented the first implementation of a compiled high-level programming language.[7] Created in 1952 specifically for the Manchester Mark 1 computer, it served as a proof-of-concept compiler aimed at simplifying programming tasks on this early stored-program machine.[6] Unlike assembly languages that required direct manipulation of machine instructions, Glennie’s system translated symbolic algebraic expressions into executable Mark 1 code, marking it as the inaugural autocode and the earliest known compiler in operation.[7] The design prioritized programmer comprehensibility over execution efficiency, resulting in compiled programs that required approximately 10% additional space compared to hand-optimized machine code.[6] This overhead stemmed from the compiler's straightforward translation mechanism, implemented as a 750-instruction program that processed input symbolically. Glennie’s Autocode was inherently machine-dependent, closely mirroring the Mark 1’s instruction set and addressing modes, which limited its portability but ensured tight integration with the hardware.[6] It featured symbolic instructions for basic arithmetic operations, such as addition, multiplication, and square root, allowing users to express computations in a notation closer to mathematical formulas rather than binary or hexadecimal opcodes.[6] A representative example illustrates its syntax and compilation process: to compute the function f(t) = \sqrt{|t|} + 5t^3, users would specify subroutines for operations like absolute value and square root, with the compiler inserting calls to predefined machine-level routines, such as a subroutine spanning multiple lines for the full expression. The compiler would parse this line-by-line, inserting necessary load/store operations and generating a sequence of Mark 1 machine words—typically expanding a single symbolic statement into several instructions for data movement and computation. No subroutines were defined within the language itself; instead, it relied on predefined machine-level routines for functions like square root.[6] Despite its innovations, Glennie’s Autocode had notable limitations that confined it to experimental use, primarily by Glennie himself. It was tightly coupled to the Manchester Mark 1’s architecture, including its fixed-point arithmetic and limited memory, making adaptation to other machines impractical without significant rewriting.[6] Error-checking was minimal, with the compiler offering little diagnostics for syntax errors or logical inconsistencies, placing the burden on the programmer to ensure correctness.[6] These constraints, combined with the system's rudimentary scope, positioned it as a foundational but non-general-purpose tool, influencing subsequent autocode developments without achieving widespread adoption.[7]Mark 1 Autocode
Mark 1 Autocode was developed by R.A. Brooker at the University of Manchester, with planning beginning in 1954 and implementation completing in 1955 for the Ferranti Mark 1 computer, the commercial variant of the Manchester Mark 1.[1] This system built briefly on earlier compiler concepts to provide a more advanced programming environment tailored to the machine's architecture. The language achieved near machine-independence by abstracting low-level details, allowing programmers to focus on algorithmic logic rather than hardware specifics, and emphasized floating-point arithmetic to handle scientific calculations efficiently.[8][9] It utilized a floating-point system with options for double-length precision (80 bits) or adjustable scale factors, where operations like addition took approximately 40 milliseconds, multiplication 24 milliseconds, and division 90 milliseconds.[9] By 1958, Mark 1 Autocode had become the dominant and standard programming language on the Ferranti Mark 1, supplanting manual coding methods.[1][9] Core features included one operation per statement line, typically in the form of simple arithmetic assignments such asr1 = r4 / 2, where variables (denoted r0 to r4095) replaced numeric codes for readability.[9][8] Automatic scaling was managed through the floating-point representation, eliminating the need for programmers to track fixed binary-point positions manually, while storage allocation handled the machine's two-level memory system—fast core store and magnetic drum—with 128 tracks each holding 32 numbers, optimizing access times of 40 milliseconds for reads and 90 milliseconds for writes.[9] The system lacked user-defined subroutines, relying instead on built-in interpretive routines for floating-point operations, and supported input/output through symbolic mechanisms like TAPE for data entry and PRINT statements with format codes for output.[9][8]
In practice, Mark 1 Autocode was heavily employed for scientific computations, powering a computing service that ran approximately 12 hours per week and handling tasks such as cube root calculations and chemical engineering simulations like flash distillation.[9][8] It directly addressed challenges of manual programming on the Ferranti Mark 1, including tedious address calculations, scale factor adjustments, and delays from drum storage access, thereby reducing the learning curve to just one or two days for casual users and enabling more productive scientific work.[1][9]
Major Later Variants
Mercury Autocode
Mercury Autocode was developed between 1958 and 1959 by R. A. Brooker, with contributions from B. Richards, E. Berg, and R. H. Kerr, primarily for the Ferranti Mercury computer at the University of Manchester.[10] This system extended the principles of earlier autocodes to support the Mercury's two-level store architecture, which included a fast local store and a slower auxiliary store for larger data sets.[11] Designed with ease of use in mind for commercial and scientific computing environments, it emphasized accessibility through a straightforward syntax that anticipated the simplicity of later languages like early BASIC.[12] The language featured a limited repertoire of variables, restricted to single letters a through z and their primed variants a' through z', which served as floating-point scalars or could be indexed for arrays of fixed size.[13] To accommodate programs exceeding the capacity of the local store, Mercury Autocode employed an overlay mechanism based on "chapters," where sections of code and data were explicitly divided and loaded from the auxiliary store as needed, with control passing between chapters via directory-based addressing.[12] Notably, it lacked support for recursion and dynamic arrays, focusing instead on deterministic, pre-allocated memory usage suitable for the era's hardware constraints.[13] Control structures were kept simple and direct, with loops implemented via statements like "i = 1(1)10" followed by the body and "repeat" to iterate over a range, and conditionals handled through jump instructions such as "jump if Y > K" for comparisons involving equality, inequality, or relational operators.[13] Input was primarily via paper tape, enabling batch processing of programs and data, while output could direct results to tape or printers.[12] These elements made it well-suited for scientific applications, including numerical computations that leveraged the Mercury's hardware floating-point arithmetic.[14] The system was documented in a comprehensive manual published in May 1959 by Brooker, Richards, Berg, and Kerr, which served as both a programming guide and reference for the compiler's facilities.[10] This manual detailed the phrase-structure grammar underlying the language, facilitating its use in translating source code to machine instructions via a compiler rather than interpretation.[15]Atlas Autocode
Atlas Autocode is a high-level programming language developed in 1963 by Tony Brooker and Derrick Morris at the University of Manchester for the Ferranti Atlas computer.[16] The initial compilers for the language, known as AA and AB, were implemented by Jeff Rohl.[16] As a variant of ALGOL 60, it simplified certain aspects of the international standard, such as removing parameter passing by name, while retaining core algorithmic expressiveness.[3] The language's compiler was constructed using the Brooker-Morris Compiler-compiler, a meta-tool that facilitated the generation of parsers and code generators from formal language descriptions.[16] Atlas Autocode is block-structured, procedural, and imperative, employing nested blocks delimited bybegin and end keywords, with the entire program treated as a top-level block concluding with of program.[17] It supports explicitly typed variables, primarily integer and real, along with subroutines and functions defined as named blocks that accept parameters; functions return values via assignments to a special result variable.[17] Arrays feature runtime dimensioning, allowing bounds to be specified dynamically (e.g., integer array A(i:j) where i and j are expressions evaluated at runtime), and optional range-checking enabled via compiler directives like array bound check.[17] The language initially included a complex data type for mathematical computations, which was later removed in subsequent evolutions.[17] Machine code integration is provided through inline assembly facilities, enabling the embedding of Atlas-specific instructions for performance-critical sections such as loops or hardware-specific operations.[17] Its parser employs a top-down recursive descent approach, processing input via a scanner that handles compound symbols and converts them into 48-bit words for the Atlas architecture.[17]
Primarily targeted at the Ferranti Atlas, Atlas Autocode was also ported to the English Electric KDF9, with adaptations to its character set and instruction set.[18] Variants were developed for the Titan computer—a prototype of the Atlas 2 at the University of Cambridge—and the Cambridge Atlas 2 itself, extending its use across related hardware platforms.[19] The language later evolved into Edinburgh IMP, a superset used to implement the EMAS operating system at the University of Edinburgh, where the complex data type was dropped to enhance efficiency for system programming.[20]