Niklaus Wirth designed Pascal as an educational programming language. Consequently, he could (and did) ignore many of the problems encountered in large- or even medium-scale programming projects. Unfortunately, a large number of programmers and companies decided to adopt Pascal as a real programming language, adding features as needed to get around its deficiencies.

I looked into Pascal about twenty years ago, when it was receiving a great deal of this sort of attention. I liked its type-checking and its ability to structure code and data. I could not abide its arbitrary restrictions, missing features, single-pass orientation, and very poor state of standardization.

Brian Kernighan's wonderful paper "Why Pascal is Not My Favorite Programming Language" (Bell Laboratories, July, 1981) details many of these problems, and sums up my attitude very succinctly: "Pascal, at least in its standard form, is just plain not suitable for serious programming."

The Pascal language family has not gone away, however, and in fact is quite active in freeware circles. There isn't much straight Pascal around, to be sure, but the language's progeny (Ada, Modula-2, Modula-3, and Oberon) are all pretty healthy, and some look very interesting indeed.


Stu Feldman quipped that Ada's success is tied to the second derivative of the US defense budget. It can also be argued that Ada is simply too complicated for most programmers to master and use with any facility. For a while, it looked as if Ada was too complicated to even compile efficiently, but that problem appears to be under control. Finally, it has been pointed out that Ada owes more of its voluminous nature to PL/1 than to Pascal. Nonetheless, Ada does address a real problem with real technology, and it isn't going away any time soon.

The impetus for Ada was the realization that the DoD had funded the development of literally hundreds of real-time programming languages. Each one, developed for use in building a particular embedded system, was totally forgotten after the system in question was shipped. Any tools built for the language were lost, and any effort spent in training was wasted.

The DoD sponsored Ada in attempt to get out of this situation, and seems to be relatively successful. Several commercial Ada implementations are on the market, and Ada is being used in numerous large-scale projects. Meanwhile, some freeware enthusiasts have jumped in to help.

The Ada Software Repository, located on seems to be the logical starting point. FTP in and grab SIMTEL20-ADA.INFO.6. It gives an overview of the repository, plus pointers to a number of subsidiary files.


While Ada and C++ both have huge language definitions, Modula-2, Modula-3 and Oberon are all described in fifty pages or less. The philosophy of language design behind all three has been to carefully combine a small number of well-understood features that offer a minimum of complexity and a maximum of power.

Moreover, Dr. Wirth actually designed Modula-2 (unlike Pascal) for use as a production programming language. The syntax is cleaner and more powerful than Pascal's, some arbitrary and annoying limitations have been removed, and useful new features have been added. In short, Modula-2 really is "suitable for serious programming."

Modula-2's central concept is the "module", which consists of an interface definition and a set of implementation code. The interface definition, like ANSI C's function prototypes, allows programmers to code for the interface, relying on the compiler to catch mis-matched types, etc. The definition also controls which functions within a module are visible to external code. This feature isn't seen in C, but is present, in effect, in C++.

mtc, a Modula-2 to C translator, can be found in p2c, a Pascal to C translator, is available in

WRL Modula-2, a much more ambitious system, is available in Olsen & Associates Portable Modula-2 Library can be found as yaml-* in


Modula-3 is a greatly enhanced version of Modula-2. It generalizes opaque types, allowing partial revelations of their nature. It supports both automatic and explicit garbage collection, type-safe exception handling, (single) inheritance, thread-based concurrency, and many-to-many relationships between interfaces and modules. Modula-3 also supports structural (as opposed to name-based) type equivalence, allowing type-safe distributed programming.

The Modula-3 community is supported by a massive collection in The archive contains boot code, example programs, and large amounts of mailing list and news group discussions. Be sure to peruse the README file in the release directory before initiating any FTP's, lest you grab large amounts of useless (on your machine) boot code.


The Oberon System is quite a bit more than a programming language. Indeed, its authors describe it as "an entire software environment for a modern workstation". Nonetheless, the entire suite of code is small enough to be studied and/or modified by an interested individual.

As a programming language, Oberon looks like a minimalist version of Modula-2. Cardinals (unsigned integers) and enumerated types, for instance, have disappeared, along with explicit support for concurrency. On the other hand, Oberon supports automatic garbage collection and extends the Modula-2 type system to support object-oriented programming.

Commercial and public domain implementations are available for most popular platforms. A programming environment much like Smalltalk in spirit has been developed over several years at ETH in Zurich. The Oberon code can be found in i


Much of the information in this article was contributed by Frode Odegard ( His company, Odegard Labs (San Francisco, CA), develops systems and application software using Modula-2 and Modula-3. I sincerely hope I have not misinterpreted his explanations too badly, or left out anything critical. In any case, here is Frode's summary, for your edification and amusement: