Autocode

Last updated

Autocode is the name of a family of "simplified coding systems", later called programming languages, devised in the 1950s and 1960s for a series of digital computers at the Universities of Manchester, Cambridge and London. Autocode was a generic term; the autocodes for different machines were not necessarily closely related as are, for example, the different versions of the single language Fortran.

Contents

Today the term is used to refer to the family of early languages descended from the Manchester Mark 1 autocoder systems, which were generally similar. In the 1960s, the term autocoders was used more generically as to refer to any high-level programming language using a compiler. [1] Examples of languages referred to as autocodes are COBOL and Fortran. [2]

Glennie's Autocode

The first autocode and its compiler were developed by Alick Glennie in 1952 for the Mark 1 computer at the University of Manchester and is considered by some to be the first compiled programming language. His main goal was increased comprehensibility in the programming of Mark 1 machines, which were known for their particularly abstruse machine code. Although the resulting language was much clearer than the machine code, it was still very machine dependent. [3]

Below is an example of Glennie's Autocode function which calculates the formula: . The example omits necessary scaling instruction needed to place integers into variables and assumes that results of multiplication fit into lower accumulator.

c@VA t@IC x@½C y@RC z@NC INTEGERS +5 →c           # Put 5 into c       →t                 # Load argument from lower accumulator                          # to variable t    +t     TESTA Z        # Put |t| into lower accumulator    -t           ENTRY Z SUBROUTINE 6 →z          # Run square root subroutine on                          # lower accumulator value                          # and put the result into z   +tt →y →x              # Calculate t^3 and put it into x    +tx →y →x +z+cx   CLOSE WRITE 1    # Put z + (c * x) into                          # lower accumulator                          # and return

User's manual of Glennie's Autocode Compiler mentioned that "the loss of efficiency is no more than 10%". [4]

Impact of Glennie's Autocode on other Manchester users' programming habits was negligible. It wasn't even mentioned in Brooker's 1958 paper called "The Autocode Programs developed for the Manchester University Computers".

Mark 1 Autocode

The second autocode for the Mark 1 was planned in 1954 and developed by R. A. Brooker in 1955 and was called the "Mark 1 Autocode". The language was nearly machine-independent and had floating-point arithmetic, unlike the first one. On the other hand it allowed only one operation per line, offered few mnemonic names and had no way to define user subroutines. [5]

An example code which loads array of size 11 of floating-point numbers from the input would look like this

      n1 = 1          1    vn1 = I         reads input into v[n[1]]       n1 = n1 + 1    j1,11 ≥ n1        jumps to 1 if n[1] ≤ 11

Brooker's Autocode removed two main difficulties of Mark 1's programmer: scaling and management of two-level storage. Unlike its predecessor it was heavily used. [6]

Later Autocodes

Brooker also developed an autocode for the Ferranti Mercury in the 1950s in conjunction with the University of Manchester. Mercury Autocode had a limited repertoire of variables a-z and a'-z' and, in some ways resembled early versions of the later Dartmouth BASIC language. It pre-dated ALGOL, having no concept of stacks and hence no recursion or dynamically-allocated arrays. In order to overcome the relatively small store size available on Mercury, large programs were written as distinct "chapters", each of which constituted an overlay. Some skill was required to minimise time-consuming transfers of control between chapters. This concept of overlays from drum under user control became common until virtual memory became available in later machines. Slightly different dialects of Mercury Autocode were implemented for the Ferranti Atlas (distinct from the later Atlas Autocode) and the ICT 1300 and 1900 range.

The version for the EDSAC 2 was devised by David Hartley of University of Cambridge Mathematical Laboratory in 1961. Known as EDSAC 2 Autocode, it was a straight development from Mercury Autocode adapted for local circumstances, and was noted for its object code optimisation and source-language diagnostics which were advanced for the time. A version was developed for the successor Titan (the prototype Atlas 2 computer) as a temporary stop-gap while a more substantially advanced language known as CPL was being developed. CPL was never completed but did give rise to BCPL (developed by M. Richards), which in turn led to B and ultimately C. A contemporary but separate thread of development, Atlas Autocode was developed for the University of Manchester Atlas 1 machine.

Related Research Articles

Atlas Autocode (AA) is a programming language developed around 1963 at the University of Manchester. A variant of the language ALGOL, it was developed by Tony Brooker and Derrick Morris for the Atlas computer. The initial AA and AB compilers were written by Jeff Rohl and Tony Brooker using the Brooker-Morris Compiler-compiler, with a later hand-coded non-CC implementation (ABC) by Jeff Rohl.

<span class="mw-page-title-main">EDSAC</span> 1940s–1950s British computer

The Electronic Delay Storage Automatic Calculator (EDSAC) was an early British computer. Inspired by John von Neumann's seminal First Draft of a Report on the EDVAC, the machine was constructed by Maurice Wilkes and his team at the University of Cambridge Mathematical Laboratory in England. EDSAC was the second electronic digital stored-program computer to go into regular service.

<span class="mw-page-title-main">Fortran</span> General-purpose programming language

Fortran is a general-purpose, compiled imperative programming language that is especially suited to numeric computation and scientific computing.

<span class="mw-page-title-main">Programming language</span> Language for communicating instructions to a machine

A programming language is a system of notation for writing computer programs. Most programming languages are text-based formal languages, but they may also be graphical. They are a kind of computer language.

In computer science, a compiler-compiler or compiler generator is a programming tool that creates a parser, interpreter, or compiler from some form of formal description of a programming language and machine.

In computer science, a high-level programming language is a programming language with strong abstraction from the details of the computer. In contrast to low-level programming languages, it may use natural language elements, be easier to use, or may automate significant areas of computing systems, making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how "high-level" a programming language is.

<span class="mw-page-title-main">IBM 1130</span> 16-bit IBM minicomputer introduced in 1965

The IBM 1130 Computing System, introduced in 1965, was IBM's least expensive computer at that time. A binary 16-bit machine, it was marketed to price-sensitive, computing-intensive technical markets, like education and engineering, succeeding the decimal IBM 1620 in that market segment. Typical installations included a 1 megabyte disk drive that stored the operating system, compilers and object programs, with program source generated and maintained on punched cards. Fortran was the most common programming language used, but several others, including APL, were available.

ALGOL 60 is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them, representing a key advance in the rise of structured programming. ALGOL 60 was one of the first languages implementing function definitions. ALGOL 60 function definitions could be nested within one another, with lexical scope. It gave rise to many other languages, including CPL, PL/I, Simula, BCPL, B, Pascal, and C. Practically every computer of the era had a systems programming language based on ALGOL 60 concepts.

CPL is a multi-paradigm programming language developed in the early 1960s. It is an early ancestor of the C language via the BCPL and B languages.

<span class="mw-page-title-main">History of programming languages</span> Aspect of history

The history of programming languages spans from documentation of early mechanical computers to modern tools for software development. Early programming languages were highly specialized, relying on mathematical notation and similarly obscure syntax. Throughout the 20th century, research in compiler theory led to the creation of high-level programming languages, which use a more accessible syntax to communicate instructions.

The TPK algorithm is a simple program introduced by Donald Knuth and Luis Trabb Pardo to illustrate the evolution of computer programming languages. In their 1977 work "The Early Development of Programming Languages", Trabb Pardo and Knuth introduced a small program that involved arrays, indexing, mathematical functions, subroutines, I/O, conditionals and iteration. They then wrote implementations of the algorithm in several early programming languages to show how such concepts were expressed.

The Mercury was an early commercial computer from the mid-1950s built by Ferranti. It was the successor to the Ferranti Mark 1, adding a floating point unit for improved performance, and increased reliability by replacing the Williams tube memory with core memory and using more solid-state components. The computer had roughly 2000 vacuum tubes and 2000 germanium diodes. Nineteen Mercuries were sold before Ferranti moved on to newer designs.

<span class="mw-page-title-main">Electrologica X1</span> Early Dutch computer

The Electrologica X1 was a digital computer designed and manufactured in the Netherlands from 1958 to 1965. About thirty were produced and sold in the Netherlands and abroad.

Alick Edwards Glennie (1925–2003) was a British computer scientist, most famous for having developed Autocode, which many people regard as the first ever computer compiler.

<span class="mw-page-title-main">CER-12</span> Third-generation digital computer

CER model 12 was a third-generation digital computer developed by Mihajlo Pupin Institute (Serbia) in 1971 and intended for "business and statistical data processing". However, the manufacturer also stated, at the time, that having in mind its architecture and performance, it can also be used successfully in solving "wide array of scientific and technical issues". Computer CER-12 consisted of multiple modules connected via wire wrap and connectors.

<span class="mw-page-title-main">Atlas (computer)</span> Supercomputer of the 1960s

The Atlas Computer was one of the world's first supercomputers, in use from 1962 to 1972. Atlas' capacity promoted the saying that when it went offline, half of the United Kingdom's computer capacity was lost. It is notable for being the first machine with virtual memory using paging techniques; this approach quickly spread, and is now ubiquitous.

Ralph Anthony Brooker, was a British computer scientist known for developing the Mark 1 Autocode.

<span class="mw-page-title-main">History of compiler construction</span>

In computing, a compiler is a computer program that transforms source code written in a programming language or computer language, into another computer language. The most common reason for transforming source code is to create an executable program.

<span class="mw-page-title-main">TMG (language)</span>

In computing TMG (TransMoGrifier) is a recursive descent compiler-compiler developed by Robert M. McClure and presented in 1965. TMG ran on systems including OS/360 and early Unix. It was used to build EPL, an early version of PL/I.

<span class="mw-page-title-main">John Iliffe (computer designer)</span> British computer designer (1931-2020)

John Kenneth Iliffe was a British computer designer who worked on the design and evaluation of computers that supported fine-grained memory protection and object management. He implemented, evaluated and refined such designs in the Rice Institute Computer, R1 (1958–61) and the ICL Basic Language Machine (1963–68). A key feature in the architectures of both machines was control by the hardware of the formation and use of memory references so that the memory could be seen as a collection of data objects of defined sizes whose integrity is protected from the consequences of errors in address calculation, such as overrunning memory pointers.

References

  1. London, Keith (1968). "4, Programming". Introduction to Computers (1st ed.). London: Faber and Faber Limited. p. 184. SBN   571085938. The 'high' level programming languages are often called autocodes and the processor program, a compiler.
  2. London, Keith (1968). "4, Programming". Introduction to Computers (1st ed.). London: Faber and Faber Limited. p. 186. SBN   571085938. Two high level programming languages which can be used here as examples to illustrate the structure and purpose of autocodes are COBOL (Common Business Oriented Language) and FORTRAN (Formular Translation).
  3. Knuth, p. 42-43
  4. Knuth, p. 48
  5. Knuth, p. 63-64
  6. Knuth, p. 65

Sources

Further reading