Modula-2

Modula-2 is a general purpose procedural language, sufficiently flexible to do systems programming, but with much broader application. In particular, it was designed to support separate compiling and data abstracting in a straightforward way. Much of the syntax is based on Wirth's earlier and better-known language, Pascal. Modula-2 was designed to be broadly similar to Pascal, with some elements and syntactic ambiguities removed and the important addition of a module concept, and direct language support for multiprogramming.

The language allows use of one-pass compilers. Such a compiler by Gutknecht and Wirth was about four times faster than earlier multi-pass compilers.[6]

Here is an example of the source code for the "Hello world" program:

MODULE Hello;
FROM STextIO IMPORT WriteString;
BEGIN
  WriteString("Hello World!");
END Hello.

A Modula-2 module may be used to encapsulate a set of related subprograms and data structures, and restrict their visibility from other parts of the program. The module design implemented the data abstraction feature of Modula-2 in a very clean way. Modula-2 programs are composed of modules, each of which is made up of two parts: a definition module, the interface portion, which contains only those parts of the subsystem that are exported (visible to other modules), and an implementation module, which contains the working code that is internal to the module.

The language has strict scope control. The scope of a module can be considered as an impenetrable wall: Except for standard identifiers, no object from the outside is visible inside a module unless explicitly imported; no internal module object is visible from the outside unless explicitly exported.

Suppose module M1 exports objects a, b, c, and P by enumerating its identifiers in an explicit export list

  DEFINITION MODULE M1;
    EXPORT QUALIFIED a, b, c, P;
    ...

Then the objects a, b,c, and P from module M1 become now known outside module M1 as M1.a, M1.b, M1.c, and M1.P. They are exported in a qualified manner to the outside (assumed module M1 is global). The exporting module's name, i.e. M1, is used as a qualifier followed by the object's name.

Suppose module M2 contains the following IMPORT declaration

  MODULE M2;
    IMPORT M1;
    ...

Then this means that the objects exported by module M1 to the outside of its enclosing program can now be used inside module M2. They are referenced in a qualified manner, thusly: M1.a, M1.b, M1.c, and M1.P. Example:

    ...
    M1.a := 0;
    M1.c := M1.P(M1.a + M1.b);
    ...

Qualified export avoids name clashes: For example, if another module M3 would also export an object called P, then we can still distinguish the two objects, since M1.P differs from M3.P. Thanks to the qualified export it does not matter that both objects are called P inside their exporting modules M1 and M3.

An alternative method exists, which is in wide use by Modula-2 programmers. Suppose module M4 is formulated as this:

  MODULE M4;
    FROM M1 IMPORT a, b, c, P;

Then this means that objects exported by module M1 to the outside can again be used inside module M4, but now by mere references to the exported identifiers in an unqualified manner, thusly: a, b, c, and P. Example:

    ...
    a := 0;
    c := P(a + b);
    ...

This method of unqualifying import allows use of variables and other objects outside their exporting module in exactly the same simple, i.e. unqualified, manner as inside the exporting module. The walls surrounding all modules have now become irrelevant for all those objects for which this has been explicitly allowed. Of course unqualifying import is only usable if there are no name clashes.

These export and import rules may seem unnecessarily restrictive and verbose. But they do not only safeguard objects against unwanted access, but also have the pleasant side-effect of providing automatic cross-referencing of the definition of every identifier in a program: if the identifier is qualified by a module name, then the definition comes from that module. Otherwise if it occurs unqualified, simply search backwards, and you will either encounter a declaration of that identifier, or its occurrence in an IMPORT statement which names the module it comes from. This property becomes very useful when trying to understand large programs containing many modules.

The language provides for (limited) single-processor concurrency (monitors, coroutines and explicit transfer of control) and for hardware access (absolute addresses, bit manipulation, and interrupts). It uses a nominal type system.

There are two major dialects of Modula-2. The first is PIM, named for the book Programming in Modula-2 by Niklaus Wirth.[4] There were three major editions of PIM: the second, third (corrected), and fourth. Each describes slight variants of the language. The second major dialect is ISO, named for the standardization effort by the International Organization for Standardization. Here are a few of the differences among them.

• PIM2 (1983)
  • Required explicit EXPORT clause in definition modules.
  • Function SIZE needs to be imported from module SYSTEM
• PIM3 (1985)
  • Removed the EXPORT clause from definition modules following the observation that everything within a definition module defines the interface to that module, hence the EXPORT clause was redundant.
  • Function SIZE is pervasive (visible in any scope without import)
• PIM4 (1988)
  • Specified the behaviour of the MOD operator when the operands are negative.
  • Required all ARRAY OF CHAR strings to be terminated by ASCII NUL, even if the string fits exactly into its array.
• ISO (1996, 1998)
  • ISO Modula-2 resolved most of the ambiguities in PIM Modula-2. It added the data types COMPLEX and LONGCOMPLEX, exceptions, module termination (FINALLY clause) and a complete standard I/O library. There are numerous minor differences and clarifications.[7]

There are several supersets of Modula-2 with language extensions for specific application domains:

• PIM supersets
  • Canterbury Modula-2, extended with Oberon-like extensible records [This has been withdrawn and is no longer available anywhere]
  • Modula-2+, extended with preemptive threads and exceptions
  • Modula-2*, parallel extension[8]
  • Modula-P, another parallel extension[9]
  • Modula-Prolog, adding a Prolog layer[10]
  • Modula/R, with relational database extensions
  • Modula-GM, extensions for embedded systems
• ISO supersets
  • ISO10514-2, adding an object-oriented programming layer[11]
  • ISO10514-3, adding a generics layer[12]
• IEC supersets
  • Mod51, extended with IEC1131 constructs for embedded development

There are several derivative languages that resemble Modula-2 very closely but are new languages in their own right. Most are different languages with different purposes and with strengths and weaknesses of their own:

• Modula-3, developed by a team of ex-Xerox employees who had moved to DEC and Olivetti[13]
• Oberon, developed at ETH Zürich for System Oberon[14] available online.
• Oberon-2, Oberon with OO extensions[15]
• Active Oberon, yet another object-oriented Extension of Oberon, developed also at ETH with the main objective to support parallel programming on multiprocessor and multicore systems.
• Parallaxis, a language for machine-independent data-parallel programming[16]
• Umbriel, developed by Pat Terry as a teaching language[17]
• YAFL, a research language by Darius Blasband[18]

Many other current programming languages have adopted features of Modula-2.

• ACK Modula-2 for MINIX (freeware)
• ADW Modula-2 ADW Modula-2 for Windows, ISO compliant, ISO/IEC 10514-1, ISO/IEC 10514-2 (OO extension), ISO/IEC 10514-3 (Generic extension) (freeware)
• Aglet Modula-2 for Amiga OS 4.0/PPC (freeware)
• Cambridge Modula-2 for various micro-controllers and embedded MINOS operating system (commercial + proprietary software)
• FST Fitted Software Tools Modula-2 for DOS (freeware)
• Gardens Point Modula-2 for BSD, Linux, OS/2 and Solaris - ISO compliant (freeware), as of July 30, 2014, original website is down
• Gardens Point Modula-2 (GPM/CLR) for .NET (freeware)
• GNU Modula-2 for GCC platforms, version 1.0 released December 11, 2010; PIM2, PIM3, PIM4, and ISO compliant (free software, GPLed)
• M2Amiga for Amiga (free software)
• M2M by N. Wirth and collaborators from ETH Zurich, platform independent, generates M-code for virtual machine (freeware)
• MacMETH by N. Wirth and collaborators from ETH Zurich for Macintosh, but Classic only (freeware)
• Mod51 for the Intel 80x51 micro-controller family, ISO compliant, IEC1132 extensions (commercial + proprietary)
• Megamax Modula-2 for Atari ST computers by T. Tempelmann. Documentation only in German language.
• Modula-2 R10 Reference compiler for Modula-2 R10 (open-source/peer-review)
• ModulaWare for OpenVMS, both VAX and Alpha, ISO compliant (commercial + proprietary)
• Native XDS-x86 for Windows and Linux (x86), ISO compliant, TopSpeed compatible library (freeware)
• ORCA/Modula-2, a compiler available for the Apple Programmer's Workshop, for the Apple IIgs
• p1 Modula-2 for Macintosh, both Classic and Mac OS X (PPC and Carbon API only), ISO compliant (commercial + proprietary)
• The Karlsruhe Modula-2 Compiler MOCKA for various platforms, PIM compliant (commercial, freeware Linux/BSD versions)
• TDI Modula-2 for Atari ST from TDI Software, Inc.
• TERRA M2VMS for OpenVMS, both VAX and Alpha, PIM compliant (commercial + proprietary)
• The Ulm Modula-2 System for Solaris, both SPARC and MC68K (free software, GPLed)
• XDS-C for Windows and Linux, 16- and 32-bit platforms, targeting C (K&R & ANSI), ISO compliant, TopSpeed compatible library (freeware)

• Wirth, Niklaus (1988). Programming in Modula-2 (4th ed.). Berlin Heidelberg: Springer-Verlag. ISBN 978-0-387-96051-7.
• King, K. N. (1 January 1988). Modula-2: A Complete Guide. Burlington, Massachusetts: Jones and Bartlett Publishers. ISBN 978-0669110913.
• Sutcliffe, Richard J. (2004–2005). Modula-2: Abstractions for Data and Programming Structures. Arjay Books. ISBN 978-0-669-11091-3. Uses ISO-standard Modula-2.
• Gleaves, Richard (1984). Modula-2 for Pascal Programmers (1st ed.). Switzerland: Springer Nature. ISBN 978-0-387-96051-7.
• Cooper, Doug (1 September 1990). Oh My! Modula-2: An Introduction to Programming. New York City, New York: W. W. Norton & Company. ISBN 978-0393960099.

• Official website

This article is based on material taken from the Free On-line Dictionary of Computing prior to 1 November 2008 and incorporated under the "relicensing" terms of the GFDL, version 1.3 or later.