Autocode facts for kids

Autocode was a name given to early "simplified coding systems." These systems were like the first versions of what we now call programming languages. They were created in the 1950s and 1960s.

These languages were developed for digital computers at universities in Manchester, Cambridge, and London. The term "Autocode" was used generally. It didn't mean all Autocodes were closely related, like different versions of Fortran are today.

Today, "Autocode" usually refers to a group of early languages. These languages came from the first systems used with the Manchester Mark 1 computer. In the 1960s, "autocoders" was a broader term. It meant any high-level programming language that used a compiler. Some languages like COBOL and Fortran were even called autocodes back then.

Glennie's Autocode

The very first Autocode was made by Alick Glennie in 1952. He created it for the Mark 1 computer at the University of Manchester. Some people believe this was the first compiled programming language.

Glennie's main goal was to make programming the Mark 1 easier to understand. The Mark 1's original machine code was very difficult. His new language was much clearer than the machine code. However, it still depended a lot on the specific computer it ran on.

The manual for Glennie's Autocode Compiler said it was very efficient. It claimed the computer would only slow down by about 10% when using it.

Even with these benefits, Glennie's Autocode was not widely used. It didn't have a big impact on how other programmers at Manchester worked.

Mark 1 Autocode

A second Autocode for the Mark 1 computer was planned in 1954. R. A. Brooker developed it in 1955. This one was called the "Mark 1 Autocode."

This new language was much more independent of the specific machine. It could also handle floating-point arithmetic. This means it could work with numbers that have decimal points. The first Autocode could not do this.

However, Mark 1 Autocode had some limits. You could only do one operation on each line of code. It also had few easy-to-remember names for commands. Plus, you couldn't create your own reusable blocks of code.

Here is a simple example of how you might tell the computer to read a list of numbers: n1 = 1 1 vn1 = I n1 = n1 + 1 j1,11 ≥ n1

Brooker's Autocode solved two big problems for Mark 1 programmers. It made it easier to handle numbers of different sizes. It also helped manage the computer's memory. Unlike Glennie's version, this Autocode was used a lot by programmers.

Later Autocodes

Brooker also created an Autocode for the Ferranti Mercury computer in the 1950s. This was done with the University of Manchester.

Mercury Autocode had a limited number of variables. These were named a-z and a'-z'. In some ways, it was similar to early versions of the Dartmouth BASIC language. It came before ALGOL, another important language. It didn't have concepts like stacks, which means it couldn't do recursion. It also couldn't change the size of arrays while a program was running.

To deal with the Mercury computer's small memory, large programs were split into "chapters." Each chapter was a separate part of the program. These chapters would load into memory as needed. This was a common way to manage memory until virtual memory became available on newer computers.

Slightly different versions of Mercury Autocode were made. These were for the Ferranti Atlas (different from the later Atlas Autocode) and the ICT 1300 and 1900 computers.

A version for the EDSAC 2 computer was designed by David Hartley in 1961. This was at the University of Cambridge Mathematical Laboratory. It was called EDSAC 2 Autocode. It was an improved version of Mercury Autocode. It was known for making computer code run very efficiently. It also had good tools for finding errors in the original code. These features were very advanced for that time.

A version was also made for the Titan computer. This was a temporary solution while a more advanced language, CPL, was being developed. CPL was never fully finished. However, it led to BCPL (made by M. Richards). BCPL then led to B and eventually to the very popular language C.

At the same time, a separate Autocode was developed for the University of Manchester Atlas 1 machine. This was called Atlas Autocode.