Atlas Autocode

related topics
{math, number, function}
{system, computer, user}
{language, word, form}
{style, bgcolor, rowspan}

Atlas Autocode (AA) was a programming language developed around 1965 at Manchester University for the Atlas Computer. It was developed by Tony Brooker and Derrick Morris as an improvement on the ALGOL programming languages, removing some of Algol's poorer features such as "passing parameters by name" (which with Algol 60 meant not its usual meaning but passing the address of a short subroutine to recalculate the parameter each time it was mentioned). It featured explicitly typed variables, subroutines, and functions. The AA compiler generated range-checking for array accesses, and allowed an array to have dimensions that were determined at run-time (i.e. you could declare an array as integer array Thing (i:j), where i and j were calculated values). Direct machine coding was allowed.

Atlas Autocode included a complex data type which would support complex numbers (for example, the square root of -1). A complex number was represented as an expression involving i, which was treated as a fixed complex constant = i. This was partly because of pressure from the electrical engineering department, which used complex numbers much to represent the behavior of alternating current.

This 'complex' feature was dropped when Atlas Autocode later morphed into the Edinburgh IMP programming language. (Imp was an extension of AA and was notable for being used to write the EMAS operating system.)

Keywords in AA were represented as being underlined. There was a mode "uppercasedelimiters", where all uppercase letters (outside strings) were treated as underlined lowercase.

In some versions (but not in the original Atlas version), for the sake of easy typing it was possible to strop keywords by placing a "%" sign in front of them, for example the keyword endofprogramme could be typed as %end %of %programme or %endofprogramme

There were no reserved words in the language. In the statement if token=if then result = token, there is both a keyword if and a variable named if.

Because of this keyword stropping, it was possible for AA to allow spaces in variable names, such as integer previous value. Spaces were not significant and were removed prior to parsing in a trivial pre-lexing stage called "line reconstruction". What the compiler would see in the above example would be "iftoken=ifthenresult=token".

The syntax for expressions let the multiplication operator be omitted, e.g. 3a was treated as 3*a, and a(i+j) was treated as a*(i+j) if a was not an array. In ambiguous usages, the longest possible name was taken, for example ab was not treated as a*b, whether or not a and b had been declared.

Atlas Autocode's syntax was influenced by the output device which the author had available, a Friden Flexowriter. Consequently it allowed symbols like "½" for ".5" and the superscript 2 for "to the power of 2". The flexowriter supported overstriking and therefore AA did as well - up to three characters could be overstruck as a single symbol. For example the character set had no "↑" symbol, so exponentiation was an overstrike of "|" and "*". (The underlining of keywords mentioned above could also be done using overstriking.) The language is described in detail in the Atlas Autocode Reference Manual.

Other Flexowriter characters that were found a use in Atlas Autocode were: α in floating-point numbers, e.g. 3.56α-7 for modern 3.56e-7 ; β to mean "the second half of an Atlas memory word"; π for the mathematical pi number.

Full article ▸

related documents
GNU Octave
Hash collision
Weierstrass–Casorati theorem
Double negative elimination
Borel-Cantelli lemma
Subalgebra
Magma computer algebra system
Nowhere dense set
Malleability (cryptography)
Calculus with polynomials
Category (mathematics)
Dyadic rational
Stirling number
Byte-order mark
Search engine (computing)
Algebraic number
T1 space
Cayley's theorem
Steiner system
Algebraic extension
C*-algebra
Residue (complex analysis)
Extractor
Real line
Regular space
Alternative algebra
Dublin Core
Partial fractions in integration
BPP
Context-sensitive grammar