Computer Languages by Committee - the 1960s
Written by Harry Fairhead   
Tuesday, 26 November 2013
Article Index
Computer Languages by Committee - the 1960s
Two Cultures

The 1960 saw the growth of interest in computer languages but, unlike today where successful languages are often designed by single-minded enthusiasts, this was the decade of the committee - language by design and consensus.

Two committees, one academic, the other under the auspices of the US Department of Defense and largely made up of commercial interests, shaped ALGOL and COBOL which, together with FORTRAN, were  the dominant languages of  the 1960s.




By the end of the 1950s most of the seeds of the future computer languages had been sown - the triumvirate of FORTRAN, ALGOL and COBOL were in already existence - but it took the next ten years of language development and consolidation to achieve any sort of maturity.

At the start of the 60's the overwhelming objective seems to have been superseding Fortran and it is tempting to see everything that happened as a reaction to IBM and its language. To a certain extent this was true but there was another important factor. Fortran seemed ideal for scientific use and that left two powerful groups out in the cold - the business users and the computer experts themselves!

Business users had been casting around for a suitable cause for some time before they got together and created COBOL. The same is true of the computer experts who actually managed to convene a committee to design a challenge to Fortran and so produced Algol.

From our distant viewpoint Fortran, Cobol and Algol are important because together they embody the broad possible approaches that you can take to the creation of a programming language.

The only ideas that can claim to be not contained in one of the three classical languages are the more recent philosophies - functional, logical and object oriented programming - and I have no doubt that even traces of these can be found!

Let's form a committee!

Fortran was an IBM programming language. It was first thought up in IBM, developed by IBM and was made a success by IBM. This is not to say that Fortran isn't a good language that deserved to succeed - it's more that with IBM's backing its quality is less of an issue.

Fortran is all about numerical computation and other aspects of computer use were an afterthought. There were various other languages and compilers being developed at around the same time that Fortran made its appearance. For example, the A series of compilers developed by a team at Remington Rand under Grace Hopper probably qualify as among the first compilers. A0 was started in 1952.

Legend has it that it was also the first program to be called a compiler - because all it really did was to compile a program made up of subroutines from a library!



Grace Hopper And Team Getting Cobol Working On A Univac 1


Even so the impact of Fortran - the first recognizably modern language - must have been very great on these early workers. Many revamped their products and introduced new and more ambitious languages and as the fifties drew to a close it must have looked as if the number of languages was about to explode.

What stopped this explosion was probably the realisation that to slow the growth of Fortran a concerted effort was needed. Surprisingly for the computer industry this realisation resulted in practical action. More in keeping with what we now expect from the computer industry the initial action was to set up a committee - two to be exact!


The computer academics formed various committees but the all-important one was a meeting in Zurich in 1958 which thrashed out the details of a language that was first called IAL (International Algebraic Language) and then ALGOL 58 (ALGOrithmic Language). ALGOL 58 was never implemented but it was the start of a family of ALGOL-like languages including ALGOL 60, its immediate successor.

The stated aim of this committee was to create a language that met the following objectives:

  • It should be close as possible to mathematical notation and be readable without too much additional explanation
  • It should be possible to use it for the description of computing processes in publications
  • It should be mechanically translatable into machine programs

These objectives seem reasonable enough, indeed you might even say that the third one was an obvious requirement for any computer language! The fact that it needed to be included at all should tell you quite a lot about the attitudes and preconceptions of the time.




What is hidden by these simple objectives is the fact that Algol was, and is, an academic's language. The committee made no serious attempt to make the language simple or easy to understand. I'm not saying that they went out of the way to make it difficult; they just assumed that its future users would all be as clever and as well informed as they were.

There is also no denying that Algol is a very elegant language and many of the ideas it introduced we now take for granted. The biggest difference between it and Fortran is that Algol is block structured.

If you program in one of the languages derived from Algol such as Pascal, C, Java or C# say, then block structure will be familiar to you. The basic idea is that you can group together a set of statements using BEGIN and END to bracket them or in our idiom surround them by a pair of curly brackets. The resulting compound statement is treated like a single statement in the language.

As a compound statement is treated like a single statement, a compound statement can be made up of compound statements, which can be made up of compound statements and so on. This nesting behaviour is typical of the ideas used in Algol - they are neat, powerful and elegant but not easy to understand if you are meeting them for the first time or if you are ignorant of the underlying ideas.

The whole block structure and nested scope rules make a lot of sense when you realize that they are what you get if you implement a language that makes heavy use of the stack. You could even say that Algol was the first language to implement high level concepts that originated from the use of a stack to implement the data the code made use of. There is certainly a lot of stack oriented thinking in Algol compared to virtually none at all in Cobol and the very minimum - Gosub and Return - in Fortran.

Algol introduced the IF..THEN..ELSE statement, the WHILE loop and the UNTIL loop which took the language as far away from the underlying machine code as possible.

These ideas were the seeds of the 'structured programming' revolution in the late 60's.

The committee defining Algol must have been like any other academic committee,  i.e. a seething mass of jealousy and self interest! To make matters worse there was a USA v European split which nearly deadlocked the committee over whether a decimal point or comma should be used! Officially it is claimed that the entire committee influenced the design of Algol equally, but reading between the lines there were one or two `leading lights'.

On the committee at various times were Peter Naur, Klaus Samuelson, Heinz Rutishauser, Alan Perlis, and Fritz Bauer. John Backus, the man most responsible for the creation of Fortran, was also involved, but it is difficult to imagine that his heart was in the creation of another language!



Pioneers in the in the development of the ALGOL programming language. (clockwise from top left) Heinz Rutishauser, Peter Naur, Friedrich L. Bauer, Adriaan van Wijngaarden










Last Updated ( Tuesday, 26 November 2013 )