Now Reading
Oberon-2, a hi-performance various to C++

Oberon-2, a hi-performance various to C++

2023-01-24 03:12:20

Oberon-2, a hi-performance various to C++ <br />

ModulaTor logo, 7.8KB

Oberon-2 and Modula-2 Technical Publication

Ubaye’s First Unbiased Modula-2 & Oberon-2 Journal! Nr. WS, Jan-1997

(This text has been submitted for publication.
Copyright could also be transferred with out additional
discover and this model might now not be accessible.)

Günter Dotzel
La Chanenche
F-04340 Meolans Revel (France)

Wojtek Skulski
Chemistry Division and Nuclear Construction Analysis Laboratory

College of Rochester
Rochester, NY 14623, USA

August 26, 1996


Oberon is a extremely environment friendly, general-purpose programming language, descendant of Pascal and
Modula-2. It is easier but extra highly effective than its predecessors. Oberon packages are structured,
modular and type-safe. Object-oriented programming is supported via the kind extension mech-
anism, single inheritance, procedural variables, type-bound strategies, information hiding and encapsulation,
and rubbish assortment. Each standalone and built-in Oberon compilers can be found for many
sorts of standard pc platforms.

1. Oberon: the brand new Pascal

Oberon [1] is a contemporary, general-purpose programming language which has all of the important options of different standard
object-oriented programming languages, resembling courses, inheritance, strategies and messages. At the identical time,
“Oberon” can also be the title of an extensible working system [2]
written in Oberon programming language. Each,
the language and the system, had been developed by Prof. Niklaus Wirth and collaborators at Eidgenössische Technische
Hochschule (ETH) in Züurich. As a professional inheritor within the Pascal household, designed by the identical one that additionally designed
Pascal and Modula-2, Oberon is each an previous and new programming language. It depends on three many years of expertise
and growth. At the identical time, Oberon is easier but extra highly effective than its predecessors Pascal and Modula-2.

The citation from Einstein “make it so simple as attainable, however not less complicated” grew to become the motto of the Oberon
venture. This design objective was achieved by eliminating many superfluous Modula-2 options, resembling nested modules,
subrange varieties, enumerations, variant information and a selective import assertion. Module definition and implementation
elements have been merged into one textual content file. In order to help object-oriented programming (OOP), solely only a few
new phrases had been added. In addition to rubbish assortment, a very powerful new language function was kind extension.
Considerably surprisingly, the OOP methodology might be totally supported as a particular case of extra normal programming
methods supplied by the Oberon language. There was little have to introduce “courses”, “inheritance”, “strategies”,
and so forth, as particular OOP phrases, along with these already present. In a way, Oberon grew to become the world’s smallest, but
totally purposeful OOP language.

The simplicity, gained by purging the pointless whereas including solely as few new options as attainable, resulted in a
language which is simple to be taught, easy to implement, and likewise very environment friendly. Final, however not least, it’s a pleasure to
work with. On this article we are going to attempt to convey this “spirit of Oberon” to the reader.

Maybe a very powerful information is that the standard procedural model is totally supported together with OOP. One
can thus write a wholly conventional program in Oberon. This interprets right into a flat studying curve. Migration from
Fortran is nearly computerized, no less than for many who organize their Fortran packages neatly. Additionally, Pascal or Modula-2
programmers may be up and writing Oberon packages in simply a few hours, after looking via the compact
language report and noting new options of the language. Naturally, studying the OOP methods will take considerably
longer, however this isn’t as a result of complexity of the language itself, however fairly as a result of complexity of the topic.
So far as the language goes, there may be virtually nothing to be realized the exhausting method.

One of many excellent Oberon qualities is the necessary modular construction of Oberon packages, a function retained
from Modula-2. A easy instance will illustrate the purpose:

    (*  Easy point-and-click on-screen calculator. How you can use:

    (1) mark any integer with proper mouse button, wherever on display

    (2) click on center mouse button on Adder.AddInt ^ *)

    MODULE Adder;

    IMPORT In, Out; (* Adder makes use of providers of different modules *)

    VAR s: REAL;    (*  sum isn't accessible from exterior *)

    PROCEDURE Clear*; (** clear the sum *)


      Out.String('Clearing sum'); s := 0; Out.Ln

    END  Clear;

    PROCEDURE  AddInt*;

    (** take integer from display, add to sum *)



     In.Open; In.Int(i); x := i;

     IF In.Achieved THEN


          Out.String('Including '); Out.Actual(x,10); Out.Ln;

     ELSE Out.String('Learn error'); Out.Ln


    END  AddInt;

    PROCEDURE  Present*;

    (** present  the  sum on display *)


     Out.String('Sum:'); Out.Actual(s,11); Out.Ln

    END  Present;

    BEGIN (*  module initialization part *)

      s := 0

    END Adder.

    Adder.AddInt ^ Adder.Present Adder.Clear

All Oberon packages should take type of modules, like the straightforward on-screen adder proven above. In contrast with
conventional packages written in Fortran, Pascal, or C, Oberon packages have a number of entry factors, which on this case
had been named Adder.AddInt, Adder.Present and Adder.Clear, all three with apparent which means. All entities marked
with asterisks are seen exterior the module and accessible for shopper modules, who can import Adder to make use of the
providers it exports. No matter isn’t marked, is hidden and thus protected against exterior entry.

On this method, Oberon modules are divided into hidden implementations and public interfaces, each outlined by the
identical supply textual content. An interface of our adder module may be extracted with one of many “browser” customary packages
out there beneath all Oberon implementations. Our favourite browser referred to as “Def” (naturally, a module itself), will
extract additionally the specifically marked feedback to provide an annotated “public view” of our on-screen adder program:



    (* clear the sum *)


   (* take integer from display, add to sum *)

  PROCEDURE Present;

    (* present  the  sum on display *)

  END Adder.

One other considerably uncommon function is that beneath the Oberon System (to be mentioned later), module entry-points
may be activated instantly from any Oberon text-window by pointing and clicking with the mouse. Thus, it isn’t by
accident that we put three “Oberon instructions” proper after the supply itemizing above. These instructions, syntactically
a mix of “Modulename.Entryname”, type easy but totally purposeful consumer interface to the adder program. It
is probably the world’s easiest point-and-click” consumer interface. With no particular configuration instruments, any consumer can
develop amazingly easy “point-and-click” interactive packages in a matter of minutes. Below the Oberon System
atmosphere, any textual content window can function consumer interface to any Oberon program, as illustrated above. Consequently,
there isn’t any standard command shell or command line beneath the Oberon atmosphere.

One also needs to word, that in truth any Oberon System textual content window is editable with out explicitly invoking an editor
program, as a result of a strong multifont wordprocessor is a normal builtin atmosphere element. To be able to begin
modifying any displayed textual content, it is sufficient to level and click on the mouse on the supposed spot. Program texts (typeset in
shade and a number of fonts) may be compiled instantly both from disk information or from any textual content window. Examples of this
facility may be discovered on the display pictures included with this text.

2. Object-Oriented Programming in Oberon

We now flip our consideration to the object-oriented aspect of the Oberon language. A easy illustration is offered
beneath. Assuming a given structured file kind


extensions could also be outlined which include sure fields along with the prevailing ones. For instance, the next


   T0 = RECORD (T) z: REAL END;  (* extension of T *)

   T1 = RECORD (T) w: LONGREAL END; (* extension of T *)

outline new varieties T0 and T1, with fields x, y, z and x, y, w, respectively. Each T0 and T1 may be referred to as “subclasses”
of the bottom class T (this terminology is a matter of pure conference.) Moreover, “strategies” and “methodology calls”
are launched as follows:


    motion  = PROCEDURE (a,b: INTEGER): INTEGER; (* a procedural kind *)

    T2 = RECORD (T)

           Add: motion   (*  "Add" is a "methodology" of the T2 class *)



    object: T2; end result: INTEGER;


    object.x := 123; object.y := 456;

    end result := object.Add (object.x, object.y); (* methodology name *)


This instance reveals, that certainly it was attainable to introduce important OOP idea with none particular OOP
terminology. All that was wanted was structured extensible file varieties with information fields of procedural kind. In
this method, a “methodology” is just a procedural information subject outlined for a given file kind. Such a way is
“polymorphic” in a pure method, as a result of, by their very nature, file fields may be redefined on the fly. Knowledge fields
resembling x, y, and z, could also be regarded as “class attributes”.

Strictly talking, the above method to OOP is the one initially launched by the Oberon language [1]. In a while,
the language revision referred to as Oberon-2 [3]
launched one other, barely completely different notation motivated by consumer comfort:


    T3  = RECORD (T) END;

    PROCEDURE (VAR me: T3) Add(): INTEGER;


     RETURN (me.x + me.y)

    END Add;

In this instance, process Add is a digital methodology “certain to a sort T3” via the “receiver” parameter me.
(For readability, the receiver should be explicitely specified. In Oberon there isn’t any predeclared receiver title resembling
“self”.) In derived varieties this methodology may be redefined, beneath the restriction that the formal parameter record stays
the identical (on this instance it’s empty):


    T4  = RECORD (T3) t, u, v: INTEGER END; (* new information fields *)

    PROCEDURE (VAR me: T4) Add(): INTEGER; (* "Add" is redefined *)


     RETURN (me.x + me.y + me.t + me.u + me.v)

    END Add;

Invoking the strategy “Add” is carried out as follows: end result := object.Add();
this time there isn’t any have to
explicitly go the parameters. Therefore, the parameter record is now empty. The appropriate model of the strategy being
referred to as is set at run time, relying on which kind of the “occasion variable” one is coping with. Whether it is T3,
the Add variant certain to T3 will likely be referred to as, and the sum of two numbers will likely be returned. If it’s T4, 5 numbers
will likely be added collectively.

We wish to stress, that this extra standard method to OOP strategies was launched just for comfort
of these customers who already realized OOP elsewhere. The unique Oberon model continues to be retained for the purists. The
distinction between the 2 is of secondary significance, and one can combine each OOP kinds in the identical program.

Due to the conceptual simplicity outlined above, the Oberon language is simple to be taught and to make use of. It’s a reas-
onable selection for training [5], programming within the massive [2]
and in consequence additionally for industrial software program growth.
The remainder of this text will likely be organized within the “query and reply” model to be able to hold presentation easy.

Does Oberon help dynamic arrays and matrices?

The multi-dimensional “open array” is the usual function of the language. The following instance reveals, easy methods to
allocate at run-time a one- and a two dimensional array with 50 components in every dimension.


   Open1Array  =  POINTER TO ARRAY OF REAL;          (*1  dim *)

   Open2Array  =  POINTER TO ARRAY OF ARRAY OF REAL; (*2 dim *)


   My1Array:  Open1Array; My2Array: Open2Array;


   NEW (My1Array, 50); (* dynamic allocation *)

   FOR i := 0 TO LEN(My1Array)-1 DO

     My1Array[i] := 0.0;

   END; (* FOR i *)

   NEW  (My2Array, 50,50); (* dynamic allocation *)

   FOR i := 0 TO LEN(My2Array,0)-1 DO

     FOR j := 0 TO LEN(My2Array,1)-1 DO

       My2Array[i,j] := 0.0

     END (* FOR j *)

   END (* FOR i *)


Evaluating this instance with Fortran, one can see that array indices at all times begin at 0, like in C! Naturally, one can
at all times discover a couple of such inconveniences within the Oberon language. One other inconvenience is lack of built-in COMPLEX
information kind (it’s nevertheless a normal a part of AlphaOberon [6]). Complicated numbers have been applied as a library

Is Oberon language kind protected?

Sort security was the foremost consideration of the language design. In contrast with Fortran or C, Oberon is nearly
completely protected, what is sort of outstanding for an extensible language relaying closely on dynamically allotted information
buildings. Security was achieved by static kind checking throughout compilation time (additionally throughout module boundaries),
dynamic kind checks at run-time, in addition to pointer security facilitated by rubbish assortment. Each the compiler and
the runtime system implement that if a module interface has modified, all its shoppers must be recompiled. Very few
safety gaps nonetheless remaining are nicely documented and may be simply prevented.

To be able to facilitate low-level programming, options to breach the kind system are offered via a particular
customary module named SYSTEM. The correctness of any given program module may be rigorously confirmed based mostly
on the imported module interfaces, beneath the precondition, that the import of module SYSTEM isn’t seen in
the interface. Though symbolic autopsy and run-time debuggers can be found, in observe there may be little or no
want for debugging Oberon packages, and no want in any respect for any form of a “lint utility”. Most programming errors
are detected at compile time. Few remaining ones are simply pinned down with the assistance of the ASSERT customary

Is it rubbish collected?

Rubbish assortment is offered and robotically triggered, when heap area is vital.
For instance, most implementations of Oberon layered on-top of present working methods resembling Unix, invoke the rubbish collector every
time when opening a file.

Can the consumer outline new varieties/courses?

Sure, that is the one most essential new function of the language, as in comparison with its predecessors Pascal and
Modula-2. Courses are merely file varieties with procedures certain to them. There isn’t any have to duplicate the headers
of certain procedures within the file as it’s accomplished in different object-oriented languages like C++ or Object Pascal. This
retains file declarations brief and avoids disagreeable redundancy. The “class browser” customary device utility permits
to record the file varieties along with all procedures certain to them.

Does it really help OOP?

Oberon is termed a “hybrid language”. It helps OOP through extensible varieties, single inheritance, polymorphism,
worth and reference based mostly objects, two classes of visibility, i.e.: public and hidden attributes and strategies, run-time
kind data and protracted objects. Nevertheless, Oberon is on no account “OOP solely”. Not every thing must be
courses. Fairly the other, the standard procedural model is supported together with OOP. One can write a wholly
conventional program in Oberon, or one can organize every thing in courses. Each approaches will also be combined. This
provides a programmer the very best of each worlds, what may be engaging for these customers, who wish to be taught OOP steadily.
Migration from Fortran to Oberon is nearly computerized, no less than in case of cleanly written Fortran packages.

Encapsulation, dynamic binding, inheritance?

Encapsulation of summary information varieties is offered via the module idea, related to Modula-2. Separate
“definition” and “implementation” modules had been dropped from Oberon. Exported objects are merely marked by an
asterisk following their declarations, or a touch in case of the read-only export. A single supply file per module simplifies
the upkeep overhead. No matter isn’t marked for export, is invisible for shoppers and thus encapsulated.

Automated dynamic binding is supported for the “type-bound” strategies defined above (the Oberon-2 methodology
model). The conventional Oberon-1 strategies are merely process variables assigned “by hand” to respective file
information fields of procedural kind. These strategies are statically certain to each variable occasion. They may be thus
reassigned at any time. This is especially helpful in GUI methods, the place the conduct of a given object may be
modified on the fly by altering its handler process (certainly one of object’s procedural information fields). As already talked about,
each OOP kinds may be freely combined, the place applicable.

Solely single inheritance is offered in Oberon. Arguably, this supplies the identical flexibility as a number of inheritance
identified from C++, however avoids the issues related to the latter. As proven by Mössenböck [3], options equal
to a number of inheritance may be simply achieved utilizing single inheritance mechanisms. A number of inheritance was due to this fact
not launched into the Oberon language. The identical was true with operator overloading: advantages weren’t well worth the
price and issues.

Is Oberon easy to be taught and use?

Oberon is probably the only of all OOP languages. The entire defining Oberon-2 language report [3] has solely
28 pages together with examples and appendices with formal description of syntax, definition of phrases, compatibility guidelines
and the SYSTEM module. This concise language report compares favorably with lots of of pages wanted to outline
another trendy programming languages. As a result of of the standard aspect of the language, Pascal or Modula-2
programmers will want solely a few hours to begin writing Oberon packages. Naturally, studying OOP methods
will take longer, however not due to the complexity of the language itself, however fairly due to the complexity of the
topic. As far because the language is taken into account, there may be virtually nothing to be realized the exhausting method.

A outstanding function of typical Oberon packages is their small measurement and small manpower wanted for growth
and upkeep. Oberon packages are sometimes measured in kilobytes, not in megabytes. For instance, despite
their nice sophistication, most implementations of the Oberon System may be distributed on single floppy disks, and
they are often successfully supported by very small developer groups.

What sort of documentation is offered?

Many articles and books had been revealed on Oberon, see the bibliography part beneath. In addition, superb
on-line paperwork are included with each Oberon System launch. Textual content-, graphics-, expression-, and formula-editor,
software programming interface, hypertext components, varied instruments and video games, are all completely documented. The
consumer can print these paperwork from inside his/her atmosphere, to have them useful.

What sort of libraries can be found?

There’s a customary set of library modules, widespread to all Oberon System releases, since it’s in truth an working
system of its personal. Regarding libraries particular to physics or math, there are few. This is of course as a result of reality
that physicists haven’t used Oberon a lot until now. Nevertheless, a couple of library growth initiatives are underway. This
relative lack of libraries isn’t as severe because it sounds, since most present Fortran and Pascal routines port simply,
as a result of “conventional aspect” of the language. It takes normally solely about half an hour to port a few Numerical
Recipes Fortran subroutines. Adjustments are principally mechanical.

Can one hyperlink Oberon with different languages?

Calling different languages from the Oberon System is system-specific and is determined by no matter dynamic hyperlink/load
amenities exist within the host working system. Most Oberon System implementations enable working system calls,
resembling calling Unix, Mac Toolbox, or Home windows API. AlphaOberon permits to name any international language routine of
any shareable picture. This consists of all system- and run-time library routines, in addition to entry to X11/OSF/Motif.
Stand-alone Oberon-2 compilers typically enable international language calls.

What sort of programming environments can be found for Oberon?

Amongst many built-in Oberon environments out there, there may be an excellent one referred to as the Oberon System [2, 4]
It originated as an entire graphical working system for a specific pc {hardware} developed at ETH-Zürich.
Two completely different variants of the Oberon System, model 3 and 4, emerged by now. Architecturally, V3 is totally based mostly
upon persistent objects, whereas V4 isn’t, however on the identical time V4 is much less complicated than V3. Each variations embrace
every thing wanted to effectively conduct on a regular basis work, resembling a compiler, a programming library together with a easy
but very efficient graphical consumer interface, and a complicated multifont textual content processor full with hyper-text
components and pop-up menus embedded in any textual content (even in supply packages). The usual Oberon System editor is
extensible in performance. Many helpful extensions of this primary system exist already, which embrace textual content formatting,
formulation editor, and graphics components.

Moreover, non-compulsory graphical consumer interface kits can be found beneath each V3 and V4 environments, that includes
subtle pop-up menus and a variety of configurable dialog containers (Dialogs [7], Devices [8]). The device set
out there beneath V3 is especially spectacular. It features a program formatter, spreadsheet, sorter, mailer, WWW
browser, Java interpreter and plenty of video games resembling Tetris and MineSweeper. Most packages can be found with supply

The Oberon System (both V3 or V4) is offered for all standard platforms: Amiga, DECAlpha (OpenVMS), MacII,
PowerMac, PC (DOS, Home windows, WNT/Win95, OS/2, Linux), NeXt (each Intel and 68k), Unix (DECStation/MIPS,
HP-9000/HP-UX, RS6000, SGI, SunSparc/Solaris). On these platforms, the Oberon System runs as an software
beneath the management of the host working system. The Oberon System has precisely the identical look-and-feel, regardless of
the platform it runs on. Texts and graphics are transportable throughout all platforms, no matter byte ordering (little or large
endian). Most Oberon-2 packages, written with this atmosphere in thoughts, may be ported to all platforms talked about
above by easy recompilation.

Of particular curiosity is the Native Oberon System for PC, at present in beta-testing stage. This model of the System
V3 runs on a naked PC {hardware}. It consists of all the instruments and elements already talked about.

Dynamic loading is the default mode for Oberon System. No separate linking step is required. Compiled modules
are robotically loaded and linked when any merchandise belonging to the module is referenced for the primary time. This
function, referred to as “lazy module loading”, permits to load and begin massive software packages very quick. Neither the
quantity of modules nor their names should be identified a priori when invoking a program.

Oberon packages may be prolonged at run-time by including new modules, or by changing an lively module by a
modified and newly compiled model. This can occur additionally when different elements of the appliance stay loaded
into pc reminiscence. Oberon System is thus an uncommon programming atmosphere, as a result of it permits piece-wise
modification of lively functions when the functions are operating. Since Oberon compilation is blazingly quick, this
interprets into very environment friendly software program growth cycle.

What about standard programming environments?

For these customers preferring to work beneath their conventional atmosphere, a number of non-integrated, command-line
Oberon-2 compilers can be found, each public area and business. For instance, a free o2c Oberon-to-C
translator may be built-in within the emacs atmosphere. o2c
has been ported to an important number of platforms. The
business Oberon-to-C translator Ofront
can be utilized each within the standalone command-line mode and within the
built-in atmosphere mode. The identical is true for the business implementation for DECAlpha: it options each,
a stand-alone compiler producing OpenVMS object information, in addition to the model of the compiler embedded within the Oberon
System (AlphaOberon). Different variants of the Oberon System for Home windows and Mac exist, that are “built-in into”
the windowing system of the host working atmosphere, and thus comply with standard “appear and feel” of respective

Does Oberon include supply code?

The unique Oberon System was revealed with full supply together with the compiler. As of time of this writing, a couple of
different implementations had been additionally launched with full supply: Amiga, Macintosh (each 68k and PowerPC) and Home windows
variations of the Oberon System V4. (The supply of different implementations is offered on request.) The Oberon-to-C
translator o2c
additionally comes with full supply.

Which implementation is sweet for me?

With so many alternative Oberon implementations out there, one doesn’t match all. Which one is the very best for the
reader, is determined by the appliance. If one desires to hyperlink Oberon code with present libraries, then both freeware o2c
or business Ofront
would be the most suitable option, or business AlphaOberon for the DECAlpha platform. Customers
desirous about “multi function” atmosphere can decide up both V3 or V4 environments. Each are perfect for interactive information
processing. Their invaluable asset is just about no GUI overhead since efficient GUIs are offered in several flavors.
One can undertake both the austere default Oberon GUI, or very subtle add-on packages like Dialogs or Devices.
One can thus develop totally interactive packages with minimal funding. (An instance of an on-screen interactive
adder was given above.)

What form of functions is Oberon finest for?

See Also

Up to now, the programming language Pascal suffered from the “principally educating language” opinion. The identical
mustn’t occur to Oberon, which needs to be considered a general-purpose programming language. The very
first program ever written in Oberon was a complicated graphical working system [2] proving the language to be
an acceptable device for large-scale system programming. Oberon is at present getting used for distributed programming,
database entry, interactive information evaluation, picture processing, and for CAD design. As an instance, the Trianus
venture [9], at present underway at ETH Zürich, focuses on designing digital circuits with Area-Programmable Gate
Arrays (FPGAs). For this function a multiple-view editor is being developed, which presents a design textually and
graphically. With assistance from this editor, a designer can manipulate a circuit structure beneath the constraints of a textual
specification offered by the textual view. By intently coupling the representations, circuit data, e.g. sign
delays, is immediately out there.

An instance of interactive information evaluation with Oberon is the Voyager venture developed at StatLab Heidelberg [10].
It focuses on an extensible transportable programming atmosphere for statistical computing and simulation, based mostly on
Oberon System. This and plenty of different Oberon initiatives may be accessed over the Web.

Along with these “actual world” functions, Oberon can and may turn into a severe various to Pascal in
training. A number of programming environments, that are freely out there for the most well-liked PC and MacIntosh
platforms, afford to setup pupil programming programs without charge. An teacher can educate each conventional procedural
programming model and the brand new object-oriented methods utilizing the identical programming language and atmosphere.
Novel object-oriented GUIs resembling Dialogs or Devices can turn into customary matters of programming programs centered
on Oberon System. At the identical time, variations of the atmosphere embedded within the conventional MS-Home windows and
MacOS environments (additionally free for academic use) may be helpful to show extra conventional GUI methods. Extra
particulars can be found via the “Oberon in training” residence web page [5]

Lately a brand new thrilling Oberon venture [11] named “Juice” was launched by the College of California at Irvine.
Juice is a brand new expertise for distributing executable content material throughout the World Broad Net. It is thus just like Java
from Solar Microsystems. Nevertheless, Juice outperforms Java in lots of “downloadable Applets” functions, particularly
massive ones. Relatively than being interpreted, as Java applets usually are, Juice at all times compiles every applet from
its mom tongue Oberon into the native code of the goal machine. Juice’s on-the-fly compilation isn’t solely
very quick, nevertheless it additionally generates object code that’s comparable in high quality to business C compilers. Additional, Juice
avoids most of the Java safety points, as a result of sturdy kind checking makes it just about not possible to put in writing an
applet that violates safety guidelines imposed by the Oberon supply language. The Juice venture may be accessed at

3. Abstract

The simplicity gained by purging pointless options is a useful asset of Oberon, which is probably the one
programming language which solves extra issues than it creates. Oberon is a sound device to conduct severe work.
The reader who desires to check out certainly one of present Oberon implementations, can obtain one them from the Web
and set up in lower than an hour. For novices, one of many built-in variations is advisable. Most built-in
environments match on a single floppy, and so they embrace documentation and host of helpful instruments. For severe growth,
both the built-in or standalone compiler could be a more sensible choice, relying on concrete venture. The Oberon
growth group could be very vigorous. New variations of Oberon instruments seem steadily.

4. Acknowlegments

We are indebted to our mates from ETH Zürich and from Univ. Linz for all their nice Oberon work and for a lot of
discussions. Man Laden contributed useful feedback on the draft model of the manuscript.

5. References

Oberon on the Net

An entire abstract and particulars of all present implementations of Oberon methods, compilers, associated documentation,
functions, an analysis papers, may be discovered on the Net at

The gathering of The ModulaTor TechJournal is at


[1] : N. Wirth and M. Reiser:
Programming in Oberon. Steps beyond Pascal and Modula.

Addison Wesley, 1992, ISBN 0-201-56543-9.
Tutorial for the Oberon programming language and concise language reference.

[2] : N. Wirth and J. Gutknecht:
Project Oberon. The Design of an Operating System and Compiler.

Addison Wesley, 1992, ISBN 0-201-54428-8.
Program listings with clarification for the entire system, together with the compiler for NS32000 processor.

[3] : H. Mössenböck:
Object-Oriented Programming in Oberon-2.
Springer, 1993, ISBN 3-540-56411-X.
Rules and functions of object-oriented programming with examples within the language Oberon-2.

[4] : M. Reiser:
The Oberon System. User Guide and Programmer’s Manual.

Addison Wesley, 1991, ISBN 0-201-54422-9. Addison Wesley, 1992, ISBN 0-201-56543-9.
Consumer guide for the programming atmosphere and reference for the usual module library.

[5] : “Oberon in Schooling” residence web page:
. See additionally J~urg Gutknecht’s
article Oberon in Education” within the ModulaTor.

[6] : Günter Dotzel:
OpenVMS Alpha Modula-2 and Oberon-2 Compiler Venture. In: Peter Schulthess
(Hsg.): Proceedings of the Joint Modular Languages Convention,
Universit~atsverlag Ulm, 1994.
Revised edition in HTML at

[7] : M. Knasmüller: Oberon Dialogs, Consumer’s Information and Programming
Interface. Institut für Informatik, Johannes Kepler Universität Linz, Report No. 1, 1994.

[8] : J. L. Marais: The Devices Consumer Interface Administration System. Division Informatik, ETH Z~urich, Report No. 144,

[9] : N. Wirth residence web page:

[10] : The Voyager venture:

[11] : The Juice venture:

Fig. 1. Oberon System 3 graphical consumer interface named Devices. The determine reveals a snapshot of the Oberon desktop with
a number of overlapping paperwork. Each graphical ingredient on this determine, from the desktop to the smallest button, is a Gadget
itself. The Native PC Oberon System (now in beta growth stage) will function Devices consumer interface.

Fig. 2. The Oberon System Model 4 that includes a really environment friendly consumer interface consisting of tiled home windows. In addition
to a number of fonts and colours, the usual Oberon editor Edit helps “lively textual content components” resembling pull down menus and
hypertext folds. Figures, just like the one proven, may be edited instantly within the textual content the place they seem. Applications may be compiled
instantly from editor home windows.

This text can also be out there for obtain in GNUzipped PostScript format at

This text appeared in Computer systems in Physics, Vol 11, No. 1 (Jan-1997),
American Institute of Physics.

[ Home |
Site_index |
Contact |
Legal |
Buy_products |
OpenVMS_compiler |
Alpha_Oberon_System |
XDS_family |
ModulaTor |
Bibliography |
Oberon[-2]_links |
Modula-2_links |
Effekta_onduleurs |
General book recommendations ],
20-Mar-1999. &copy (1996-1999) Günter Dotzel, Wojtek Skulski.

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top