The connecting link at ETH between Mesa and Oberon was the Lilith workstation with its system software written in Wirth's Modula-2 (01977–01984).
As for Golang, the relationship is much more direct! The first public version of Golang is mostly a slightly modified version of Pike's Newsqueak, but at the point Golang became Golang, Pike was working with Griesemer and Thompson. IIRC Griesemer did his dissertation under Wirth at ETH on extending Oberon to parallel computers.
Wirth was twice at PARC. In his HOPL3 paper he writes in section 4 "From Modula to Oberon":
"As my sabbatical year at Xerox in 1976/77 had inspired me to design the personal workstation Lilith in conjunction with Modula-2, my second stay in 1984/85 provided the necessary inspiration and motivation for the language and operating system Oberon [29, 30]. Xerox PARC ’s Cedar system for its extremely powerful Dorado computer was based on the windows concept developed also at PARC for Smalltalk. [...] Thus the idea was born of gaining first-hand experience by designing such a modern operating system on my own, with Cedar as the primary source of ideas."
> IIRC Griesemer did his dissertation under Wirth at ETH
His supervisor was actually Prof. Mössenböck, the author of Oberon-2 (from which Go inherited its type-bound procedure syntax), see https://www.research-collection.ethz.ch/bitstream/handle/20....
Apologies for misleading readers!
I also find it remarkable that while Wirth refers to the windows concept and Smalltalk in the HOPL paper, which was written as recently as 2005, Cedar does not use overlapping windows at all, but rather - like the Oberon system - a tiling window manager; the Oberon user interface looks very similar to Cedar and has little resemblance to the Smalltalk-80 user interface.
"The designers of Smalltalk clearly wished to present not only a new language, but also a new paradigm, a new approach to programming. To be effective and convincing in this endeavor, they provided also a new terminology to underscore a different quality of programming. In this effort, record-structured variables became objects, their associated procedures became methods, a data type became a class, and calling a procedure is now termed sending a message to an object. This is denoted as object.method(message)"
It is interesting to note that "object.method(message)" has nothing to do with Smalltalk syntax at all (which supports my assumption that he had little to no personal contact with it). In his 1988 papers Smalltalk is just referenced as one of many OO languages, next to Simula 67, ObjectPascal and C++.
Interestingly his point (3) on p.219 (236/338) ("Within the text of a specific action procedure, a regional type guard is required to allow access to the state variables defined in the extension of the base type") was precisely Abadí and Cardelli's motivation for defining the ς-calculus. This limitation means that Oberon's type system is insufficient to statically guarantee the safety of object methods ("action procedures") and this is an obviously desirable thing. He mentions another similar limitation on the Oberon type system on p. 237 (254/338): "The fact that the compiler cannot check whether a message is ‘understood by the object’ may be an advantage or a disadvantage, depending on the type of the application."
I'd be interested to know as well. It might be worth writing him a physical letter asking about it. There is a mailing address for his department at ETH here (https://people.inf.ethz.ch/wirth/index.html) and I'm willing to bet they know how to forward him correspondence.
And a Go port of the RISC compiler: https://github.com/fzipp/oberon-compiler
I also remember reading somewhere that Wirth found Cedar too powerful, or complex, so Oberon was designed with the goal to be as capable as Cedar environment, while using a simpler language.
So not sure which kind of relation I would put them, besides being an inspiration.
What are the Oberon-2 features in Golang that aren't in Limbo?
I should have clarified the Squeak → Newsqueak → Alef → Limbo → Golang lineage, but from my point of view Newsqueak is already recognizably a version of Golang (and Squeak isn't.)
I think the emulator linked at the bottom left side is a better way to check out Oberon in action as you can easily (well, after you figure out how things get compiled, etc :-P) see it in practice and how a few individually simple (if not outright primitive) things can be combined to create something nice. For example i always found it amusing that the "menu bar" in each window is really just a regular text area and the commands shown are really methods that are called when you (IIRC) middle click them, like any other text in a window (so the main "GUI" for a program can really by just a text file with methods to click on - and of course since it is editable you can simply customize the GUI by editing the text file).
ETHZ researchers and Niklaus Wirth then iterated further on the Oberon (the OS) and Oberon (the language).
The definitive Oberon (the OS) version that still uses the plain Oberon (the language) from original project was System 3, which is what those videos relate to.
In Active Oberon used to write AOS (BlueBottle OS), you can still relauch System 3 as a nested OS.
Wirth created Oberon-7 largely by removing features[0]:
Revised Oberon (Oberon-07) is a revision of the original language Oberon as defined in 1988/1990. It is accepted by the compiler recently completed for the ARM processor. Most changes in the language might easily be called features of a dialect. However, there are a few that merit a stronger distinction, because they should be considered as permanent, and as corrections of unsatisfactory properties of the original Oberon. These are the elimination of the loop statement, function result specification, array assignments, constant parameters, and read- only import of variables. All changes were made in the interest of regularity, simplicity, completeness, and well-structuredness.
See also [3] for confirmation that Oberon-7 is the language of Project Oberon.
I'd recommend reading the papers on Wirth's personal site [2].
[0] https://people.inf.ethz.ch/wirth/Oberon/Oberon07.pdf (pdf) (15Jul2011 update)
[1] https://people.inf.ethz.ch/wirth/Oberon/OberonAtAGlance.pdf (pdf) (20Nov2013)
[2] https://people.inf.ethz.ch/wirth/Oberon/index.html
[3] https://people.inf.ethz.ch/wirth/ProjectOberon/PO.System.pdf (pdf) (2013)
It is hard to consider them forks, when they originated on the same department and he also collaborated in some form.
Component Pascal and Zonnon, those are proper forks.
While I admire Wirth's work, his goal to pursue a minimalist Oberon with Oberon-07 is not so interesting to me.
My pocket phone is more powerful than any Xerox workstation, why should we keep searching for such minimalist endeavours, instead of the rich development experience provided by them.
While it may not be interesting to you, it is what the linked project is all about.
Oberon 1.0 isn't what was the daily driver at ETHZ, beyond its initial introduction.
https://www.youtube.com/results?search_query=The+Oberon+Chan...
While Oberon was quite cool, people should also learn about its Xerox influence,
"Eric Bier Demonstrates Cedar"
https://www.youtube.com/watch?v=z_dt7NG38V4
Also dive into what happened afterwards, Oberon-2, Active Oberon, Zonnon,...
Active Oberon could be considered quite modern, also makes the distinction between safe and unsafe pointers, which improves the experience for low level coding.
https://github.com/metacore/A2OS
One of the best things about these systems is proving what systems programming with automatic memory management were capable of.
Given Oberon-2's influence on Go, maybe improving Fyne (https://fyne.io/fynedesk/) with something like gRPC for the dynamic experience, could be a possible sucessor.