Today objects seem to have taken over every language but back in the 1980s it still wasn't clear that we had found the best approach and so every new idea was latched onto and deemed to be an important breakthough.
Standard programming languages are imperative in the sense that programs written using them are long "do this" lists. They are instructions about what the computer must do and as such they are not just the static texts.
For example, a loop may look as if it is just a few lines of instructions but when run it may result in thousands of instructions. In other words, the few lines of static text give rise to many more lines of instructions when interpreted dynamically.
The distinction between the static text and the dynamic activation of a program was made use of in object-oriented languages by allowing a single program text to give rise to any number of instances of the running program.
In non-imperative programming the distinction between the static and dynamic text of the program is removed. If you are used to standard programming methods then this may sound impossible but there are two distinct ways in which it can be achieved - functional languages and logical languages.
Functional languages such as Lisp, FP and Hope did away with imperative programming by insisting that everything is written in terms of mathematical functions and assignment cannot be used.
Assignment is at the heart of imperative programming. Writing
means that each time this part of the program is executed A has a different value and this means that the program's text cannot have a single meaning. In other words asking what is the value of A and expecting a single answer is silly if you allow assignment.
Instead of assignment functional languages make use of recursion to create new variables and so change values on the sly. Recursion is also used to replace loops so making the program text identical to is run time form. The only problem is that many programmers find recursion difficult. Even so the best known functional language, LISP designed by John McCarthy of MIT back in 1959, still has its loyal devotees and it is still the main language for AI in one form or another.
The most successful of all of the non-imperative languages is Prolog. Rather than being a functional language Prolog is based on the idea of writing programs as a set of logical statements and using an automatic theorem prover to work out the results automatically.
In principle this approach frees the programmer from worrying about exactly how the result is obtained - all that has to be included in the program are the facts that are known and what is required to be deduced.
The strange thing about Prolog is that it needed some fundamental breakthroughs in logic - in automatic proof procedures to be exact. Most other languages were simply a matter of design and implementation difficulties. The language itself was developed by Alain Colmerauer and Philippe Roussel in 1972 at the University of Marseilles.
The name Prolog was suggested by Phillipe's wife Jacqueline as an abbreviation of "PROgrammation en LOGique". As well as Marseilles the University of Edinburgh was involved in the development. Robert Kowalski contributed much to the theory of logic programming, Maarten van Emden provided a demonstration that it could work and David Warren produced the first efficient implementation that was essential to Prolog's success in the real world.
The most important part of the Prolog story is its adoption by the Japanese in 1981 as part of the ten year fifth generation project. This panicked many programmers in the USA to reconsider their use of Lisp as the first choice for AI programming. Without the Japanese intervention Prolog would probably have remained a curiosity. It could even be that the Japanese intervention served to rush the process of Prolog's acceptance into general programming.
It may be that logic programming as well as functional programming is a technology that has yet to see its true potential - on the other hand it might just be a specialism that works in some situations leaving imperative object oriented languages to do the real work..
Although not new languages in their own right it would be unfair to close a discussion of programming languages in the 80's without mentioning the Borland family of Turbo languages.
Turbo Pascal was the first of a new generation of high speed interactive compilers complete with an easy to use development environment. Its creator, Anders Heilsberg, (who went on to develop C# for Microsoft) is yet another example of the Scandinavian influence on computing.
Anders Heilsberg, born 1960
Before Turbo Pascal compilers were slow and difficult to use and this was the reason why interactive languages such as BASIC were implemented as interpreters. After Turbo Pascal compilers were fast, interactive and there was no longer any excuse for difficult to use environments just because programmers were technical enough to cope!
Following Turbo Pascal the integrated program development environment was included in Turbo C, Turbo BASIC and Turbo Prolog and quickly copied by the Quick language family from Microsoft and the JPI family from Jensen.
This emphasis on the complete programming environment probably accounts for more increase in programmer productivity and accuracy than any other change in programming languages since Fortran was introduced.
Away from the mainstream
There are two other languages that made their first real impact in the 80's that deserve mention but don't really fit into any neat category - Modula 2 and Ada.
Modula 2 was Niklaus Wirth's offering as a modern replacement for Pascal.
Niklaus Wirth, born 1934
Essentially an upgrade to Pascal, Modula was designed in 1975 in the early 1970s as a language that could be used for concurrent/parallel programming. In 1980 he released Modula 2, a more general purpose extension of Pascal that included features that can be described in object oriented jargon.
Modula 2 allows programs to be built up of interacting modules and it restricts what one module can `see' of another's workings to just the interface between the two. This allows the programmer to concentrate on what a module does rather than on how it does it. This is just an extension of the basic principles of structured programming and it is clear that this is how Wirth thought of it. However it is possible to describe the module as providing the data hiding and encapsulation facilities that are one of the foundations of the object-oriented method.
As an object-oriented language Modula 2 isn't a good specimen and it is probably better to see it as the last in the line of the traditional Algol like structured languages.
Ada on the other hand is probably best seen as the last of the super languages. Unlike the other languages produced in the 70's and 80's, Ada was produced by a committee and as such it is a return to the Algol/Cobol method of language creation. Ada is a huge language that includes an incredible range of statements and features. For this reason it can be used as if it was Fortran or Cobol and it can be used to create object oriented program and even functional programs. In short it is everything to everyone.
Although introduced in the 80'sand still in use, never got the boost it needed to make it truly popular and today it is almost in the same category as Cobol i.e. a language every one complains about having to use.
For the development of other computer languages see the other parts of this series covering the 1950s and onwards
In the mid 70s it was revealed that British Intelligence had been using machines to break the German coded communications - and one of the machines was an early electronic computer called Colossus. Ca [ ... ]
The 1970 saw the rise of languages created by small groups of people rather than committees or institutions and much of the cause was the number of personal computers that had appeared and where in ne [ ... ]