When you are done praising Plan 9, head on to Inferno and Limbo, which are actually the last OS developed by the authors at Bell Labs and contain the genesis of Go.
Not trying to disparage but: how is Inferno a complete break from Plan9 ? I mean there's some fundamentally breaking changes (it's just(TM) a VM, the language is brand new) but I don't feel like they're the kind of changes that revolutionized the way we do computing compared to Plan9, the way Plan9 did over Unix.
Now of course that doesn't mean Inferno doesn't have its own merits: limbo is a probably an important step towards the kind of programing that Go enables
It is more like a Limbo copy cat, with a bit of Oberon influences.
As strange as it may sound, UNIX folks were Oberon fans, hence why ACME in Plan 9 had a similar developer workflow as the whole Oberon UI, where clickable text is combined with dynamic UI actions.
Plan 9 failed short of using a userspace systems language as C's successor (see Alef[0]).
Plan 9's sucessor, Inferno, fixed this with Limbo [1], where C is only used for the kernel, disVM, and a couple of userspace libraries, everything else done in Limbo.
Go ends up being a mix of Limbo, Oberon-2 method syntax and SYSTEM package.
However one thing that both Limbo and Oberon based systems have, and Go misses out, in how the whole platform embraces dynamic linking to extend existing applications, and surface operations to the UI.
By the way, I advise wasting a couple of hours diving into Inferno and Limbo's manuals[2],
Plan 9 and Inferno are very related, but I wouldn't say Inferno is "Plan 9 rewritten in Limbo", nor is Limbo equivalent enough to Go for the comparison to make sense.
First, the Inferno kernel is written in C, not Limbo, and is somewhat similar to the Plan 9 kernel to the point that is moderately feasible to port drivers from Plan 9 to Inferno.
Second, you could say acme was rewritten from alef (not C) to Limbo, and maybe you can say cat, tail, mk and yacc were "rewritten in Limbo", but soon after the list ends. Most utilities are genuinely new utilities that make use of the different abstractions provided by the operating system. Of course there are lots of high-level similarities, but they are quite different programs.
This brings me to my next point, the abstractions provided by Plan 9 and Inferno are very different. Different enough that a new set of tools makes sense. For comparison, rewriting C code to Go uses the same underlying abstractions, so it doesn't make as much sense.
Another point I want to make is that compiled Limbo programs are extremely small, and Limbo is dynamically loaded, unlike Go.
Yet another point is that Limbo programs use reference counting plus a real-time garbage collector for cycles, which is made easier by Limbo and Inferno constraints. Go uses neither and the language is different enough to prevent a real time garbage collector.
While Plan 9 is cool and such, I prefer what they built afterwards with the lessons of Plan 9, while trying to compete against Java and Sun.
Inferno and Limbo, which tend to be ignored with too much focus on Plan 9, a middle stop in their whole experience designing OSes and programming languages after being done with UNIX and C.
They're two independent projects and architecturally quite different (what with the Dis VM being king in Inferno), even though the 9P protocol and much of the Plan 9 userland was reused.
Plan 9 never used Limbo natively from what I know. Only C and Alef. Limbo was ported to it, however.
Consider this, the authors have fixed some of the Plan 9 design errors including the demise of Alef, by creating Inferno and Limbo (yeah it was a response to Java OS, but still).
Where C is only used for the Inferno kernel, Limbo VM (with a JIT) and little else like Tk bindings, everything else in Inferno is written in Limbo.
Replace Limbo with AOT compiled Go, and that is what systems programming is in the minds of UNIX, Plan 9 and Inferno authors.
What was the exact relationship between Inferno and Plan 9? The documentation said it was "influenced by". Did it share code? Was Limbo used anywhere in Plan 9 (which I assume was written in C)?
Inferno was Lucents answer to Sun's Java and was intended as a commercial product. They stopped all Plan 9 development for a year to work on it. The big difference and attraction to me are the pure VM user space and the dual build path where you can build it for bare metal or hosted on a number of operating systems (Plan 9, Windows, BSD, Unix, Linux, web browser, etc.) That way you can run Inferno applications just about anywhere (even microcontrollers). The Limbo language is part of Go's lineage as well: https://seh.dev/go-legacy/
Go at its base is a fusion of Limbo and Oberon-2.
reply