Oberon (operating system)

Last updated

Oberon
OberonScreen.PNG
Tiled window arrangement of Oberon
Developer Niklaus Wirth
Jürg Gutknecht
Written in Oberon
OS familyOberon
Working stateCurrent
Source model Open source
Initial release1987;37 years ago (1987) [1]
Available in English
Platforms Ceres (NS32032), IA-32, Xilinx Spartan, and many others
Kernel type Object-oriented
Default
user interface 		Text-based user interface
License BSD-style [2]
Preceded by Medos-2
Official website www.projectoberon.net

The Oberon System [3] is a modular, single-user, single-process, multitasking operating system written in the programming language Oberon. [4] It was originally developed in the late 1980s at ETH Zurich. The Oberon System has an unconventional visual text user interface (TUI) instead of a conventional command-line interface (CLI) or graphical user interface (GUI). This TUI was very innovative in its time and influenced the design of the Acme text editor for the Plan 9 from Bell Labs operating system.

Contents

The system also evolved into the multi-process, symmetric multiprocessing (SMP) capable A2 (formerly Active Object System (AOS), [5] then Bluebottle), with a zooming user interface (ZUI).

History

The Oberon operating system was originally developed as part of the NS32032-based Ceres workstation project. It was written almost entirely (and in the 2013 version entirely is valid) in the Oberon programming language. [6] The basic system was designed and implemented by Niklaus Wirth and Jürg Gutknecht and its design and implementation is fully documented in their book "Project Oberon". [7] The user Interface and programmers reference is found in Martin Reiser's book "The Oberon System". [8] The Oberon System was later extended and ported to other hardware platforms [9] [10] [11] [12] [13] by a team at ETH Zurich and there was recognition in popular magazines. [14] [15] [16] [17] [18] [19] Wirth and Gutknecht (although being active computer science professors) refer to themselves as 'part-time programmers' in the book Project Oberon. [7] In late 2013, a few months before his 80th birthday, Wirth published a second edition of Project Oberon. [20] It details implementing the Oberon System using a reduced instruction set computer (RISC) CPU of his own design realized on a Xilinx field-programmable gate array (FPGA) board. It was presented at the symposium [21] organized for his 80th birthday at ETH Zurich. In the meantime, several emulators for this version were implemented. [22] [23] [24] [25] [26]

According to Josef Templ, a former member of the developer group at Swiss Federal Institute of Technology in Zurich and later member of the Institut für Systemsoftware of Johannes Kepler University Linz, where one forked version (V4) was maintained, the genealogy of the different versions of the Oberon System is this:

YearNameRemark
1985Start of Oberon project
1987V1Internal use at ETHZ; [3] [27] simple text editing facilities only
1991V2Extensible text model and a special editor named Write [28] supporting these extensions
1991System 3 Kernel extensions supporting persistent objects and object-libraries supporting object embedding and object linking; Gadgets, Script (text editor), Illustrate (graphics editor) [15]
1992Publication of Oberon Trilogy: "Project Oberon", [7] "The Oberon System", [8] and "Programming in Oberon" [6]
1992V4Functions of Write integrated into standard text editor
Rel. 1.4Desktops
1993Rel. 1.5Generic document model
1994V4 Hanspeter Mössenböck appointed at JKU (Linz), V4 development moves there
1995Rel. 2.0Document space extended to the whole internet; improved bitmap editor: Rembrandt; online tutorials
2000ETH-OberonSystem-3 renamed ETH-Oberon
2002AOSActive Object System, [5] also Active Oberon System, later renamed Bluebottle, then A2
2013PO 2013 - V5Re-implementation of the original Oberon System in FPGA

User interface

Oberon has a text user interface (TUI), which is very different from a terminal user interface. It combines the point and click convenience of a graphical user interface (GUI) with the linguistic strength of a command-line interface (CLI) and is closely tied to the naming conventions of the Oberon language. Text appearing almost anywhere on a screen can be edited and used as command input. Commands are activated by a middle-mouse click [29] on a text fragment of the form Module.Command (optionally followed by parameters, which are terminated by ~). A command is defined by any procedure which is exported and has an empty argument list. Parameters to the command must be defined before executing the middle click, and must be explicitly scanned and retrieved by the procedure. No checks or questions occur during command execution. This is sometimes called a non-modal user interface (UI). Nothing like a command prompt is needed.

Although very different from a command line, the TUI is very efficient and powerful. [30] A steep ascent in the early learning curve makes it a bit difficult at first. No questions are asked: this is a deliberate design decision, which needs getting used to. Most editors ask the user when closing a modified text: this is not the case in the Oberon System. The use of the TUI and programming interface is fully documented in Martin Reiser's book "The Oberon System". [8] A short introduction to the user interface can be found on Niklaus Wirth's home page. [31] The later Versions of System Oberon, Oberon V4 (V4, sometimes also named Linz-Oberon) and Oberon System 3 (or S3, sometimes also named ETH-Oberon or Spirit of Oberon), enhanced the basic interface with different but incompatible implementations for buttons, drop down menus, and other active elements. V4 used for that purpose a dedicated control character embedded in normal text in contrast to System 3, which extended the kernel by introducing persistent objects. Both extensions include a large set of user interface elements.

Mastering the Oberon user interface, both the purely textual and the so-called Gadgets System (under S3), is non-trivial. Thus, after successfully installing Oberon System 3, it is recommended to study André Fischers Oberon System 3 Tutorial. An expanded version of this tutorial was published as a book, [32] which it is out of print now. The whole book is available in electronic form under a one user license in every installed version of System 3 (Windows, Linux, or Native, i.e., also with the Gadgets toolkit of OLR [33] ). More information how to get your own copy of the Oberon Companion may be found in the Getting Started section of the Oberon Wikibook.

Similar user Interfaces have yet to appear in more commonplace operating systems. Rob Pike's Acme system for Plan 9 from Bell Labs was strongly inspired by the Oberon TUI. Whether the worksheet interface of the Macintosh Programmer's Workshop influenced Oberon's TUI or vice versa is difficult to decide: the Oberon System was based on Wirth's prior computer design, the Lilith, and both the Apple Macintosh (and its precursor Lisa) and the Oberon System (on Ceres and its precursor Lilith) have the same roots: they were all inspired by the Alto developed at Xerox PARC.

Versions and availability

V1 was the first usable version some time before the Oberon Trilogy [6] [7] [8] was published. A major change in the text model together with the editor named Write [28] yielded V2. As foreshadowed in the table in section History above, there was a major fork in the early 1990s: V4 vs. System 3: The group around Jürg Gutknecht introduced persistent objects and object-libraries thereby extending the kernel. The group around Hanspeter Mössenböck realized similar features by introducing active elements mapped to a special character thereby extending fonts without changing the kernel. System 3 was sometimes also named Spirit of Oberon and later renamed ETH Oberon, whereas V4 was sometimes also named Linz Oberon.

The Oberon subsystem in A2 on an XO-1.5. XO.A2.Oberon.jpg
The Oberon subsystem in A2 on an XO-1.5.

As of 2017, the Oberon OS is available for several hardware computing platforms, generally in no cost versions and from several sources, which is quite confusing. The Oberon OS is typically extremely compact. Even with an Oberon compiler, assorted utilities including a web browser, TCP/IP networking, and a GUI, the full package can be compressed to one 3.5" floppy disk. There are versions which emulated the Oberon OS on another operating system and versions which run on bare hardware. The latter ones are named Native Oberon. There are native versions for the Ceres, Intel IA-32, and ARM platforms. In 2013, Niklaus Wirth adapted the basic system as described in "Project Oberon" [7] to a current FPGA design. According to the preface of the 2013 edition, the whole system compiles in less than 10 seconds on a Spartan-3 board. This version is sometimes also named V5, despite it being much more similar functionally to the original V1 running on the Ceres than any of the later versions.

Plugin Oberon and slim binaries

A version of the Oberon System 3, [15] which is more integrated in the Microsoft Windows OS than other implementations was named Plugin Oberon. [34] Plugin Oberon had support for OLE, Netscape Plugins, and the binary format named Oberon Module Interchange (OMI) or slim binaries, which allowed portable object code between Intel x86, Motorola 68K, and PowerPC architectures. Slim binaries were invented by Michael Franz in the early 1990s. They were motivated and opposed to the fat binaries invented by Apple during the transition from 68k to PowerPC architectures. [35] OMI provided portable code based on a compressed version of the abstract syntax tree. The approach of a compressed abstract syntax tree for portable code representation is revived in the Java world for GraalVM and Truffle.

Oberon V4

The version named Oberon V4 (see also History) is closer to the original operating system developed by Wirth and Gutknecht. It was originally developed at ETHZ, but when H.P. Mössenböck went to Institut für Systemsoftware at Johannes-Kepler University in Linz (JKU), the development of V4 moved also. Thus, V4 is sometimes also called Linz-Oberon in contrast to ETH-Oberon. The most recent version of V4 and extensions are available at JKU. Oberon V4 appears to be orphaned, there are almost no changes since 2000. Another repository of V4 is Claudio Nieder's Oberon V4, which also shows difference between the different V4 implementations. Since 2013 this page moved to/is mirrored at SourceForge. V4 is closer to what would now be called an integrated development environment than an operating system of its own. There were many extensions written for V4, which are still available from the ftp server of SSW at JKU; some documentation can be found on their web-pages, more information is normally included in the packages and it is given in Oberon's special rich text format.

AOS/Bluebottle/A2

Around 2010, the computer science department at ETH Zurich began exploring active objects and concurrency for operating systems, and has released an early version of a new language Active Oberon and a new operating system for it, first named Active Object System (AOS) in 2002, [5] then due to trademark issues, renamed Bluebottle in 2005, then renamed A2 in 2008. It is available from ETH Zurich with most source via the Internet. Native versions of A2 run on single- and multi-processor x86-32 and x86-64 hardware, both on bare metal and inside virtual machines. It was previously also available for the StrongARM CPU family. Versions which execute as programs under other operating systems are available on Windows (WinAos), Unix (UnixAos), Linux (LinuxAos), and macOS (DarwinAos). More detailed information about A2 is on the Russian Wikipedia pages about A2.

stailaOS

As a part of an industrial research project [36] the Native Systems Group of ETH Zurich has developed an application-specific operating system named stailaOS which is based on the latest version Oberon OS. It is intended for uses such as real-time analytics, financial applications, main memory based enterprise resource planning (ERP), etc.

Native Oberon

The Oberon0 installer running on QEMU in Debian Wheezy. The presentation of the partition table illustrates the comprehensibility of the system in general. Oberon0UnderQEMU.png
The Oberon0 installer running on QEMU in Debian Wheezy. The presentation of the partition table illustrates the comprehensibility of the system in general.

Native Oberon is an Oberon System that runs on bare hardware. [37] PC-Native Oberon is a version that runs on IA-32 (x86-32) PC hardware. There has never been a V4 Native Oberon, so all information in this section implicitly assumes that it is System 3. Native Oberon has small hardware requirements: 133 MHz Pentium, 100MB hard disk, VESA 2 graphics card with resolution minimum of 1024x768 pixels, optional 3Com network card. The basic system runs from one HD floppy disk, and more software can be installed through a network. The full installation includes the Gadgets GUI. It is written fully in the language Oberon. The latest available version was 2.3.7. It is dated 5. January 2003 and sometimes also labeled as Update/Alpha, especially on the ftp-server of ETHZ. Later versions were incorporated in AOS/BlueBottle/A2.

LNO

A version named Linux Native Oberon (LNO) uses Linux as a hardware abstraction layer (HAL). Its goal is to be as compatible as possible to PC-Native Oberon. Other versions of the Oberon System, without Native in the name, had partly modified interfaces of low level modules. In 2015, Peter Matthias revitalized LNO under the name Oberon Linux Revival (OLR) [33] as a multi-platform distribution running seamlessly on Intel x86, ARM, MIPS, and RISC-V. It runs well on the Raspberry Pi and on the low cost (discontinued) CHIP computer; with some tweaking (adjusting group membership or/and permissions on some devices) it runs well on Tiny Core Linux. OLR interfaces with Linux kernel by direct system calls. As of June 2017, OLR lacks a network layer.

Project Oberon 2013

In 2013, Wirth and Paul Reed completed a re-implementation of the original Oberon System for the Digilent Xilinx Spartan 3 FPGA Starter Board. The work includes a revision of "Project Oberon", [7] identified as Project Oberon (New Edition 2013). In 2015, Reed collaborated with Victor Yurkovsky to create OberonStation, a Xilinx Spartan 3-based computer designed specifically to run Oberon. The system has since been ported to a Xilinx Spartan 6 FPGA Pepino development board by Saanlima Electronics, and a Xilinx Artix 7-based Digilent Nexys A7-100 FPGA Trainer board by CFB Software. Peter de Wachter implemented an emulator for it, which was also ported to Java and JavaScript by Michael Schierl, running in modern browsers, and ported to Free Pascal/Ultibo by Markus Greim and to Go. [22] [23] [24] [25] Andreas Pirklbauer maintains an experimental version and extensions of Project Oberon 2013 at GitHub.

Glossary

See also

Related Research Articles

The Modula programming language is a descendant of the Pascal language. It was developed in Switzerland, at ETH Zurich, in the mid-1970s by Niklaus Wirth, the same person who designed Pascal. The main innovation of Modula over Pascal is a module system, used for grouping sets of related declarations into program units; hence the name Modula. The language is defined in a report by Wirth called Modula. A language for modular multiprogramming published 1976.

<span class="mw-page-title-main">Niklaus Wirth</span> Swiss computer scientist (1934–2024)

Niklaus Emil Wirth was a Swiss computer scientist. He designed several programming languages, including Pascal, and pioneered several classic topics in software engineering. In 1984, he won the Turing Award, generally recognized as the highest distinction in computer science, "for developing a sequence of innovative computer languages".

<span class="mw-page-title-main">Oberon (programming language)</span> General-purpose programming language

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. 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 type extension of record types. It permits constructing new data types on the basis of existing ones and to relate them, deviating from the dogma of strictly 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 elfs.

An object-oriented operating system is an operating system that is designed, structured, and operated using object-oriented programming principles.

Component Pascal is a programming language in the tradition of Niklaus Wirth's Pascal, Modula-2, Oberon and Oberon-2. It bears the name of the language Pascal and preserves its heritage, but is incompatible with Pascal. Instead, it is a minor variant and refinement of Oberon-2 with a more expressive type system and built-in string support. Component Pascal was originally named Oberon/L, and was designed and supported by a small ETH Zürich spin-off company named Oberon microsystems. They developed an integrated development environment (IDE) named BlackBox Component Builder. Since 2014, development and support has been taken over by a small group of volunteers. The first version of the IDE was released in 1994, as Oberon/F. At the time, it presented a novel approach to graphical user interface (GUI) construction based on editable forms, where fields and command buttons are linked to exported variables and executable procedures. This approach bears some similarity to the code-behind way used in Microsoft's .NET 3.0 to access code in Extensible Application Markup Language (XAML), which was released in 2008.

<span class="mw-page-title-main">Lilith (computer)</span> 1980 custom-built workstation computer

The DISER Lilith is a custom built workstation computer based on the Advanced Micro Devices (AMD) 2901 bit slicing processor, created by a group led by Niklaus Wirth at ETH Zurich. The project began in 1977, and by 1984 several hundred workstations were in use. It has a high resolution full page portrait oriented cathode ray tube display, a mouse, a laser printer interface, and a computer networking interface. Its software is written fully in Modula-2 and includes a relational database program named Lidas.

<span class="mw-page-title-main">Oberon-2</span> Programming language

Oberon-2 is an extension of the original Oberon programming language that adds limited reflection and object-oriented programming facilities, open arrays as pointer base types, read-only field export, and reintroduces the FOR loop from Modula-2.

<span class="mw-page-title-main">Text-based user interface</span> Type of interface based on outputting to or controlling a text display

In computing, text-based user interfaces (TUI), is a retronym describing a type of user interface (UI) common as an early form of human–computer interaction, before the advent of bitmapped displays and modern conventional graphical user interfaces (GUIs). Like modern GUIs, they can use the entire screen area and may accept mouse and other inputs. They may also use color and often structure the display using box-drawing characters such as ┌ and ╣. The modern context of use is usually a terminal emulator.

Kronos is a series of 32-bit processor equipped printed circuit board systems, and the workstations based thereon, of a proprietary hardware architecture developed in the mid-1980s in Akademgorodok, a research city in Siberia, by the Academy of Sciences of the Soviet Union, Siberian branch, Novosibirsk Computing Center, Modular Asynchronous Developable Systems (MARS) project, Kronos Research Group (KRG).

<span class="mw-page-title-main">QEMU</span> Free virtualization and emulation software

QEMU is a free and open-source emulator. It emulates a computer's processor through dynamic binary translation and provides a set of different hardware and device models for the machine, enabling it to run a variety of guest operating systems. It can interoperate with Kernel-based Virtual Machine (KVM) to run virtual machines at near-native speed. QEMU can also do emulation for user-level processes, allowing applications compiled for one architecture to run on another.

A2 is a modular, object-oriented operating system with unconventional features including automatic garbage-collected memory management, and a zooming user interface. It was developed originally at ETH Zurich in 2002. It is free and open-source software under a BSD-like license.

The MicroBlaze is a soft microprocessor core designed for Xilinx field-programmable gate arrays (FPGA). As a soft-core processor, MicroBlaze is implemented entirely in the general-purpose memory and logic fabric of Xilinx FPGAs.

Wirth's law is an adage on computer performance which states that software is getting slower more rapidly than hardware is becoming faster.

Lola is designed to be a simple hardware description language for describing synchronous, digital circuits. Niklaus Wirth developed the language to teach digital design on field-programmable gate arrays (FPGAs) to computer science students while a professor at ETH Zurich.

LatticeMico32 is a 32-bit microprocessor reduced instruction set computer (RISC) soft core from Lattice Semiconductor optimized for field-programmable gate arrays (FPGAs). It uses a Harvard architecture, which means the instruction and data buses are separate. Bus arbitration logic can be used to combine the two buses, if desired.

<i>Algorithms + Data Structures = Programs</i> 1976 book by Niklaus Wirth

Algorithms + Data Structures = Programs is a 1976 book written by Niklaus Wirth covering some of the fundamental topics of system engineering, computer programming, particularly that algorithms and data structures are inherently related. For example, if one has a sorted list one will use a search algorithm optimal for sorted lists.

<span class="mw-page-title-main">Active Oberon</span>

Active Oberon is a general purpose programming language developed during 1996-1998 by the group around Niklaus Wirth and Jürg Gutknecht at the Swiss Federal Institute of Technology in Zürich. It is an extension of the programming language Oberon. The extensions aim at implementing active objects as expressions for parallelism. Compared to its predecessors, Oberon and Oberon-2, Active Oberon adds objects, system-guarded assertions, preemptive priority scheduling and a changed syntax for methods. Objects may be active, which means that they may be threads or processes. As it is tradition in the Oberon world, the Active Oberon language compiler is implemented in Active Oberon. The operating system named Active Object System (AOS) in 2002, then due to trademark issues, renamed Bluebottle in 2005, and then renamed A2 in 2008, especially the kernel, synchronizes and coordinates different active objects.

The Ceres Workstation was a workstation computer built by Niklaus Wirth's group at ETH Zurich in 1987. The central processing unit (CPU) is a National Semiconductor NS32000, and the operating system, named Oberon System is written fully in the object-oriented programming language Oberon. It is an early example of an operating system using basic object-oriented principles and garbage collection on the system level and a document centered approach for the user interface (UI), as envisaged later with OpenDoc. Ceres was a follow-up project to the Lilith workstation, based on AMD bit slicing technology and the programming language Modula-2.

Modula-2 is a structured, procedural programming language developed between 1977 and 1985/8 by Niklaus Wirth at ETH Zurich. It was created as the language for the operating system and application software of the Lilith personal workstation. It was later used for programming outside the context of the Lilith.

Jürg Gutknecht is a Swiss computer scientist. He developed, with Niklaus Wirth, the programming language Oberon and the corresponding operating system Oberon.

References

  1. ↑ Kulka, Irena. "Oberon: Welcome to Oberon". ETH. Archived from the original on 6 January 2017. Retrieved 27 November 2017.
  2. ↑ ETH-License
  3. 1 2 Wirth, Niklaus; Gutknecht, Jürg (1988). The Oberon System: Report Number 88 (PDF) (Report).
  4. ↑ Wirth, Niklaus: The Programming Language Oberon. Software - Practice and Experience, 18:7, 671-690, Jul. 1988
  5. 1 2 3 4 Muller, Pieter Johannes (2002). The active object system design and multiprocessor implementation (PDF) (PhD). Swiss Federal Institute of Technology, Zürich (ETH Zurich).
  6. 1 2 3 M. Reiser and N. Wirth: Programming in Oberon Addison-Wesley/ACM Press (1992) ISBN   0-201-56543-9. Out of print.
  7. 1 2 3 4 5 6 N. Wirth and J. Gutknecht: Project Oberon - The Design of an Operating System and Compiler Addison-Wesley/ACM Press (1992) ISBN   0-201-54428-8. Out of print. Online version of the second edition (2013).
  8. 1 2 3 4 Reiser, Martin: "The Oberon System - User Guide and Programmer's Manual" - Out-of-print - Addison-Wesley/ACM Press (1991) ISBN   0-201-54422-9
  9. ↑ A. R. Disteli, Oberon for PC on an MS-DOS base, Technical Report #203 der ETH Zurich, November 1993, Reprint.
  10. ↑ J. Supcik, HP-Oberon, Technical Report #212 of the ETH Zurich, November 1993, Reprint.
  11. ↑ M. Franz, MacOberon Reference Manual, Technical Report #142 der ETH Zurich, November 1993, Reprint.
  12. ↑ J. Templ, Design and implementation of SPARC-Oberon. Structured Programming, 12, 197–205 (1991).
  13. ↑ M. Brandis, R. Crelier, M. Franz, J. Templ, The Oberon System Family. Software-Practice and Experience, Vol. 25(12), 1331–1366, December 1995. Also: Technical Report 174 of the ETH Zurich.
  14. ↑ R. Gerike, Wider den Schnickschnack. Oberon System, Teil 1: Anwendersicht. c't 1994 (2) p. 180, Teil 2: Technische Einblicke. c't 1994 (3), p. 240 (German language).
  15. 1 2 3 H. Marais, Oberon System 3, Dr. Dobb's Journal, October 1994, pages 42-50.
  16. ↑ Pountain, Dick (May 1993). "Oberon: A Glimpse at the Future". Byte . Vol. 18, no. 5. p. 111ff – via Archive.org.
  17. ↑ Pountain, Dick (March 1991). "Modula's Children, Part II: Oberon". Byte . Vol. 16, no. 3. pp. 135–142 – via Archive.org.
  18. ↑ Pountain, Dick (January 1995). "The Oberon/F System" (PDF). Byte . Vol. 20, no. 1. p. 227f – via Vintage Apple.
  19. ↑ Börner, T. (March 1999). "Betriebssysteme: Native Oberon für den PC". Chip (in German). p. 131ff.
  20. ↑ Reed, Paul (21 December 2013). "[Oberon] Project Oberon, 2013 Edition" . Retrieved 13 February 2021.
  21. ↑ Wirth, Niklaus (20 February 2014). Niklaus Wirth Birthday Symposium. ETH Zurich. Retrieved 13 February 2021.
  22. 1 2 De Wachter, Peter (18 August 2020). "Oberon RISC Emulator". GitHub. Retrieved 13 February 2021.
  23. 1 2 Schierl, Michael (19 January 2021). "Project Oberon emulator in JavaScript and Java". GitHub. Retrieved 13 February 2021.
  24. 1 2 Greim, Markus (14 August 2016). "Port of the Oberon RISC Emulator to [Ultibo]". GitHub. Retrieved 13 February 2021.
  25. 1 2 "Project Oberon emulator in Go". GitHub. 18 September 2021. Retrieved 13 February 2021.
  26. ↑ de Jong, Roel P. (19 October 2018). "Oberon Workstation". Reactive Instruments. Retrieved 13 February 2021.
  27. ↑ Wirth, Niklaus. Designing a System from Scratch. Structured Programming (1989) Vol. 10, pp. 10–18.
  28. 1 2 Szyperski, Clemens A., Write: An extensible text editor for the Oberon system. Swiss Federal Institute of Technology in Zurich (1991). Report 151.
  29. ↑ Using the mouse and the keyboard https://web.archive.org/web/20171225160628/http://www.ethoberon.ethz.ch/ethoberon/tutorial/Mouse.contents.html
  30. ↑ Franz, Michael (2000). "Oberon: The Overlooked Jewel". In Böszörmény, Lászlo; Gutknecht, Jürg; Pomberger, Gustav (eds.). The School Niklaus Wirth: The Art of Simplicity. Morgan Kaufmann Publishers. pp. 41–53. CiteSeerX   10.1.1.90.7173 . ISBN   1-55860-723-4.
  31. ↑ Wirth, Niklaus (2015). "How to use the Oberon System" (PDF). Retrieved 24 November 2016.
  32. ↑ André Fischer & Hannes Marais: The Oberon Companion. A Guide to Using and Programming Oberon System 3. vdf Hochschulverlag AG (1997). ISBN   978-3728124937, out of print, but see notes in Getting Started section of the Oberon Wikibook
  33. 1 2 Matthias, Peter. "Oberon Linux Revival" . Retrieved 31 August 2016.
  34. ↑ Zeller, Emil Johann (2002). "Fine-grained integration of Oberon into Windows using pluggable objects" (PDF).
  35. ↑ Franz, Michael (1 March 1994). Code-Generation On-the-Fly: A Key to Portable Software. Zürich: Verlag der Fachvereine Hochschulverlag AG an der ETH Zurich. ISBN   978-3728121158.
  36. ↑ stailaOS (ETHZ) Project Page Archived 2011-10-04 at the Wayback Machine
  37. ↑ Archives of the Oberon Website.
  38. ↑ "Fox Tool". Archived from the original on 6 February 2018. Retrieved 19 March 2021.
  39. ↑ Crelier, Régis. "Separate Compilation and Module Extension". ETH Zurich. Retrieved 18 November 2018.
  40. ↑ Wirth, Niklaus. "FPGA-related Work". ETH Zurich. Retrieved 12 September 2016.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.