

Oberon – The Overlooked Jewel [pdf] - urschrei
https://www.ics.uci.edu/~franz/Site/pubs-pdf/BC03.pdf
This article presents selected facets of Project Oberon, the latter of [Pascal creator Niklaus] Wirth’s two large system-level design efforts. The leitmotiv of this project was a quote from Einstein, “make it as simple as possible, but not simpler”. And if any further evidence was still needed, Oberon provided the conclusive proof for Wirth’s mastery of The Art of Simplicity.
======
sb
I tried Oberon once and have to say that it was way ahead of its time. Not
only did the author (of the linked paper) invent one of the first JIT compiled
systems, but also the ability to execute code with a mouse click (similar to
Rob Pike's ACME editor) is---for a systems programming language---still not
available today.

There were several novel research ideas tried for the Oberon system. I
remember there was some paper called "Active Text" that allowed putting videos
into code comments. (Probably that could have been done in Smalltalk, too.)

Finally, all of the books explaining details are heartily recommended. Wirth's
compiler book (referred to at HN several times) is a classic easy-going
introduction (the Oberon-0 grammar fits on only two pages IIRC! [1]), his
algorithm book (also available for download, also referred to multiple times
at HN) has some of the nicest descriptions that I did not find anywhere else
(showing a divide-and-conquer approach to computing the median [near the
Quicksort treatment]; plus polyphase sort, which might be useful again in data
centers), and finally the Project Oberon book contains some unique treatment
on system software that is not easily found anywhere else. For example, it
contains the details on what's called PieceLinkText, which is the (at least
AFAIK) best data structure to implement a text editor and it's operations.
(Predating rope-strings by a fair amount of time, too.)

edit:

[1]: just checked my own copy; Oberon-0's grammar actually fits on one page,
the full Oberon grammar fits on two pages!

[2]: URLs:

\- Compiler book: <http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf>

\- Algorithm book:
[http://www.inf.ethz.ch/personal/wirth/books/AlgorithmE1/AD20...](http://www.inf.ethz.ch/personal/wirth/books/AlgorithmE1/AD2012.pdf)

\- Project Oberon:
[http://www.inf.ethz.ch/personal/wirth/books/ProjectOberon.pd...](http://www.inf.ethz.ch/personal/wirth/books/ProjectOberon.pdf)

------
magoghm
The book "Project Oberon: The Design of an Operating System and Compiler"
[http://www.amazon.com/Project-Oberon-Design-Operating-
Compil...](http://www.amazon.com/Project-Oberon-Design-Operating-
Compiler/dp/0201544288/ref=sr_1_1?ie=UTF8&qid=1366902572&sr=8-1&keywords=project+oberon)
contains a detailed explanation of the design for the Oberon compiler and
operating system. Not only it is well written with clear explanations, but it
also includes the full source code for the compiler and operating system in
less than 550 pages!

I learned some interesting compiler techniques from reading that book.

------
_pmf_
The same (or a very similar) article can be found in the really, really great
book "The School of Niklaus Wirth: The Art of Simplicity", which is a
collection of high quality, highly entertaining essays about hardware,
software and general CS concepts.

------
TomMasz
Pascal was the first "real" language I learned (BASIC doesn't count) with a
compiler that ran on the IBM mainframe at work. From then it was an easy
transition to a Pascal compiler from Motorola that produced code for the
68000. Tellingly, the Motorola compiler had a bunch of extensions that made
programming a lot easier and mirrored the features Wirth introduced in
Modula-2. In some ways, learning C was a step backwards, although in terms of
my marketability it was absolutely necessary.

~~~
gecko
The 68000 was a wonderful CPU, and the last one that I genuinely enjoyed
writing assembler for. A sane number of registers, a very orthogonal
instruction set, good performance, non-segmented RAM, and high-level. If we
had to have a 1980s CISC chip be The One True ISA, I _really_ wish that 68000,
not x86, could've been it.

~~~
spitfire
Burroughs B5000.

Stack based instruction set designed from scratch for programmers (and
implementing high level languages). tagged architecture. Single cycle context
switching. It was also a secure architecture directly on hardware, tasks
couldn't even generate addresses to munge another tasks data if they wanted
to.

Wish someone would bring that back.

<https://en.wikipedia.org/wiki/Burroughs_large_systems>

------
smallegan
If you are from Michigan like I am you probably thought this was about beer
before clicking.

<http://beeradvocate.com/beer/profile/287/1094>

------
xradionut
I remember the the weeks I spent reading Wirth's book and learning about the
OS and language. Would be nice if Oberon had become a competing system
language to C, but it, the OS and the NS32K series of chips have faded into
memories of us original alternative OS geeks.

~~~
catenate
You might consider Limbo or Go as alternative system languages. Limbo is
bundled with the Inferno VM OS, which provides Acme, which is roughly a text-
only take on the Oberon UI. Go isn't the main systems language of any OS
(yet), but is more recent than Limbo.

~~~
xradionut
Limbo/Inferno/Plan-9 look to be almost as dead as Modula and Oberon. :(

Which is a shame, because the Imp of the Perverse programer in my dreams
always wanted to do low level coding in some other language besides assembly,
C or Forth...

~~~
gecko
If you just want to do low-level coding in a language other than those, the
Free Pascal project (<http://www.freepascal.org/>) is very much alive, and
very much none of the above. It's a nice, low-level language that also has a
very nice, .NET-like object system if you want to reach for it. (In fact, the
object system it has, modeled on Delphi's, was the inspiration for .NET's
system.)

(Note that both the Free Pascal project and its sister project, Lazarus, have
horrid websites that are not reflective of the activity or quality of either
product. In fact, the top post on the Lazarus website right now is about how
they need to fix the website.)

~~~
Roboprog
It's a shame Google could not have used FreePascal as the basis for Go,
instead of thinking that C-like structure had to be forced into the syntax
somehow "because it's familiar", even though Go clearly wants to be an
extension of Modula, and often must break away from C practices that just
don't work.

~~~
nimrody
Given that the language was created by ex-Bell-Labs researchers (Ken Thompson,
Robe Pike, Russ Cox and perhaps others), it is not surprising that the
language was modeled after C.

Overall the current popularity of C (in systems software) gives an advantage
to any language with similar syntax and semantics.

~~~
Roboprog
Yeah, they ganged up on the Swiss (U of Zurich) guy in the group, I guess (the
guy that worked on the JIT at Sun who also worked on Go).

God I wish K&R layout would just up and die already, at least in terms of
having function headers that span multiple screen widths. Personally, I like
having "end" keywords, and a bit more freedom in the layout. (mostly, I like
to be able to write one formal parameter per line in a function heading, and
to use "Whitesmiths" layout vs K&R)

Go feels much more like Pascal semantically than it does like C. I wonder if
there is any research to back up the decision to make Go look sorta, kinda,
like C, or if it was all ego and/or inertia.

------
nasmorn
One of my former coworkers took a job as CIO and inherited a huge application
written in Oberon. It is maintained by two brothers who charge exorbitant
amounts but since talent is very thin on the ground and they did a good enough
job there was not really anything anyone could do about it. I really hoped
this would happen to me when I started with rails but the the whole WHOOPS
video happened.

~~~
BruceM
Any chance that huge application has to do with video processing or something
similar?

------
praptak
The article feels incomplete, as are many articles that praise systems of the
past.

Why did Oberon become obsolete? I suspect we could learn a lot from an answer
to this question.

~~~
keenerd
That is simple. Oberon was a full-stack environment. Where full-stack means it
typically provides OS-like and filesystem-like elements. Where as a mainstream
language such as Python molds itself to the existing OSes, Oberon tries to
take on the whole thing.

These have a history of failing. Not because they are poor at some aspects of
being an operating system. But because they force a programmer to give up all
their tools. You can't typically use your favorite source control or text
editor. (This is getting better as VM interoperability improves.)

So Oberon shares the same fate as other full-stack languages like Smalltalk
and Forth. (I'm sure you can think of a few.) Awesome at what they do, but
never gains traction.

~~~
xradionut
Forth isn't suitable for large systems or large teams. And Smalltalk has a
"image" problem.

~~~
fusiongyro
The Smalltalk image problem is basically the same as the Oberon full-system
problem. They have the same undesirable consequences.

~~~
igouy
Have you used Smalltalk?

~~~
fusiongyro
Yes, and I like it.

~~~
igouy
In that case, please say specifically what you mean by "the same undesirable
consequences".

~~~
fusiongyro
What we're all talking about here is that Oberon, Smalltalk, Forth, etc. all
live in obscurity. Having an image seems to spell doom for wide adoption.
People like to integrate systems with their other tools. Smalltalk can examine
the outside system, but (except for oddities like GNU Smalltalk) the outside
system gets a completely opaque box it can't do anything with. One could argue
that ZODB had the same consequences.

I don't think there is a _technical_ problem with images (which I think is
what you're hoping to pounce on and debate ad nauseum), they just demand the
rest of the ecosystem be built around them. This seems to be a trick you can
get away with once per computing industry. Lots of people have come up with
better image structures/concepts than hierarchical blobs of binary data, but
they never seem to get significant traction because they are closed.

~~~
igouy
> what you're hoping to pounce on

I'm just trying to untangle the different things you might be talking about -
whether you're talking about development tools or run-time monitoring tools?

------
no_more_death
Yeah, in high school in the early 00s I was a big Oberon fan. I had booted the
system from diskette on my windows computer. I also had Blackbox and built
some really basic things. Overall it was a huge amount of fun, and I have fond
memories of the Object Inspector and connecting references together on forms
and stuff. It was really Brett Victor's "tangled" before Brett Victor came
along with these ideas. Actually, it was a lot like hypercard, based on what
I've read of hypercard. LayLa was a cool layout system kind of like flexbox.
They had a lot of cool applications. The flat filesystem was weird (no
directories), but it was certainly simple.

Over time it was so disappointing, though, that the system never went
anywhere. My biggest takeaway was to not be such a programming language
purist. Now I'm a javascript fan. It's not pure or perfect, but it's simple
and it nails the important things. Plus for the foreseeable future it's the
most widely supported computer language in existence. Simplicity and
pragmatism are really key.

------
gecko
So, let's say I wanted to take a spin in Oberon today. Is that even still
feasible, or is it just dead? I can't tell what I'd download to get started
from the ETH Oberon page, nor do I have any idea what the library and
development community would look like at this point.

~~~
bpsm
A2 (nee Bluebottle) is the successor to Oberon, but remains compatible in the
sense that you can run the classic Oberon System 3 as an application within
Bluebottle.

<http://bluebottle.ethz.ch/download.html>

(My Eyes! The goggles do nothing!)

You could probably boot the ISO image in a virtual machine (VMWare or such).

There's a version of Bluebottle that runs as an application on Windows. Here
(A2.r4701.zip):

<http://www.ocp.inf.ethz.ch/wiki/OCP/WinAos>

A few things to note:

(1) unpack the zip file (2) Open a2\WinAos\Aos.EXE

Note that Aos.EXE will run full screen. There's no obvious way to minimize or
hide it, but you can Ctrl-TAB back to another program.

The system log is displayed by default near the upper left corner of the
screen. You'll want to close this as Oberon and Aos can not both be managing
it at the same time.

(3) Close the System log by clicking the red button in the upper right corner
of the System log window.

You'll see a palette of buttons in the lower left corner of the screen. We'll
be using that to start Oberon.

There are two ways to start the hosted Oberon: full screen or within an Aos
window. Since we're here for Oberon, we'll start it full screen.

(4) Click "Deveop" in the top row of buttons. (5) Click "Oberon FullScreen"
which is revealed as the left-most bottom-most button.

To exit Oberon click "Quit" in Popups.Tool and choose "Shutdown".

To exit Aos click "System" and then "Shutdown" on the button palette in the
bottom left of the screen.

Happy exploring!

~~~
gecko
Thanks! Perfect. That's enough of a tutorial I can poke around.

------
gl
Oberon/F was used as a teaching language during my first semesters of CS. At
the suggestion of Sun's marketing department, Oberon and it's accompanying
textbook were replaced by Java™ 1.0. For me that's what happened to
programming in Oberon. Fortunately, Blackbox is very well documented and even
without a command of its language you can still appreciate many of the elegant
gems it Guards just by reading Blackbox in Blackbox . I really enjoyed the
article especially learning the bit about how Wirth measured a compiler's
quality.

------
MaysonL
For an open source version of Oberon which will run on Windows, and with
Darwine on OS X, see <http://oberon.ch/blackbox.html>

------
guard-of-terra
But is it really that good today when we have Ruby, Scala, Go, Clojure and
stuff? What are selling points today? Or is it a purely historic thing?

~~~
xradionut
Read the article or the Wirth's original book. Wirth and his colleage had some
original ideas about programming languages, operating systems and user
interfaces that were revolutionary for the day. They even built their own
workstations from scratch to run them on.

------
lennel
we were taught oberon at varsity. twas fun.

------
rcfox
I had to write a compiler for a subset of Oberon in second year. I wasn't
terribly impressed with the language itself.

------
xtraclass
Thx, very interesting!

