[CWC logo] The Rough Guide to Programming Languages

Computer Shopper's lexicon of programming languages, old and new, concludes with an overview of the history of computing

While there are other languages that could be covered as part of the Rough Guide, and I have no doubt that angry enthusiasts for language X are already massing on the hilltops, it seems time to call a close before we degenerate into the examination of increasingly similar dialects.

By now you have seen enough languages to get an impression of what is possible - this should enable you to come to terms with any new language that pops up. In short, the Rough Guide has explored all of the components that go to make a language, and anything new should be recognisable as a combination of features that you've seen before. All that's left is to provide an overview that shows how one language relates to another.

In the beginning

Computing is an amazing subject, in that it has grown out of nothing in less than a lifetime You can still meet many of the pioneers of computing - not Babbage, of course, but many of the pioneers of the electronic phase of computers, who are still computing today. Yet the pace of progress has been so fast that it can be difficult to imagine the opinions and feelings of the early workers. For example, back in the early days, programmers thought high-level languages were impossible to construct - and even if they were possible, they were undesirable and unnecessary!

The early days of programming were only a fraction removed from the hot soldering iron, let alone machine code, and programmers couldn't see that there were any benefits to be gained from moving away from the internal structure of the machine. Indeed, as efficiency was then the most important consideration, and the highly technical skill of programming took a long time to acquire, many thought that high-level languages would simply be impractical . There were many experimental languages around at the time that edged the idea of an assembly language towards the idea of a high- level language, but the real breakthrough was Fortran.

The principal designer of Fortran was John Backus, but he had a little help from IBM . Even so, it took around five years and lots of programmers to produce the working compiler that emerged in 1958. This really was the forefront of technology, because there wasn't anycompilertheoryto help, and Fortran (standing for 'formula translation') had to include the ability to compile arbitrarily complicated arithmetic expressions written in a natural algebraic way. The early versions of Fortran had lots of problems, but the successful implementation of a high-level language demonstrated two things: it could be done and it was worth doing. After Fortran, the flood gates were open and high-level languages poured though.

The Big Three

The most notable of the languages of the early era, besides Fortran, were Cobol and Algol. Interestingly, these first three are still good representatives of the three general styles of high-level language, and all modern languages have traceable roots in one or more of these.

Fortran was, and is, a language designed to be used by scientists and engineers. It caters for their needs by making it easy to code complicated bits of maths and by being good at numerical I/O. Cobol was originally proposed as a non-technical language. The original designers (principally Grace Hopper, as far as I can tell) even doubted that the people who wanted to use it could cope with algebraic notation - so instead of A+B you had to write A PLUS B. This approach did make Cobol the least technical of languages, and also the most wordy. It wasn't so good at working things out, but it was good at moving data from one place to another and displaying it.

Now we come to Algol. Algol was designed by computer scientists for computer scientists. It included all of the fun computing ideas of the time - nested block structure, recursion and so on. It was hopeless at the practical things that Fortran and Cobol were good at, but it was a theoretically pleasing language! Neatly enough, the three languages were a success with the audiences that they were aimed at - scientists used Fortran, business people used Cobol and the computer scientists used Algol. Of course, this is a picture simplified to the point where some distortion of reality is inevitable, but it's not a gross distortion.

As an aside, it's worth mentioning that IBM's success with Fortran encouraged the company to try its luck a second time with a mega-language that incorporated elements of Fortran, Algol and Cobol. It was called PL/1, standing for Programming Language 1. The main problem with PL/1 was that it was a bit on the big side. You still come across the occasional compiler for PL/1, or a subset, but it can't be rated as a popular language.

Family tree

Although Fortran and Cobol, as a pair, were more successful in terms of the number of people using them, it was Fortran and Algol that actually gave rise to more new language offspring. In fact, apart from its partial inclusion in PL/1, I can't think of a single language that was influenced by Cobol. Perhaps the reason is that the original Cobol language went as far down that particular road as a high-level language can. However, this is to overlook the influence that Cobol has had over applications- based languages. For example, what is the dBASE language if not an easier-to-use dialect of Cobol?

Fortran's best-known off-spring has to be Basic. In many ways, early Basic is just a cut-down version of Fortran with extras to cope with the needs of an interactive environment. Although philosophers will probably haggle for many years about exactly what made Basic the great success that it has been, I think it was the combination of Fortran's simple structure with the broadening of its applications area to include non-numeric work. Basic was and still is, one of the easiest languages in which to do character-based work, because of its use of variable-length strings. Its biggest mistake was to generalise the line number labels used by Fortran into combined line editing and label numbers. This, plus the fact that it didn't support modules of anykind worth using, made it an essentially weak language.

Of course, I would argue that this weakness has been overcome in modern versions of Basic by the inclusion of procedures and functions. Indeed, some might even argue that QuickBASIC is slightly too aggressive in its insistence on modular construction - to the point that the editor only lets you work with one subroutine at a time!

Algol spawned many a dialect and version, with catchy titles such as Algol 68 and Algol W. It's not unreasonable to suppose that one of the main reasons why no single Algol derivative ever caught on was that there were so many of them - a clear case of 'divide and fall'. Mind you, Algol did eventually give rise to two success stories, Pascal and C. Pascal is best described as a cut-down and simplified version of Algol. It was designed as a compact teaching language, and that is still where it excels. But once you have learned to program using Pascal, you will probably want to go on using it for real work, and for this you need the 'real world' Pascal systems such as Turbo Pascal. These supplement the basic Pascal language with a collection of libraries that extend it to make it easy to tackle real problems. It is arguable that real-world Pascals have moved so far away from the original idea that they aren't really Pascal in spirit.

C, on the other hand, is more like a fusion of a simplified Algol and assembler-level constructs. I have previously described C in print as a high-level assembler, and I know just how much this irritates C enthusiasts. But, sorry, folks, that really is what it is - and what makes it good at the jobs it tends to be used for.

Black sheep

There are languages that, while they might be useful in their own right, don't really lead anywhere. Whether they are historical curiosities, a product of the state of technology at the time, or whether they contain some really good general principle waiting to be rediscovered is difficult to say. The prime example of such a historical curiosity is Forth. This is a stack-orientated language that, once you understand the idea of an operator stack, is a powerful way of generating programs that can be interpreted in an efficient way.

Forth was successful because the hardware it was aimed at wasn't very powerful, so there was a choice to be made between languages that were easy to use but slow and languages that were difficult to use but fast. Forth was a sort of compromise, a language that was moderately difficult to use but moderately fast. As hardware has grown increasingly powerful, Forth has become less and less useful. This argument is confirmed by the fact that the one remaining Forth stronghold is in the programming of dedicated controllers - ie not-so-powerful microprocessors where the alternatives to Forth are still 'difficult but fast' assembler and 'easy but slow' high-level languages. Forth's explicit use of a stack may be dying out, but it isn't a principle that is being lost. For example, the stack is also at the heart of the Algol family's nested block structure, and all nested control and data structures. The difference is that the stack remains hidden under the language rather than being a central feature of it.

The only language that I have difficulty placing in the scheme of things is the notorious APL. This is an operator language that is more like a formal mathematical notation than a language. It's possible to write amazingly complex programs in a single APL line, and many of its enthusiasts like it for just this reason. In its defence, it is often pointed out that you don't have to write one-line programs in APL. Whatever its inherent merits, the principles of APL don't seem to lead onto a family of languages or to any generalisation. Like many mathematical notations, its conventions seem arbitrary. APL may be the best sort of language of its type, but it's also the only one!

New generation

If the trinity of Fortran, Algol and Cobol held the stage for the first phase of language development, then the trinity for the next stage consists of general principles rather than particular languages: object orientation, logic programming and functional programming. The first phase of development saw all languages incorporate structure and modularity- other changes were just frills. Now the traditional languages were rapidly incorporating object- orientated features, object-orientated Pascal and C++ being the best-known examples.

Modula 2, a development of Pascal, was really designed with a stricter form of modularity in mind, but now that looks more or less identical to a weak form of the object- orientated philosophy. Of course, there are many new languages that are purpose-built vehicles for the object-orientated method - Smalltalk and Actor, to name but two - but none has a user base as large as a traditional language, or even the object-orientated extension of a traditional language.

Logic programming is exemplified by the language Prolog, but there are others. A logic programming language aims to do away with the procedural ('what to do') aspect of programming. In a logic programming language, you state the facts and what is required, and expect the language to sort out the details of how the result is to be obtained.

Paths less trodden

The third force is the functional languages. The basic idea is to use strictly mathematical functions as a way of getting rid of the procedural aspect. You may not have noticed, but the functions you find in a programming language do not behave in the same way as mathematical functions. For example, no matter how many times you use a mathematical function on the same input, you always get the same result. This isn't necessarily the case with programming functions, which can store 'histories' in state variables and so on. In short, functional languages do away with the assignment operator and replace it by the evaluation of functions.

At the moment there are no good examples of functional languages in general use - the closest is Lisp, which isn't a pure functional language and is only just in general use. The reason for the lack of impact of the functional languages is twofold. Firstly, it is difficult to add a functional extension to a traditional language, and secondly, functional languages don't offer anything other than the promise of more reliable programs.

My final comment is Ada. Just when you thought it was safe to assume that mega-languages were dead, along with PL/1, along comes Ada - the most mega of all languages. It is a large language that includes Algol, Fortran and Cobol-like elements all mixed up together. Personally I like it, but there are a lot of programmers who think it should join PL/1 as quickly as possible.

The above article first appeared in Computer Shopper, November 1991, and was written by Mike James. Their kind permission to reproduce this article is gratfully acknowledged. 

1954
1955       FORTRAN   (1954-57)
1956
1957
1958       ALGOL 60  (1958-60)
1959       COBOL     (1959-60)
1960
1961
1962
1963       PL/1      (1963-64)    ALGOL 68    (1963-68)
1964       BASIC     (1964)
1965
1966
1967
1968       PASCAL    (1968-71)
1969       BCPL      (1969)
1970
1971
1972
1973
1974       C         (1974-78)
1975       CONCURRENT PASCAL (1975)
1976
1977       MODULA  2 (1977-80)
1978       ADA       (1978-82)
1979
1980
1981       OCCAM     (1981)
[Leicester University] [] Computer Centre
Information Suppliers: Richard Mobbs, Head of Information Services, Leicester University Computer Centre and Marina Carter, Postgraduate Student, Leicester University Computer Centre.
Last Updated: July 1996