From Wikipedia for FEVERv2
Revision as of 05:12, 7 January 2021 by imported>Unknown user
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search

For the assembly language used with the IBM 1400 series, see Autocoder. Autocode_sentence_0

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_sentence_1

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. Autocode_sentence_2

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. Autocode_sentence_3

In the 1960s, the term autocoders was used more generically as to refer to any high-level programming language using a compiler. Autocode_sentence_4

Examples of languages referred to as autocodes are COBOL and Fortran. Autocode_sentence_5

Glennie's Autocode Autocode_section_0

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. Autocode_sentence_6

His main goal was increased comprehensibility in the programming of Mark 1 machines, which were known for their particularly abstruse machine code. Autocode_sentence_7

Although the resulting language was much clearer than the machine code, it was still very machine dependent. Autocode_sentence_8

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

Impact of Glennie's Autocode on other Manchester users' programming habits was negligible. Autocode_sentence_10

It wasn't even mentioned in Brooker's 1958 paper called "The Autocode Programs developed for the Manchester University Computers". Autocode_sentence_11

Mark 1 Autocode Autocode_section_1

The second autocode for the Mark 1 was planned in 1954 and developed by R. Autocode_sentence_12 A. Brooker in 1955 and was called the "Mark 1 Autocode". Autocode_sentence_13

The language was nearly machine-independent and had floating-point arithmetic, unlike the first one. Autocode_sentence_14

On the other hand it allowed only one operation per line, offered few mnemonic names and had no way to define user subroutines. Autocode_sentence_15

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

Brooker's Autocode removed two main difficulties of Mark 1's programmer: scaling and management of two-level storage. Autocode_sentence_17

Unlike its predecessor it was heavily used. Autocode_sentence_18

Later Autocodes Autocode_section_2

Brooker also developed an autocode for the Ferranti Mercury in the 1950s in conjunction with the University of Manchester. Autocode_sentence_19

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. Autocode_sentence_20

It pre-dated ALGOL, having no concept of stacks and hence no recursion or dynamically-allocated arrays. Autocode_sentence_21

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. Autocode_sentence_22

Some skill was required to minimise time-consuming transfers of control between chapters. Autocode_sentence_23

This concept of overlays from drum under user control became common until virtual memory became available in later machines. Autocode_sentence_24

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. Autocode_sentence_25

The version for the EDSAC 2 was devised by David Hartley of University of Cambridge Mathematical Laboratory in 1961. Autocode_sentence_26

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. Autocode_sentence_27

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. Autocode_sentence_28

CPL was never completed but did give rise to BCPL (developed by M. Richards), which in turn led to B and ultimately C. Autocode_sentence_29

A contemporary but separate thread of development, Atlas Autocode was developed for the University of Manchester Atlas 1 machine. Autocode_sentence_30

Credits to the contents of this page go to the authors of the corresponding Wikipedia page: