Oberon (programming language)

General-purpose programming language

This article's use of external links may not follow Wikipedia's policies or guidelines. Please improve this article by removing excessive or inappropriate external links, and converting useful links where appropriate into footnote references. (November 2024) (Learn how and when to remove this message)

|

For other uses, see Oberon (disambiguation).

Oberon

Paradigms| Imperative, structured, modular, object-oriented
Family| Wirth Oberon
Designed by| Niklaus Wirth
Developer| Niklaus Wirth
First appeared| 1987; 38 years ago (1987)
Stable release|

Oberon-07 / 6 March 2020; 5 years ago (2020-03-06)

Typing discipline| Strong, hybrid (static and dynamic)
Scope| Lexical
Platform| ARM, StrongARM; IA-32, x86-64; SPARC, Ceres (NS32032)
OS| Windows, Linux, Solaris, classic Mac OS, Atari TOS, AmigaOS
Website| projectoberon.net
Influenced by
Modula-2
Influenced
Oberon-2, Oberon-07, Active Oberon, Component Pascal, Zonnon, Go, V (Vlang), Nim

Oberon is a general-purpose programming language first published in 1987 by Niklaus Wirth and the latest member of the Wirthian family of ALGOL-like languages (Euler, ALGOL W, Pascal, Modula, and Modula-2).[1][2][3][4] Oberon was the result of a concentrated effort to increase the power of Modula-2, the direct successor of Pascal, and simultaneously to reduce its complexity. Its principal new feature is the concept of data type extension of record types.[5] It permits constructing new data types on the basis of existing ones and to relate them, deviating from the dogma of strict static typing of data. Type extension is Wirth's way of inheritance reflecting the viewpoint of the parent site. Oberon was developed as part of the implementation of an operating system, also named Oberon at ETH Zurich in Switzerland. The name was inspired both by the Voyager space probe's pictures of the moon of the planet Uranus, named Oberon, and because Oberon is famous as the king of the elves.[6]

Oberon was maintained by Wirth and the latest Project Oberon compiler update is dated 6 March 2020.[7]

## Design

[edit]

Oberon is designed with a motto attributed to Albert Einstein in mind: "Make things as simple as possible, but not simpler." The principal guideline was to concentrate on features that are basic and essential and to omit ephemeral issues. Another factor was recognition of the growth of complexity in languages such as C++ and Ada. In contrast to these, Oberon emphasizes the use of the library concept to extend the language. Enumeration and subrange types, which were present in Modula-2, were omitted, and set types are limited to sets of integers. All imported items must be qualified by the name of the module where they are declared. Low-level facilities are highlighted by only allowing them to be used in a module which includes the identifier `SYSTEM` in its import list. Strict type checking, even across modules, and index checking at runtime, null pointer checking, and the safe type extension concept largely allow programming to rely on the language rules alone.

The intent of this strategy was to produce a language that is easier to learn, simpler to implement, and very efficient. Oberon compilers have been viewed as compact and fast, while providing code quality comparable to commercial compilers.[8]

## Characteristics

[edit]

Features characterizing the Oberon language include:[9]

* Case sensitive syntax with uppercase keywords
* Type-extension with type test
* Modules and separate compiling
* String operations
* Isolating unsafe code
* Support for system programming

## Object orientation

[edit]

Oberon supports extension of record types for the construction of abstractions and heterogeneous structures. In contrast to the later dialects, Oberon-2 and Active Oberon, the original Oberon lacks a dispatch mechanism as a language feature but has it as a programming technique or design pattern. This gives great flexibility in OOP. In the Oberon operating system, two programming techniques are used together for the dispatch call: Method suite and Message handler.

### Method suite

[edit]

In this technique, a table of procedure variables is defined and a global variable of this type is declared in the extended module and assigned back in the generic module:

MODULE Figures; (* Abstract module *)

TYPE
Figure*    = POINTER TO FigureDesc;
Interface* = POINTER TO InterfaceDesc;

InterfaceDesc* = RECORD
draw*  : PROCEDURE (f : Figure);
clear* : PROCEDURE (f : Figure);
mark*  : PROCEDURE (f : Figure);
move*  : PROCEDURE (f : Figure; dx, dy : INTEGER);
END;

FigureDesc* = RECORD
if : Interface;
END;

PROCEDURE Init* (f : Figure; if : Interface);
BEGIN
f.if := if
END Init;

PROCEDURE Draw* (f : Figure);
BEGIN
f.if.draw(f)
END Draw;

(* Other procedures here *)

END Figures.

We extend the generic type Figure to a specific shape:

MODULE Rectangles;

IMPORT Figures;

TYPE
Rectangle* = POINTER TO RectangleDesc;

RectangleDesc* = RECORD
(Figures.FigureDesc)
x, y, w, h : INTEGER;
END;

VAR
if : Figures.Interface;

PROCEDURE New* (VAR r : Rectangle);
BEGIN
NEW(r);
Figures.Init(r, if)
END New;

PROCEDURE Draw* (f : Figure);
VAR
r : Rectangle;
BEGIN
r := f(Rectangle); (* f AS Rectangle *)
(* ... *)
END Draw;

(* Other procedures here *)

BEGIN (* Module initialisation *)
NEW(if);
if.draw  := Draw;
if.clear := Clear;
if.mark  := Mark;
if.move  := Move
END Rectangles.

Dynamic dispatch is only done via procedures in Figures module that is the generic module.

### Message handler

[edit]

This technique consists of replacing the set of methods with a single procedure, which discriminates among the various methods:

MODULE Figures; (* Abstract module *)

TYPE
Figure*    = POINTER TO FigureDesc;

Message*   = RECORD END;
DrawMsg*   = RECORD (Message) END;
ClearMsg*  = RECORD (Message) END;
MarkMsg*   = RECORD (Message) END;
MoveMsg*   = RECORD (Message) dx*, dy* : INTEGER END;

Handler*   = PROCEDURE (f : Figure; VAR msg : Message);

FigureDesc* = RECORD
(* Abstract *)
handle : Handler;
END;

PROCEDURE Handle* (f : Figure; VAR msg : Message);
BEGIN
f.handle(f, msg)
END Handle;

PROCEDURE Init* (f : Figure; handle : Handler);
BEGIN
f.handle := handle
END Init;

END Figures.

We extend the generic type Figure to a specific shape:

MODULE Rectangles;

IMPORT Figures;

TYPE
Rectangle* = POINTER TO RectangleDesc;

RectangleDesc* = RECORD
(Figures.FigureDesc)
x, y, w, h : INTEGER;
END;

PROCEDURE Draw* (r : Rectangle);
BEGIN
(* ... *)
END Draw;

(* Other procedures here *)

PROCEDURE Handle* (f: Figure; VAR msg: Figures.Message);
VAR
r : Rectangle;
BEGIN
r := f(Rectangle);
IF    msg IS Figures.DrawMsg THEN Draw(r)
ELSIF msg IS Figures.MarkMsg THEN Mark(r)
ELSIF msg IS Figures.MoveMsg THEN Move(r, msg(Figures.MoveMsg).dx, msg(Figures.MoveMsg).dy)
ELSE  (* ignore *)
END
END Handle;

PROCEDURE New* (VAR r : Rectangle);
BEGIN
NEW(r);
Figures.Init(r, Handle)
END New;

END Rectangles.

In the Oberon operating system both of these techniques are used for dynamic dispatch. The first one is used for a known set of methods; the second is used for any new methods declared in the extension module. For example, if the extension module Rectangles were to implement a new Rotate() procedure, within the Figures module it could only be called via a message handler.

## Implementations and variants

[edit]

### Oberon

[edit]

No-cost implementations of Oberon (the language) and Oberon (the operating system) can be found on the Internet (several are from ETHZ itself).

### Oberon-2

[edit]

Main article: Oberon-2

A few changes were made to the first released specification. For example, object-oriented programming (OOP) features were added, the `FOR` loop was reinstated. The result was Oberon-2. One release, named Native Oberon which includes an operating system, and can directly boot on IBM PC compatible class hardware. A .NET implementation of Oberon with some added minor .NET-related extensions was also developed at ETHZ. In 1993, an ETHZ university spin-off company brought a dialect of Oberon-2 to the market named Oberon-L. In 1997, it was renamed Component Pascal.

Oberon-2 compilers developed by ETH include versions for Microsoft Windows, Linux, Solaris, and classic Mac OS. Implementations from other sources exist for some other operating systems, including Atari TOS and AmigaOS.

There is an Oberon-2 Lex scanner and Yacc parser by Stephen J Bevan of Manchester University, UK, based on the one in the Mössenböck and Wirth reference. It is at version 1.4.

Other compilers include Oxford Oberon-2,[10] which also understands Oberon-07, and Vishap Oberon.[11] The latter is based on Josef Templ's Oberon to C language source-to-source compiler (transpiler) named Ofront,[12] which in turn is based on the OP2 Compiler developed by Regis Crelier at ETHZ.

### Oberon-07

[edit]

Oberon-07, defined by Niklaus Wirth in 2007 and revised in 2008, 2011, 2013, 2014, 2015, and 2016 is based on the original version of Oberon rather than Oberon-2. The main changes are: explicit numeric conversion functions (e.g., `FLOOR` and `FLT`) must be used; the `WITH`, `LOOP` and `EXIT` statements were omitted; `WHILE` statements were extended; `CASE` statements can be used for type extension tests; `RETURN` statements can only be connected to the end of a function; imported variables and structured value parameters are read-only; and, arrays can be assigned without using `COPY`.[13]

Oberon-07 compilers have been developed for use with many different computer systems. Wirth's compiler targets a reduced instruction set computer (RISC) processor of his own design that was used to implement the 2013 version of the Project Oberon operating system on a Xilinx field-programmable gate array (FPGA) Spartan-3 board. Ports of the RISC processor to FPGA Spartan-6, Spartan-7, Artix-7 and a RISC emulator for Windows (compilable on Linux and macOS, and binaries available for Windows) also exist. OBNC compiles via C and can be used on any Portable Operating System Interface (POSIX) compatible operating system. The commercial Astrobe implementation targets STM ARM Cortex-M0, M3, M4, M7 and Raspberry Pi RP2040 and RP2350 microcontrollers. The Patchouli compiler produces 64-bit Windows binaries. Oberon-07M produces 32-bit Windows binaries and implements revision 2008 of the language. Akron's produces binaries for both Windows and Linux. OberonJS translates Oberon to JavaScript. There is online IDE for Oberon. oberonc is an implementation for the Java virtual machine.

### Active Oberon

[edit]

Active Oberon is yet another variant of Oberon, which adds objects (with object-centered access protection and local activity control), system-guarded assertions, preemptive priority scheduling and a changed syntax for methods (named type-bound procedures in Oberon vocabulary). Objects may be active, which means that they may be threads or processes. Further, Active Oberon has a way to implement operators (including overloading), an advanced syntax for using arrays (see OberonX language extensions Archived 4 March 2016 at the Wayback Machine and Proceedings[14] of the 7th Joint Modular Languages Conference 2006 Oxford, UK), and knows about namespaces.[15] The operating system A2 (formerly Active Object System (AOS),[16] then Bluebottle), especially the kernel, synchronizes and coordinates different active objects.

ETHZ has released Active Oberon which supports active objects, and the operating systems based thereon (Active Object System (AOS), Bluebottle, A2), and environment (JDK, HTTP, FTP, etc.) for the language. As with many prior designs from ETHZ, versions of both are available for download on the Internet. As of 2003, supported central processing units (CPUs) include single and dual core x86, and StrongARM.

### Related languages

[edit]

Development continued on languages in this family. A further extension of Oberon-2 was originally named Oberon/L but later renamed to Component Pascal (CP). CP was developed for Windows and classic Mac OS by Oberon microsystems, a commercial spin-off company from ETHZ, and for .NET by Queensland University of Technology. Further, the languages Lagoona[17][18][19] and Obliq carry Oberon methods into specialized areas.

Later .NET development efforts at ETHZ focused on a new language named Zonnon. This includes the features of Oberon and restores some from Pascal (enumerated types, built-in IO) but has some syntactic differences. Other features include support for active objects, operator overloading, and exception handling.

Oberon-V (originally named Seneca, after Seneca the Younger) is a descendant of Oberon designed for numerical applications on supercomputers, especially vector or pipelined architectures. It includes array constructors and an `ALL` statement.[20]

## See also

[edit]

* Oberon (operating system)
* A2 (operating system)
* Oberon on Wikibooks

## Resources

[edit]

### General

[edit]

* Official website (latest available copy at archive org) at ETH-Zürich
* Niklaus Wirth's Oberon Page at ETH-Zürich
* Oberon Page at SSW, Linz
* Oberon: The Programming Language at Ulm
* Project Oberon, The Design of an Operating System and a Compiler, book in PDF by Niklaus Wirth and Jürg Gutknecht, 2005 Edition
* Oberon Language Genealogy
* Astrobe ARM Oberon-07 Development System
* Oberon System V4 for HP OpenVMS Alpha with source code upward-compatible 64 bit addressing
* 64 bit Oberon-2 compiler for OpenVMS Alpha
* Oxford Oberon-2 Compiler and its User Manual[permanent dead link]
* Free Oberon-07 IDE Free Oberon-07 IDE for Windows, Macintosh, and Linux with syntax colouring, semantic navigation and source code debugger
* Oberon article by Joseph Templ in the January 1994 issue of Dr.Dobbs

### Evolution of Oberon

[edit]

* Modula-2 and Oberon Wirth (2005)
* The Programming Language Oberon Wirth, (1988/90)
* The Programming Language Oberon (Oberon-7, Revised Oberon) Wirth, (2016, most current language report)
* Differences between Oberon-07 and Oberon Wirth (2011)
* The Programming Language Oberon-2 H. Mössenböck, N. Wirth, Institut für Computersysteme, ETH Zürich, January 1992
* Differences between Oberon and Oberon-2 Mössenböck and Wirth (1991)
* What's New in Component Pascal (Changes from Oberon-2 to CP), Pfister (2001)

## References

[edit]

1. ^ Wirth, Niklaus (1987). From Modula to Oberon and the programming language Oberon (Report). ETH Technical Reports D-INFK. Vol. Band 82. Wiley. doi:10.3929/ethz-a-005363226.
2. ^ Wirth, Niklaus (July 1988). "The Programming Language Oberon". Software: Practice and Experience. 18 (7): 661–670\. doi:10.1002/spe.4380180707.
3. ^ Wirth, Niklaus (July 1988). "From Modula to Oberon". Software: Practice and Experience. 18 (7): 671–690\. doi:10.1002/spe.4380180706. S2CID 13092279.
4. ^ Wirth, Niklaus (April 1988). "Type Extensions". ACM Transactions on Programming Languages and Systems. 10 (2): 204–214\. doi:10.1145/42190.46167. S2CID 15829497.
5. ^ Pountain, D. March 1991. "Modula's Children, Part II: Oberon". Byte. Vol. 16, no. 3\. pp. 135–142.`{{cite magazine}}`: CS1 maint: numeric names: authors list (link)
6. ^ Wirth, Niklaus; Gutknecht, Jürg (1987–2021). "Project Oberon" (PDF).
7. ^ Wirth, Niklaus. "Oberon Change Log". ETH Zurich. Retrieved 16 January 2021.
8. ^ Mössenböck, Hanspeter. "Compiler Construction: The Art of Niklaus Wirth" (PDF). Retrieved 28 May 2025.
9. ^ Wirth, Niklaus; Gutknecht, Jürg (1987–2021). "Project Oberon".
10. ^ Spivey (8 April 2019). "Oxford Oberon-2 compiler". Retrieved 17 January 2021.
11. ^ dcwbrown (16 June 2020). "Vishap Oberon Compiler". GitHub. Retrieved 17 January 2021.
12. ^ jtempl (2 January 2020). "Ofront". GitHub. Retrieved 17 January 2021.
13. ^ Wirth, Niklaus (3 May 2016). The Programming Language Oberon-07 (PDF). ETH Zurich, Department of Computer Science (Report). Retrieved 17 January 2021.
14. ^ Friedrich, Felix; Gutknecht, Jürg (2006). "Array-Structured Object Types for Mathematical Programming". In Lightfoot, David E.; Szyperski, Clemens (eds.). Modular Programming Languages. Lecture Notes in Computer Science. Vol. 4228\. Springer, Berlin Heidelberg. pp. 195–210\. doi:10.1007/11860990_13. ISBN 978-3-540-40927-4. S2CID 34210781.
15. ^ "Proposal for Module Contexts" (PDF). Archived from the original (PDF) on 22 December 2015. Retrieved 21 December 2015.
16. ^ Muller, Pieter Johannes (2002). The active object system design and multiprocessor implementation (PDF) (PhD). Swiss Federal Institute of Technology, Zürich (ETH Zurich).
17. ^ Fröhlich, Peter H.; Franz, Michael. On Certain Basic Properties of Component-Oriented Programming Languages (PDF) (Report). University of California, Irvine. Retrieved 18 January 2021.
18. ^ Fröhlich, Peter H.; Gal, Andreas; Franz, Michael (April 2005). "Supporting software composition at the programming language level". Science of Computer Programming. 56 (1–2). Elsevier B.V.: 41–57\. doi:10.1016/j.scico.2004.11.004.1–2&rft.pages=41-57&rft.date=2005-04&rft_id=info:doi/10.1016/j.scico.2004.11.004&rft.aulast=Fröhlich&rft.aufirst=Peter+H.&rft.au=Gal,+Andreas&rft.au=Franz,+Michael&rft_id=https://doi.org/10.1016%2Fj.scico.2004.11.004&rfr_id=info:sid/en.wikipedia.org:Oberon+(programming+language)" class="Z3988"> Retrieved 18 January 2021.
19. ^ Franz, Michael; Fröhlich, Peter H.; Kistler, Thomas (20 November 1999). "Towards language support for component-oriented real-time programming". Proceedings: Fifth International Workshop on Object-Oriented Real-Time Dependable Systems. Institute of Electrical and Electronics Engineers (IEEE). pp. 125–129\. doi:10.1109/WORDSF.1999.842343. ISBN 0-7695-0616-X. S2CID 6891092. Retrieved 21 January 2021.
20. ^ Griesemer, Robert (1993). "A Language for Numerical Applications on Vector Computers". Proceedings CONPAR 90: VAPP IV Conference, Diss Nr. 10277. ETH Zurich.

* v
* t
* e

Modula, Oberon

Modula|

| By Wirth|

Modula (1975) → Modula-2 (1978)

|

By others|

* Modula-2+ (1984)
* Modula-3 (1988)
* Baby Modula-3 (1993)
* Obliq (1993)
* Alma-0 (1997)

Operating systems|

* Medos-2 (1983, Knudsen)
* Excelsior (1988, Soviet)

Workstations|

* Lilith (1980, Wirth)
* Kronos (1988, Soviet)

Developers|

| Organizations|

* ETH Zurich
* Modula Computer Systems
* Centrum Wiskunde & Informatica
* Digital Equipment Corporation (DEC) Systems Research Center (SRC)
* Acorn Research Center
* Olivetti Research Center (ORC)
* elego Software Solutions GmbH
* Academy of Sciences of the Soviet Union, Novosibirsk

|

People|

* Niklaus Wirth
* Martín Abadi
* Luca Cardelli
* Greg Nelson

Oberon|

| By Wirth|

Oberon (1987) → Oberon-2 (1991) → Lola (1995) → Active Oberon (1998) → Oberon-07 (2007)

Operating systems|

* Oberon System (1987)
* Active Object System (AOS, 2002), Bluebottle (2005), A2 (2008)

Workstation|

Ceres (1985)

By others|

* Object Oberon (1989)
* Oberon/F, BlackBox Component Builder (1993)
* Component Pascal (1997)
* Zonnon (2013)

Developers|

| Organizations|

* ETH Zurich
* Johannes Kepler University Linz
* Oberon microsystems AG

|

People|

* Niklaus Wirth
* Jürg Gutknecht
* Tony Hoare
* de:Hanspeter Mössenböck

* Category: Modula
* Category: Oberon

* v
* t
* e

Niklaus Wirth

Software|

| Programming
languages|

Euler (1965) → PL360 (1966) → ALGOL W (1966) → Pascal (1970) → Modula (1975) → Modula-2 (1978) → Object Pascal (1986) → Oberon (1987) → Oberon-2 (1991) → Lola (1995) → Active Oberon (1998) → Oberon-07 (2007)

|

Operating systems|

Oberon System (1987) → Active Object System (AOS, 2002), Bluebottle (2005), A2 (2008)

Formalisms|

* Wirth's law
* Wirth syntax notation
* Wirth–Weber precedence relationship

Books|

* Algorithms + Data Structures = Programs

Workstations|

Lilith (1977) → Ceres (1985)

Workplaces|

* Stanford University (1963–67)
* University of Zurich (1963–67)
* ETH Zurich (1968–99)
* Xerox PARC (1976–77, 1984–85)

Collaborators|

* Jürg Gutknecht
* Tony Hoare
* de:Hanspeter Mössenböck
* Larry Tesler

Awards|

* Turing Award
* SIGPLAN Programming Languages Achievement Award
* Fellow of the Computer History Museum
* Marcel Benoist Prize

* Category

* v
* t
* e

Programming languages

* Comparison
* Timeline
* History

* Ada
* ALGOL
* Simula
* APL
* Assembly
* BASIC
* Visual Basic
* classic
* .NET
* C
* C++
* C#
* COBOL
* Erlang
* Elixir
* Forth
* Fortran
* Go
* Haskell
* Java
* JavaScript
* Julia
* Kotlin
* Lisp
* Lua
* MATLAB
* ML
* Caml
* OCaml
* Pascal
* Object Pascal
* Perl
* Raku
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* SAS
* SQL
* Scratch
* Shell
* Smalltalk
* Swift
* more...

* Lists: Alphabetical
* Categorical
* Generational
* Non-English-based
* Category

Authority control databases: National |

* Germany

|

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template