Modula-2

Modula-2 is a systems programming language created by Niklaus Wirth as the successor to his earlier Pascal language. Conceived in 1977 during Wirth’s sabbatical at Xerox PARC and developed at ETH Zurich through the early 1980s, Modula-2 introduced concepts that influenced generations of programming languages: true modules with separate compilation, low-level system access combined with high-level abstractions, and compile-time safety for systems programming.

History & Origins

In the mid-1970s, Niklaus Wirth was designing the Lilith personal workstation at ETH Zurich. He needed a language that combined Pascal’s clarity and safety with the ability to write operating systems and device drivers. Pascal, while excellent for teaching, lacked the modularity and low-level features needed for systems work.

The Mesa and Modula Influence

Wirth drew on his earlier Modula language (1975) and Mesa, a systems programming language developed at Xerox PARC:

1. Module System - Separate interface and implementation
2. Separate Compilation - Compile modules independently
3. Low-Level Access - Direct hardware interaction
4. Coroutines - Lightweight concurrency primitives

Modula-2 refined these concepts while maintaining Pascal’s elegant syntax and strong typing.

Design Philosophy

Modula-2 was designed with clear goals:

1. Modularity - True separate compilation units
2. Type Safety - Catch errors at compile time
3. Efficiency - Minimal runtime overhead for systems work
4. Simplicity - Small, understandable language
5. System Programming - Replace assembly for OS development

Why Modula-2 Mattered

Despite being nearly half a century old, Modula-2’s innovations are still relevant:

1. The Module System

Modula-2 pioneered the separation of interface (DEFINITION MODULE) and implementation (IMPLEMENTATION MODULE):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

(* Stack.def - Interface *)
DEFINITION MODULE Stack;

PROCEDURE Push(x: INTEGER);
PROCEDURE Pop(): INTEGER;

END Stack.

(* Stack.mod - Implementation *)
IMPLEMENTATION MODULE Stack;

VAR data: ARRAY [0..99] OF INTEGER;
    top: INTEGER;

PROCEDURE Push(x: INTEGER);
BEGIN
  data[top] := x;
  INC(top)
END Push;

PROCEDURE Pop(): INTEGER;
BEGIN
  DEC(top);
  RETURN data[top]
END Pop;

BEGIN
  top := 0  (* Module initialization *)
END Stack.

This pattern influenced Go’s packages and many subsequent module systems.

2. Separate Compilation

Modula-2 solved the “recompile everything” problem:

• Compile definition modules to symbol files
• Implementation changes don’t require recompiling clients
• Type checking across module boundaries
• Faster development cycles

This was revolutionary in the late 1970s when C programs frequently recompiled from scratch.

3. Low-Level Programming Safety

Modula-2 provided controlled unsafe operations:

1
2
3
4
5
6
7

FROM SYSTEM IMPORT ADDRESS, ADR, TSIZE;

VAR ptr: ADDRESS;
    size: CARDINAL;

ptr := ADR(someVariable);  (* Get address *)
size := TSIZE(INTEGER);     (* Get type size *)

The SYSTEM module explicitly marks dangerous code - if your program doesn’t import SYSTEM, it’s provably type-safe.

4. Opaque Types

Modula-2 invented information hiding through opaque types:

1
2
3
4
5
6
7
8
9

(* File.def *)
DEFINITION MODULE File;

TYPE Handle;  (* Opaque - clients can't see inside *)

PROCEDURE Open(name: ARRAY OF CHAR): Handle;
PROCEDURE Close(h: Handle);

END File.

Clients can’t access Handle internals, only pass it to module procedures. This became the foundation for object-oriented encapsulation.

Modern Modula-2 Features

Strong Typing with Flexibility

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

TYPE
  Meters = REAL;
  Feet = REAL;

VAR
  distance_m: Meters;
  distance_f: Feet;

(* Compiler error - different types! *)
distance_m := distance_f;  (* Won't compile *)

Subrange Types

1
2
3
4
5
6
7
8

TYPE
  Percentage = [0..100];
  DayOfMonth = [1..31];

VAR
  score: Percentage;

score := 150;  (* Runtime error - out of range *)

Set Types

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

TYPE
  CharSet = SET OF CHAR;

VAR
  vowels: CharSet;

vowels := CharSet{'a', 'e', 'i', 'o', 'u'};

IF 'a' IN vowels THEN
  WriteString("Found a vowel")
END;

Variant Records

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

TYPE
  NodeKind = (Leaf, Branch);

  Tree = POINTER TO Node;

  Node = RECORD
    CASE kind: NodeKind OF
      Leaf: value: INTEGER |
      Branch: left, right: Tree
    END
  END;

Coroutines

Modula-2 had lightweight concurrency before it was cool:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

FROM SYSTEM IMPORT PROCESS, NEWPROCESS, TRANSFER;

VAR
  main, worker: PROCESS;
  workspace: ARRAY [0..1023] OF WORD;

PROCEDURE Worker;
BEGIN
  LOOP
    (* Do work *)
    TRANSFER(worker, main)  (* Yield to main *)
  END
END Worker;

BEGIN
  NEWPROCESS(Worker, ADR(workspace), SIZE(workspace), worker);
  TRANSFER(main, worker)  (* Start worker *)
END.

The GNU Modula-2 Compiler (gm2)

In 2023, GNU Modula-2 became an official part of GCC:

Compilation Model

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Compile definition module
gm2 -c Stack.def

# Compile implementation
gm2 -c Stack.mod

# Compile and link program
gm2 -o program Main.mod Stack.mod

# Or let gm2 handle dependencies
gm2 -o program Main.mod

Modula-2’s Unique Strengths

1. Qualified Imports

1
2
3
4
5

FROM StrIO IMPORT WriteString, WriteLn;
(* Only imports specified identifiers *)

IMPORT StrIO;
(* Must use StrIO.WriteString, StrIO.WriteLn *)

Control exactly what’s visible - prevents namespace pollution.

2. Module Initialization

1
2
3
4
5
6
7
8

IMPLEMENTATION MODULE Database;

(* Module body runs on program start *)
BEGIN
  OpenConnection();
  LoadCache();
  RegisterShutdownHandler()
END Database.

Guaranteed initialization order based on dependencies.

3. FOR Loop Simplicity

1
2
3
4
5
6
7

FOR i := 1 TO 10 DO
  WriteInt(i)
END;

FOR i := 10 TO 1 BY -1 DO
  WriteInt(i)  (* Countdown *)
END;

Clear, readable, no off-by-one errors.

4. Type Compatibility

Modula-2 has strict rules preventing type confusion:

• Assignment compatibility (can assign X to Y?)
• Expression compatibility (can use X and Y in expressions?)
• Parameter compatibility (can pass X where Y expected?)

This caught bugs that C’s implicit conversions allowed through.

PIM vs ISO Standards

Modula-2 had two major standardization efforts:

PIM (Programming in Modula-2)

Wirth’s book series (editions 2, 3, 4):

• PIM-3 (1985) - Most widely implemented
• PIM-4 (1988) - Added SYSTEM module formalization

ISO Standard (1996)

ISO/IEC 10514-1 added:

• Exception handling
• Generic modules (templates)
• Object-oriented extensions (in Part 2)
• Enhanced I/O libraries

Most modern compilers support both dialects.

File Extensions

Modula-2 uses specific extensions:

• .def - Definition modules (interfaces)
• .mod - Implementation modules and programs
• .mi - Module intermediate files (compiler-specific)

Modula-2 vs Pascal

Coming from Pascal, the key differences:

Why Modula-2 Influenced So Many Languages

Go’s Packages

Go’s package system directly descended from Modula-2:

1
2
3

package database  // Like MODULE Database

import "fmt"      // Like FROM fmt IMPORT ...

Ada’s Packages

Ada’s packages with specifications (.ads) and bodies (.adb) reflect similar modular design principles; Ada and Modula-2 were developed concurrently in the late 1970s and share common ancestry in Pascal.

TypeScript/ES6 Modules

Modern JavaScript modules echo Modula-2:

1

export function open()  // Like DEFINITION MODULE exports

Why Modula-2 Didn’t Dominate

If Modula-2 was so innovative, why didn’t it win?

1. Timing - C was already entrenched in Unix (1980s)
2. Tooling - Commercial compilers were expensive
3. Community - Smaller ecosystem than C
4. Wirth Moved On - Created Oberon (Modula-2 simplified)
5. Ada Competition - DoD mandated Ada for defense work

But its ideas live on in every modern language with modules.

Modern Modula-2 Development

Contemporary Modula-2 isn’t isolated:

• gm2 - Part of GCC since 2023, actively maintained
• ADW Modula-2 - Windows-focused implementation
• XDS Modula-2 - Cross-platform compiler with IDE
• Gardens Point - Academic compiler with source code available

Learning Resources

Active resources for Modula-2:

• GCC gm2 Documentation - gcc.gnu.org/onlinedocs/gm2/
• Programming in Modula-2 - Wirth’s classic text (PDF available)
• Modula-2.org - Community site with tutorials
• ISO Standard - ISO/IEC 10514 (for comprehensive reference)

Modula-2 Philosophy

Wirth’s design principles shine through:

1. Make it simple - Small, understandable language
2. Make it safe - Strong typing catches errors
3. Make it modular - Separate compilation and interfaces
4. Make it efficient - Minimal runtime overhead
5. Make it consistent - Orthogonal feature set

These principles influenced every language Wirth designed: Pascal, Modula-2, Oberon, and indirectly Go (Wirth’s student Robert Griesemer co-created Go).

The Lilith Connection

Modula-2 was born from necessity - Wirth needed a language to implement:

• Lilith Workstation - Personal computer with bitmap display (developed 1978-1980)
• Lilith OS - Complete operating system in Modula-2
• Compiler - Self-hosting Modula-2 compiler
• Applications - Text editor, debugger, all in Modula-2

This demonstrated that a type-safe, high-level language could be used for full systems programming.

Modula-2 in the Wild Today

While not mainstream, Modula-2 still runs critical systems:

• Embedded Systems - Industrial controllers and automation
• Education - Teaching systems programming and modularity
• Legacy Systems - 1980s-90s software still maintained
• GCC Development - gm2 actively developed by GNU community

Continue to the Hello World tutorial to write your first Modula-2 program.