The 1960s saw the growth of interest in computer languages but, unlike today where successful languages are often designed by small teams and even 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 as distinctly different languages.

As outlined in the first part of the History of Computer Languages, during the 1950s Fortran emerged as a compiled language, a high-level lanaguage by contrast to assembly language. By the end of the decade 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, which is all about numerical computation and had other aspects of computer as an afterthought, 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.

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 and 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!

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 the1950s 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!

ALGOL

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 60s.

<ASIN:0735611319>

<ASIN:0124916503>

<ASIN:3540430814>