A compact overview of the Oberon family of languages and how their ideas lead to Go. The lineage runs from Pascal and Modula-2 through Oberon and its variants to Go, with shared emphasis on simplicity, strong typing, and clear semantics.

Oberon (1986) — Niklaus Wirth & Jurg Gutknecht

Evolved from Pascal and Modula-2; designed for simplicity and efficiency.
Strong typing, modular programming, integrated development environment.
Used in software and hardware (e.g. Ceres workstation); part of Project Oberon at ETH Zurich.

Oberon-2 (1991) — Hanspeter Mössenböck

Extension of Oberon with object-oriented features.
Type-bound procedures, read-only export of variables and methods.
Improved type safety and reusability.

Modula-3 (1988) — Luca Cardelli, James Donahue, Greg Nelson, Paul Rovner, Andrew Birrell

Evolution of Modula-2: simplicity, safety, systems programming.
Garbage collection, exception handling, strong type system with modules.
Concurrency and generic programming.

Active Oberon (1997) — Jurg Gutknecht

Extends Oberon with active objects and concurrency.
Combines object-oriented and system-programming features.
Runtime and language support for concurrent processes.

Zonnon (2005) — Jurg Gutknecht

Draws on Oberon, Active Oberon, and Modula-2.
Component-oriented programming, concurrency and parallelism.
Refined syntax and semantics.

Oberon-07 (2007) — Niklaus Wirth

Simplified, modernized Oberon.
Removed deprecated features; clearer syntax and safer semantics.
Streamlined compiler and language report.

Component Pascal (1997)

Clemens Szyperski: Component Pascal at Oberon Microsystems (1991–1997); component-based software; author of Component Software: Beyond Object-Oriented Programming.
K. John Gough: Co-developed Gardens Point Component Pascal for .NET.

Derived from Oberon-2 with stronger object-oriented and component-oriented features; designed for component-based software engineering and .NET integration (Gardens Point).

Feb 2, 2025 2 min read

From Oberon to Go in Faces

Short portraits of people in the Oberon and Modula lineage—language designers, compiler writers, and researchers—whose work leads, in spirit or in person, toward Go.

Niklaus Wirth
Inventor of Pascal (1970), Modula-2 (1978), and Oberon (1986). He also designed Oberon-07 (2007). His work stressed simplicity and efficiency and influenced many modern languages.

Hanspeter Mössenböck
Developed Oberon-2 (1991) and the compiler generator Coco/R. His work on compiler construction and development tools has had a lasting impact.

Feb 1, 2025 2 min read

Solving a Three-Variable Recursion via Generating Functions

This post extends the generating-function technique from the two-variable recursion to a three-variable case. I originally wrote this as an answer to a Math Stack Exchange question; here it is adapted for the blog with clearer exposition and code.

The Problem

We want to solve the recurrence

$a_{n,m,k} = 2a_{n-1,m-1,k-1} + a_{n-1,m-1,k}$ $ + a_{n,m-1,k-1} + a_{n-1,m,k-1}$

where $m$, $n$, $k$ are nonnegative integers, with boundary conditions:

$a_{0,0,0} = a_{0,1,0} = a_{1,0,0} = a_{0,0,1} = 1$
$a_{n,0,0} = a_{0,n,0} = a_{0,0,n} = 0$ for any $n > 1$
$a_{n,m,k}$ is symmetric in $n$, $m$, $k$

A subtlety: $a_{1,0,1}$ is not defined by the recurrence alone, since it would require values like $a_{0,-1,0}$. We take $a_{n,m,k} = 0$ whenever any subscript is negative.

Apr 10, 2018 5 min read

Multiplicative Hashing Functions -- Notes on Primes, Golden Ratio, and Evil

Introduction

Mapping partitions (or keys) to slices (or buckets) in a distributed or sharded system has a large impact on performance. Different hash-based solutions for this problem exist; each has drawbacks. The goal is to choose a hash function that is simple to implement and gives acceptable performance with as few collisions as possible.

The problem is defined as follows. Given a logical partition number $P$, compute the corresponding slice number $S = s(P)$. Where $0 ≤ P < 2^{32}$, $0 ≤ S < M$, and $M$ denotes the table size (e.g. $M = 2^{14}$). In our “binary” world, assumptions that input data (partition numbers) have uniform distribution are not always correct. Therefore, the hash function $s: P \to S$ must be designed very carefully. In addition to providing uniform distribution of hash values (slice numbers), it has to add some randomness. Luckily, this field is well studied: well-known textbooks of Corman’s and Knuth’s have a good introduction to this field. The last one has more detail explanation; therefore, without hesitation, we make use of Knuth’s book (Section 6.4.): usually explaining in two paragraphs what the book is saying just in one sentence.

Aug 2, 2017 12 min read

Perfect Distribution: GCD in Disguise

We discuss an algorithm that distributes $a$ ones among $n$ positions so that the gaps between consecutive ones differ by at most one—a perfect distribution. I developed it while working on profiling, stress, and negative testing of a system that needed exactly this kind of uniform spread. I am not aware of prior art; if you know of related work, I would be interested to hear.

Aug 1, 2017 7 min read

Slava Chernoy

Software Engineer

About

Recent Posts