The Evolution of Programming Languages

A number of languages were developed when computers started to become available to a significant user community, around 1960. Such languages include FORTRAN and COBOL, still in widespread use today albeit with many extensions.

In the 1960s, researchers started to bring important ideas that were to affect the development of computer languages thereafter. Algol is the ancestor of many classical structured programming languages. Simula, initially targeted at simulation tasks, brought many of the important concepts now behind object oriented programming languages. Lisp is representative of flexible interpreted programming environments and has the seeds of functional programming.

The 1970s brought Pascal, Modula-2 and C. Modula-2 was created by Niklaus Wirth, as an improvement over his earlier creation Pascal. It is the classical example of a structured modular compiled programming language. C was developed as a portable assembler to build the UNIX operating system. While it offers several high level constructions like structures, procedures and loops, it retains all the flexibility of assembly programming.

In the following decade, several programming languages tried to establish themselves as successors to the popular FORTRAN, COBOL, Pascal and C. Smalltalk was probably the forerunner in the object oriented renaissance. Lisp and its object oriented version CLOS gained in popularity. Ada was developed as the standard programming language for the United States defense department; it is strongly inspired from Modula-2. Object oriented extensions are being added and the result is called Ada 9X, described in a 500 pages reference manual. Functional programming took off with Scheme and eventually ML.

The C language popularity grew with UNIX usage, and object oriented extensions were developed by Bjarne Stroustrup. Similarly, Niklaus Wirth experimented with minimalism and produced a strikingly simple language Oberon, later followed by Oberon II which includes object oriented features. Luca Cardelli, Jim Donahue, Mick Jordan, Bill Kalsow and Greg Nelson developed Modula-3, a modular object oriented programming language strongly inspired from Modula-2. Eiffel was developed by Bertrand Meyer and centers everything around objects. Hermes, developed under the direction of Robert E. Strom, takes a different approach, emphasizing distributed computing.

Selecting a programming language among those available can be an arduous task. Criterions may include performance, language features, available libraries, potential for reuse, maintainability, cost and availability, programming support... While several hundred programming languages have been developed over the years, only a few tens are reasonably active and, for example, have a discussion group on the Internet Usenet News system.

In the following sections, a number of serious contenders for developing object oriented applications are examined.

Ada 9X

Ada 9X is a powerful, albeit complex, compiled modular object oriented programming language. Its use is mandated for several US government projects. Ada did not succeed as expected in the past because of its complexity and the lack of lightweight, efficient and affordable implementations. Libraries availability was also problematic. Ada 9X was created with the intention of correcting some of these deficiencies. Free implementations and more libraries are now available. The language remains complex and lacks garbage collection in the base implementation. It has extensive support for multi-threading.

C++

C++ builds on the popularity of C on UNIX and DOS/Windows platforms. It offers many object oriented features, including virtual and non virtual methods, function and operator overloading, single and multiple inheritance, templates and exceptions. It lacks garbage collection and support for multi-threading.

The biggest asset, and problem, of C++ is C compatibility. It enabled C++ to become the most widely used object oriented language. However, many C features, chiefly the unrestricted use of pointers and the lack of explicit interfaces, make encapsulation, garbage collection and run-time error detection difficult if not impossible to achieve. Free and low cost efficient implementations are available for almost every platform.

CLOS

This interpreted extension of LISP offers very powerful object oriented features. It supports all the usual features, including multiple inheritance and garbage collection, and adds generic functions which are selected at run time based on the actual type of all the arguments. Multi-threading support, however, is missing. Several libraries and free implementations are available.

The cost of this expressiveness and flexibility is in much higher memory and CPU usage as compared to most compiled object oriented languages.

Eiffel

Eiffel uses object types not only for inheritance but also as the unit of encapsulation and modularity. It supports multiple inheritance and garbage collection. It emphasizes assertions about properties that must hold for each object type before or after methods are called. Multi-threading is not supported.

For a long time, the only implementations available were slow and buggy and few libraries were available. Newer implementations are much better now. No free implementation is yet available, however.

ML

ML and its cousins enjoy wide recognition among computer scientists and mathematicians and typifies functional programming languages. Functional programs have a number of interesting properties and are easy to transform in various ways, in particular to execute on parallel computers. Functional programming languages, however, are not well suited for many interactive programming tasks and often require much more memory and some more CPU than equivalent non functional programs. Several free implementations are available.

Modula-3

This language represents an excellent compromise between expressiveness and simplicity. Modula-2+ was built as an object oriented extension to Modula-2. Modula-3, instead, was built from scratch retaining only the best proven features of Modula-2+ and other similar languages. It does not support multiple inheritance and operator overloading but comes with garbage collection and multi-threading support.

A free implementation and numerous libraries are available. It is particularly well suited for distributed object oriented applications.

Object Pascal

A new standard was recently established for Object Pascal. However, few if any implementations are available, and programmers are using it. Nonetheless, non standard object oriented variants of Pascal are in widespread use but their portability is limited.

Oberon

Oberon is an experiment in minimalism. It offers a very limited set of features. It was developed for building an operating system used for teaching. Very efficient free implementations are available along with interesting libraries. It uses a very limited garbage collection and tasking model.

Smalltalk

The Smalltalk environment is very interesting for prototyping. Free implementations and many libraries are available. It is a simple yet very expressive language. The drawback, however, is the run time overhead of this interpreted language and the lack of type declarations and static type checking.


Copyright 1995 Michel Dagenais, dagenais@vlsi.polymtl.ca, Wed Mar 8 14:41:03 EST 1995