Oberon/ETH Oberon/white
This document was originally hosted at the ETHZ. It remains under the ETH license and is in the WayBack archive.
Unknown origin
Keywords: component framework, document-based, dynamic loading, extensibility, graphical user interface, graphical components, interactive composition, MVC, Oberon, object-oriented, operating system, persistent object, programming language.
- The Oberon Project History
- The Oberon Programming Language
- The ETH Oberon System
- Application Packages
- The different ETH Oberon System Implementations
- How to get the ETH Oberon System
- Books on Oberon
- Interesting HTML documents
- Contact address
- Copyright
Oberon is simultaneously the name of a programming language and of a modern operating system. The Oberon project [WG92] was started at the Swiss Federal Institute of Technology in Zürich (ETHZ) in 1985 by Niklaus Wirth and Jürg Gutknecht. It was originally targeted towards in-house built hardware (Ceres workstation, based on the National Semiconductors 32000 processor family). Later, the decision was made to port the system to popular computer hardware, where it would run natively or on top of the operating system of the host. Today, Oberon is available for many computer platforms.
In 1991, Jürg Gutknecht and his group continued the development towards the ETH Oberon System. The goal was to exploit the inherent potential and features of Oberon to a much larger degree, upgrade the system by a concept of composable and persistent objects, complement the textual user interface by a graphical companion and provide support for the ubiquitous network. In 1995, the first official Oberon System 3 release was finished. Since then, the system has been constantly improved and extended. In 1997, the Release 2.2 including a large palette of applications was published together with a comprehensive hypertext-based documentation. In March 2000, a new release was ready and the system was renamed "ETH Oberon System".
The Oberon language is the successor of Modula-2 in the Pascal family [RW92]. From Modula-2, Oberon inherits the following programming in-the-large concepts which are universally recognized as essential, namely:
- abstraction (data structures and data types)
- encapsulation (information hiding)
- modularity (modules with type-checked interfaces and separate compilation)
- strong typing (with support for run-time type test).
New concepts in Oberon include:
- a simple and natural construct called type extension for the specialization of record types
- polymorphism: extended types accepted at run time where ever objects of the corresponding base type are
- fine-grained information hiding for data types
The primary merit of the language Oberon [Wir88] lies in the provision of data type extensibility as a multi-purpose construct. In combination with polymorphism and procedure variables it supports both heterogeneous data structures and object-oriented programming. As a consequence, no radical break with traditional programming technique is necessary even if an OOP style is used.
In comparison with typical terminology, classes correspond to record types, subclasses to extended record types, superclasses to base record types and objects to record instances. In its simplest form, a method corresponds to an installed procedure variable and a message-send to a call of an installed procedure variable. In contrast to class-centeredness of most OOP languages, Oberon uses an instance-centered OOP model.
Some of the characteristics of the compiler are:
- very fast compilation
- can compile directly from edit window
- generates native or portable code, no separate linking necessary
The compiler can generate two types of object files: (a) classical native object files containing target machine code or (b) slim binaries. Slim binaries are a new form of object files that contain no object code at all, but a portable description of a module's content that makes these files completely independent of the eventual target machine (platform independence). Object code generation is carried out on-the-fly by the module loader (depending on the underlying hardware) and is as efficient as loading traditional object files.
The original Oberon system is a single-threaded, single-user, co-operative multi-tasking operating system [Wir88, WG92] that runs on bare hardware or on top of a hosted operating system as a single-window application. The ETH Oberon System is an extended version that has intrinsic support for persistent objects and for building graphical user interfaces. It presents itself as a hierarchy of modules, many of which export one or several powerful abstract data types. Application modules simply reuse these data types and do not have to care about their implementation at all.
Core components:
- Kernel with integrated garbage collector
- Dynamic module loader
- Tiling-viewer display manager
- Extensive built-in support for texts and fonts (Text is an abstract data type)
- Lean and efficient file system
- Integrated support for persistent objects and object libraries
- Drivers for disk, diskette, mouse, keyboard, asynchronous communication, printer and a bit-mapped display
- Local area network services
- Superfast Oberon compiler
Some of the implementations use the facilities of the underlying operating system, via API.
System characteristics:
- Single-process multitasking
- Automatic garbage collection
- Built-in non-modal text editor
- Commands: A distinguishing feature of Oberon is the unification of text input and command input. Anywhere editable text is accepted, a valid command name M.P may be entered and executed (or activated). A command is the code unit which can be executed from the user interface. It is a parameterless procedure P exported by a module M written in Oberon.
- Separate compilation with complete cross-module consistency checks. A smart module loader and fine-grained finger printing of module interfaces enables interface extensions to be made without invalidating clients.
- Dynamic loading. Allows modules to be loaded on demand at run time
- Advanced tools for text and graphics editing, and for program development
- Component framework
- GUI developer kit called Gadgets
ETH Oberon System highlights:
- Advanced Textual User Interface. The basic ETH Oberon System layer comes with a highly powerful textual user interface (texts with embedded Oberon commands). It is as lean and compact as the original system. For the native version the basic system is only 210 KB when loaded.
- Integrated object support in the kernel. The ETH Oberon System kernel is an upgrade of the original Oberon kernel by a unifying object machinery that
- integrates and generalizes existing concepts. In particular, all substantial ingredients of the original Oberon system like character, font, text, display frame and viewer can be expressed uniformly in terms of two newly introduced concepts object and object library (an indexed collection of objects). The entire object machinery is represented by a single module Objects of very modest size.
- defines a generic message protocol ("software bus") for composite objects and thus provides a universal and extensible platform for future object types.
- Object Autonomy and Persistence. All ETH Oberon System objects are autonomous and persistent by nature, i.e. they are viable in any environment and are portable to any other store or machine together with their current state. The ETH Oberon System supports persistence by a binding mechanism that allows objects to be bound to an object library.
- Extensibility by Software Bus Technology. The ETH Oberon System objects are consistently equipped with generic message interfaces. Based on this genericity, the ETH Oberon System defines a common message protocol that can be regarded as a kind of software bus in the sense that objects implementing this protocol can participate and cooperate in system data structures. The protocol is defined by a set of basic message types and rules that can be extended individually for specific classes or groups of objects. It follows the principle of parental control in composite objects.
- Fully Hierarchical Composability. The ETH Oberon System objects are components by nature, i.e. they can be freely embedded in any other container object or text. Object composition can be nested up to any arbitrary level.
- Generalized MVC Scheme. The ETH Oberon System display space is a heterogeneous hierarchy of composite and elementary visual objects and it supports arbitrary partial and total overlapping. The hierarchy is based on a generalized Model-View-Controller scheme that allows different camera views of one and the same object (visual or not).
- Powerful GUI Framework Gadgets. The Gadgets package provides a very powerful framework for object composition. It includes a rich library of predefined visual objects and model (or abstract) objects, called "gadgets", and some effective tools for their interactive and descriptive composition and inspection.
Gadgets object types cover a large spectrum. Most of them are of a visual nature and are seen on the display, that is, they are part of the display space. Examples are text gadgets, viewers, menu bars, buttons, sliders, panels etc. In contrast to visual gadgets, non-visual gadgets operate behind the scenes and are able to manipulate and store information. They are acting as models in the MVC scheme.
The Gadgets framework allows the run-time construction of graphical user interfaces (GUI) from gadgets as building blocks. Each dialog element, or gadget, can be embedded in any UI (textual or graphic) or application. All gadgets can be integrated and reused in any other ETH Oberon System environment. Gadgets can float in a text, they can be embedded in a panel, in a graphic diagram etc. Container gadgets manage other gadgets as their "children". The principal containers are panel gadgets (two-dimensional edit surfaces) and text gadgets (complete text editors with support for embedding), although more refined containers are available.
Two different methods for object construction and composition are available: interactive and descriptive. The interactive method makes use of the built-in editing support of ETH Oberon System objects. Visual objects are modified and used interactively wherever they are located. ETH Oberon users create new UIs or modify existing ones in a typical drag-and-drop fashion. In effect, UI construction is reduced to pure document editing. In addition, two supporting tools are available: The Gadgets tool offers a rich and extensible arsenal of predefined components and some layouting functionality. The Columbus inspector allows gadgets to be inspected together with their attributes and links.
The descriptive method relies on a formal language and a corresponding interpreter. The description language LayLa is of a LISP-like functional style. - Self-Contained Documents. A concept of generic and self-contained documents is part of the Gadgets framework. Such documents are named and can be included in other container objects or texts by reference. Also, they are able to migrate and, optionally, they can be authenticated.
- Extensibility on Different Levels
Openness and extensibility were key goals of project Oberon from the beginning. With ETH Oberon System we can distinguish extensibility on three different levels:- The lowest level corresponds to the simplest case. It comprises the creation of composite objects, i.e. of user interfaces and documents from existing components. This level is accessible to programmers as well as to end-users. It merely requires some familiarity with (depending on the desired method) either the interactive composition tools and the inspector or the description language. Independant of the construction method, components can be acquired alternatively from:
- generators for elementary objects (by cloning)
- generators for container objects (by cloning)
- prefabricated object libraries (by cloning or via reference)
- The next level is programmed use of existing gadgets and GUIs, in particular for adding "glue logic" to components and for input and output. This level is supported by a rich procedural interface and in particular by the modules Attributes, Links and GadgetsIn, GadgetsOut. No object-oriented programming is needed on this level.
- The third level involves developing new components. Here, one should distinguish between two kinds of components: elementary gadgets that do not contain any further gadgets and container gadgets that are able to manage other gadgets. In this context, "developing" means extending the type and message handler code of an existing gadget or defining a new type and programming a new message handler. To support this activity, the ETH Oberon System release provides code skeletons, in other words templates that can easily be modified and tailored to individual needs. It should be mentioned that object-oriented programming is essential in this case. In particular, the full basic message protocol must be implemented to allow the new object (type) to plug into the "software bus".
- The lowest level corresponds to the simplest case. It comprises the creation of composite objects, i.e. of user interfaces and documents from existing components. This level is accessible to programmers as well as to end-users. It merely requires some familiarity with (depending on the desired method) either the interactive composition tools and the inspector or the description language. Independant of the construction method, components can be acquired alternatively from:
The ETH Oberon System package includes several interesting tools and applications. Many of them were developed as productivity tools by ETH assistants and students. Some of the applications ready for use are:
- A symbol file browser, a source code profiler, an analyzer of Oberon source code, a hex editor, and a smart browser called Watson for exploring module documentation in the form of hypertexts.
- A tool to compress and encrypt source modules for further distribution, and a tool to attach code to documents so that they become transportable.
- A tool to backup files on MS-DOS diskettes, a tool to prepare files for mailing, an archiver to compress multiple files into a single archive, an interface to the underlying operating system clipboard, and a tool to manipulate the color palette.
- Several tools and sample programs related to the Gadgets GUI, including the Gadgets component tool for the interactive creation and a tool for the management of public libraries of reusable components.
- A powerful graphics editor called Leonardo
- A picture editor called Rembrandt, with associated image manipulation tools.
- A network software package. Internet connection is possible both via Ethernet link, SLIP or PPP dial-in. A set of tools is available that support e-mail, Web browsing, FTP, Gopher, News and Telnet. Most of these tools are presented to the user in Gadgets GUI form. They conform with a unified and universal document model. In particular, they allow to open any remote document, including any html document, as if it were local. Mail and News support the transport of Gadgets components.
- Several electronic tutorials with embedded code examples about all aspects of the system, an Oberon language reference, a programmer's guide, and a large collection of sample programs.
Users may opt to install their selection of applications chosen from a rich palette of application packages supplied with the system:
- ASCIITab - ASCII table gadget
- Backdrops - Textured wallpaper generator
- Calc - Simple calculator
- Coco - Scanner and parser generator
- CUSeeMe - CUSeeMe video receiver
- Diff - Text difference tool
- Dim3 - 3D-engine
- EditKeys - Keyboard macro utility for TextGadgets
- Find - String searcher
- FontEditor - Oberon raster font editor
- Games - A collection of games: Asteroids, Freecell, MineSweeper, Scramble, Sokoban, Solitaire, Spider, Tetris
- Hex - Binary file editor
- Histogram - Histogram gadget
- HPCalc - RPN calculator
- HTML - Simple text to HTML converter
- LayLa - Layout language
- LayoutPanels - LayoutPanels with formatting constraints
- LPRPrinter - Remote (LPR) printer utility
- Magnifier - Pixel magnifier
- PictConverters - Picture format converters
- RX - Regular expression searcher
- Sort - Line-based sorter
- Sound - Sound and CD tool (Soundblaster)
- TextPopups - Popup menu for TextDocs
- V24Terminal - Simple V24 terminal
- WTS - V4 text to ETH Oberon System text converter
The ETH Oberon system can be installed on various platforms, either on top of the operating system (Windows, Linux for Intel-based PC or for PPC, MacOS for Macintosh) of the host machine or, in the case of Intel-based PC, Transmeta platform and DEC Shark NCs, as a native operating system, known as Native Oberon. The platform-specific hardware and software requirements together with installation instructions are described in readme files. Details on how to obtain the latest update for a specific platform are given in the next section.
PC Native Oberon on Intel-based PCs is absolutely self-contained and makes no use of any alien software layer or Bios. In a way, PC Native Oberon is to the PC what the original Oberon [WG92] was to the Ceres. For example, it uses the same flat file directory structure found in the original Oberon system. In contrast, the other implementations adopt the directory structure of their host system and the concept of a name path.
The system, together with its source code (under a general license agreement), is available for free as freeware. The newest release of the ETH Oberon System can be obtained at any time via anonymous file transfer from the ETH:
- ftp://ftp.ethoberon.ethz.ch/ETHOberon/
The subdirectory names for the different implementations are:
- Native for Intel-based PC
- Win95NT for Windows 95, Windows NT and Windows 2000 (supports long file names)
- Win3x for Windows 3.1, WfWG 3.11, Windows 95 and Windows NT
- Unix for Linux on Intel-based PC
- Macintosh for MacOS on PowerMac and 68K-based Apple Macintosh
The Macintosh port [along with Native and a Windows port] can also be obtained from the University of California in Irvine (UCI):
- ftp://ftp.ics.uci.edu/pub/oberon/System3/Macintosh
- [Wir88] - Niklaus Wirth
The Programming Language Oberon
Springer - Software - Practice and Experience, 19(9), 1988.
The original Oberon language report.
- [Rei91] - Martin Reiser
The Oberon System - User Guide and Programmer's Manual
Addison-Wesley, 1991 - ISBN 0-201-54422-9
This is the complete guide and reference to the original Oberon System. Featuring a user guide, a description of the module library and a programming guide, this book also contains a wealth of practical real-world examples and illustrations.
- [RW92] - Martin Reiser and Niklaus Wirth
Programming in Oberon - Steps beyond Pascal and Modula
Addison-Wesley, 1992 - ISBN 0-201-56543-9
The book is a self-contained reference providing detailed documentation of the language - the original Oberon report by Niklaus Wirth is included as an appendix. Researchers, lecturers, students and programmers will be fascinated by the complete and well-organized definition of what Oberon is and how it should be used.
- [RW92d] - Martin Reiser und Niklaus Wirth
Programmieren in Oberon - Das neue Pascal
Addison-Wesley, 1992 - ISBN 3-89319-657-2
[RW92] translated into German by Josef Templ.
- [WG92] - Niklaus Wirth and Jürg Gutknecht
Project Oberon - The Design of an Operating System and Compiler
Addison-Wesley, 1992 - ISBN 0-201-54428-8
The first-hand account of the design, development and implementation of the original Oberon System. The main design principle behind this project - that few core features are necessary to produce a sophisticated computer system - is amply illustrated as the story evolves into an account of the design and development of an integrated text and graphics system, an assembler, a compiler, programming tools, a file and print server and an electronic mail server.
- [Mös93] - Hanspeter Mössenböck
Object-Oriented Programming in Oberon-2
Springer Verlag, 1993 - ISBN 3-540-60062-0
Principles and applications of object-oriented programming with examples in Oberon-2.
- [Mös93d] - Hanspeter Mössenböck
Objektorientierte Programmierung in Oberon-2
Springer Verlag, 1993 - ISBN 3-540-55690-7
[Mös93] translated into German.
- [ML97] - J.R. Mühlbacher, B. Leisch, B. Kirk, U. Kreuzeder
Oberon-2 - Programming with Windows
Springer Verlag, 1997 - ISBN 3-540-62522-4
- [Nik97] - Eric Nikitin
Into the Realm of Oberon: An introduction to Programming and
the Oberon-2 Programming Language
Springer Verlag, 1997 - ISBN 0-387-98279-5
- [FM97] - André Fischer and Hannes Marais
The Oberon Companion: A Guide to Using and Programming Oberon System 3
vdf Verlag der Fachhochschulen, 1997 - ISBN 3-7281-2493-1
A CD-ROM is included.
A comprehensive list of technical papers issued by the ETH as well as a list other papers having Oberon as subject is found in: www.ethoberon.ethz.ch/books.html [dead link].
More information on current developments is available using an Internet browser. The following list of HTML documents addresses is not exhaustive. Refer also to the bibliography.
- www.ethoberon.ethz.ch - The Oberon home page at the ETHZ
- https://github.com/berkus/Juice - Juice technology for distributing executable content across the WWW
- www.math.tau.ac.il/~laden/
[dead link] - The Oberon information collected by Guy Laden
- http://archiv.ub.uni-heidelberg.de/volltextserver/21411/1/report.18.pdf - Project Voyager at the Uni Heidelberg
Swiss Federal Institute of Technology
The ETH Oberon System Developer Team
Institute for Computer Systems
ETH Zentrum
CH-8092 Zürich
Switzerland
Phone +41 1 632 7311, Fax +41 1 632 1307
E-mail (discussion list): oberon at lists.inf.ethz.ch
ETH Oberon homepage: http://www.ethoberon.ethz.ch
Bluebottle homepage: http://bluebottle.ethz.ch
ETH Oberon System is a copyright of the Team of the Institute of Computer Systems of the ETH Zürich.
The Oberon system is available free of charge and no registration is required for downloading the material. The source code is available under the following license agreement. Each source code module refers to the license terms at the beginning.
13 Mar 2000 - Copyright © 2002 ETH Zürich. All rights reserved.
E-Mail: oberon at lists.inf.ethz.ch