Modula-2

Modula-2 is a systems programming language created by Niklaus Wirth as the successor to his earlier Pascal language. Designed between 1977 and 1985 at ETH Zurich, Modula-2 introduced revolutionary 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 Influence

Wirth drew inspiration from 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 - Zero-cost abstractions for systems work
4. Simplicity - Small, understandable language
5. System Programming - Replace assembly for OS development

Why Modula-2 Mattered

Despite being 47+ years 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 influenced Java’s interfaces, Go’s packages, and Rust’s modules.

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 1978 when C programs recompiled from scratch constantly.

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 InOut IMPORT WriteString, WriteLn;
(* Only imports specified identifiers *)

IMPORT Terminal;
(* Must use Terminal.Write, Terminal.Read *)

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 ...

Rust’s Modules

1
2
3

mod database {    // Like MODULE Database
    pub fn init() // Like PROCEDURE Init in DEFINITION
}

Ada’s Packages

Ada refined Modula-2’s modules into packages with specifications (.ads) and bodies (.adb).

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 still updated
• FreeBSD - Some utilities still written in Modula-2

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 - Zero-cost abstractions
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 (1978)
• Lilith OS - Complete operating system in Modula-2
• Compiler - Self-hosting Modula-2 compiler
• Applications - Text editor, debugger, all in Modula-2

This proved Modula-2 could replace C for 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.