Inferno: A small operating system for building crossplatform distributed systems | Hacker News Reader

Inferno: A small operating system for building crossplatform distributed systems

vitanuova.com

93 pointshemloc_io50 comments

Open articleView on HN

Inferno is the 'successor' to / a descendant of Plan 9:

* https://en.wikipedia.org/wiki/Plan_9_from_Bell_Labs

* https://en.wikipedia.org/wiki/Inferno_(operating_system)

And the predecessor of Golang.

That would be Limbo, and the language is called Go.

Yup.

I don't know if you've noticed, I try to be careful to include enough context in my comments to disambiguate multiple candidate meanings, and "Go" is not specific enough.

Go is more than specific enough, unless you go writing the name in lowercase.

Take it up with the people who named the golang-nuts and golang-dev mailing lists, then.

That is not the name of the programming language.

https://en.m.wikipedia.org/wiki/Go_(programming_language)

I don't see people saying Dlang, Clang, Javalang, C++Lang, Rustlang, Swiftlang,....

According to the frequencies of the British National Corpus, "go" is the #99 most common word in English before lemmatization. "Swift" is #5734, about 75× less common. "Rust" is #14616 ("rusty" is only #11333.) The letter "C" as a word by itself is #548, 6× less common than "go", though the BNC was compiled recently enough that its corpus included references to the C programming language and also to C++. "Java" is #19574, 500× less common than "go".

"D" is #1033, and https://en.wikipedia.org/wiki/D_(programming_language) begins, "D, also known as Dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001." I commonly see people resorting to elocutions like "Digital Mars D" or "D, the programming language" to clarify.

As you surely remember, when C was 13 years old (like Golang is now), it was common for people to write things like "The 'C' programming language" too. (Though not, of course, in Bell Labs or CSRG.) Most programmers only started calling it "C" without any additional qualification after it became the one and only language in which all serious software was written, something that will never happen to Golang.

Also, Golang is the second programming language to be called "Go", though the other one was much less popular.

Also, "go" is the wrong part of speech, so it induces parsing errors. This is a problem with the game too.

So, objectively, saying "Go" is 0.7–2.7 orders of magnitude more likely to cause confusion than your other examples. It's unfortunate, but that's the way it is. I'm just glad they didn't try to name the programming language "Of". Or "The¿", or just ",".

Pulling back a bit, why do you think it's good to "correct" the word usage of strangers on the internet who haven't asked for your advice? If you see a road sign that says "NO THRU TRAFFIC" do you get out your paintbrush to correct it to say "THROUGH"?

And, from the other perspective, you're recommending that I defer to your expertise on English prose style. Why would someone do that? Have you written something that is regarded as an exemplar of English prose style? I have a lot of respect for your technical expertise from your HN comments, but I don't have you mentally tagged as a Brian-Kernighan-caliber writer, much less an Ursula-K.-Le-Guin-caliber writer. Change my mind!

Otherwise, just be glad I don't call it "Issue9".

The language is called Go, no matter how you happen to try to turn the tables around.

You're free to call it whatever you want, but different choices will have different effects. If you prioritize looking hip, for example, sometimes you will sacrifice clarity of communication.

As a go player and reader of the "computer go" magazine, I disagree.

Google does not care, and I should note that you wrote both go in lowercase.

It is a pity that only Plan 9 gets most of the attention in hacker circles and its successor is mostly ignored.

I think it is so because the original license sucked. They have changed it to MIT just in 2021

That's partly because many of the core ideas behind Plan9 have since been partly reimplemented in more common OS's like Linux or DragonflyBSD. That's the whole point of a research OS, after all. Inferno has yet to go through that step.

Android, Windows Phone, ...

I think it is worth noting this is more "historical" and seems a somewhat dead project now, quite a few of the links are dead, download page last updated 2015, the repo hasn't really had an significant commits for over a year.

"Host Operating Systems: Windows NT/2000/XP, Irix" ... "As a demonstration, Inferno also ran as a plug-in under Internet Explorer version 4."

I would be more interested in the back-story behind this. Why did the creators of Unix think this would be a good way to take on the Java juggernaut? They had a language, Limbo, a lot like Go with a bytecode interpreter a lot like JVM. What was it for?

I guess it was just a competitor? One time they even had a crosscompiler to run Limbo on the JVM

Does anyone know of any similar active projects?

Two great blogs about actually using and improving Inferno (the relevant posts are 5-10 years old, though):

Inferno programmer's notebook by Caerwyn Jones: lots of experiments with detailed descriptions and code. The entire blog is really thoughtful actually: https://web.archive.org/web/20200519122543/http://ipn.caerwy...

The author also provided Acme-SAC, stripping Inferno to a barebones VM that only runs the Acme editor and the shell: https://github.com/caerwynj/acme-sac

The other blog is Pete Elmore's Debu.gs. Using Inferno for real work, etc. A really well written blog, too: http://debu.gs/tags/inferno

Also worth noting are mjl's repos, he wrote a lot of code to improve Inferno for real-life usage. Possibly all of them are linked in this extensive list: https://github.com/henesy/awesome-inferno

I personally really liked Inferno's shell.

My professor, Brian L. Stuart, was Inferno enthusiast and wrote a great small book on how it all works (We used it for class.) if you've read all of these his book might be interesting.

https://www.amazon.com/Principles-Operating-Systems-Applicat...

(It's also pretty easily available online if you cannot afford or find the hard copy.)

Also worth a read regarding Inferno's influences,

"Oberon, Plan 9 and Inferno"

https://blog.tsr-podcast.com/index.php/2021/05/13/episode-76...

Here it is running on a Nintendo DS https://www.gamebrew.org/wiki/File:Infernods2.png

What a blast from the past. I was at Murray Hill around that time and remember the "Inferno" posters everywhere. It seemed like a legit project with some real corporate backing. From what I understood it was hoped to be used as a router OS in the core routers they were developing there.

One of my wild ideas was to use my own port of the Dis virtual machine to program cross-platform games using Limbo, which I find very pleasant lang to use, honestly, and a custom graphics library.

Sadly, life happens and I'm still in the process of giving form to my idea with my half-baked emulator[0] :-)

[0] https://github.com/luismedel/sixthcircle

This is the project that people actually should wonder about instead of always stopping in Plan 9, a middle stop.

> By using one standard protocol for all network communication, security can be focused on one point and provided at a system level. Inferno offers full support for authenticated, encrypted connections using a certificate based user identification scheme and variety of algorithms including:

> IDEA, 56 bit DES, 40, 128 and 256 bit RC4 encryption algorithms MD4, MD5 and SHA secure hash algorithms

Seems ambitious but quite antiquated already. The site reminds me of TempleOS for some reason.

It seems antiquated because it was released in 01996 and hasn't been updated much in 20 years.

I've never seen years in octal before :)

If you want to be extra obnoxious you can do something like: 820458671

Nothing more fun than converting epoch times.

Heh, you must think Inferno is pretty old!

it is. it was the better java those times, but didn't have such a big backing as from Sun.

If you interpreted "01996" as octal, you'd think it came out 829 years before Java.

Unless you mean the island.

> Inferno applications are written in Limbo®, a modern, safe, modular, concurrent programming language with C-like syntax. It is more powerful than C but considerably easier to understand and debug than C++ or Java. It is easy to express the concurrency in the physical world directly in Limbo's syntax. Any Inferno application will run identically on all Inferno platforms.

I was amazed by what a great idea this is until I got here. You have to use a special snowflake programming language.

This is the same thing that turns me off from Google's Flutter. You have to use Dart, a language not used anywhere else.

It's not that these languages are bad. They may be fine, even great. It's the cognitive load of learning yet another language. For it to make sense this language would have to be quite a bit more productive or otherwise better than Go, Rust, C++, JS/TS, Python, Java, etc. Otherwise just let people use languages they know. It's not that hard. We now have WASM which can be targeted by all of those either directly or indirectly.

Limbo is from 95 java is from 96 js from 98, go and rust from 20xx something, and dart is made from the ground up to be compile to multiple plataforms, I wish they make kotling in the same way to be onest but I can't say is dumb flutter apps are fast in comparison to react native becouse they don't need a virtual Dom in the process

Java first release was in 1995…

The Limbo language predated Go by over a decade, and is, in fact, a predecessor of Go. I think its creation and use in this system makes more sense in the context of 1995 when it was initially created.

Yeah, they both share Rob Pike and the Bell Labs heritage.

Weird side note: Renee French did both the Plan 9 and Go mascot designs as well.

https://go.dev/blog/gopher

And to the further above, there are other languages and compilers supported on Plan 9/Inferno. Like Go.

Well she is married to Rob Pike…

And Penn Jillette knew both of them and introduced them to each other.

Source: Penn's radio show where Rob and Renee were each guests at different times.

Golang and Limbo share a lot more than that!

I don't suppose there's a web page / article / etc that spells some of this out, is there?

When I try searching for "golang" and "limbo X" (where X = history, or comparison, or..., or...) it looks like the popularity of golang swamps any pages that might compare Go and Limbo.

https://swtch.com/~rsc/thread/

https://spf13.com/presentation/on-the-shoulders-of-giants/

https://seh.dev/go-legacy/

Thanks!

I built a computer with its own languages, and I consider it to be _less_ cognitive load when everything is in 1/2/3 languages. I don't have to worry that the next program I want to read the sources will require "Go, Rust, C++, JS/TS, Python, Java, etc."

There are other metrics to consider besides your notions of cognitive load and productivity. Inferno predates most of the languages on your list. My computer (https://github.com/akkartik/mu) uses custom languages because I was able to design them to minimize total LoC, and to ensure the dependency graph has no cycles (unlike all of the conventional software stack, at least until https://www.gnu.org/software/mes connects up all the dots).

> For it to make sense this language would have to be quite a bit more productive or otherwise better than Go, Rust, C++, JS/TS, Python, Java, etc.

Concurrent programming languages are quite a bit more expressive and therefore productive for distributed systems than the languages you listed. Go, Rust, C++ JS, Python, Java etc. are all imperative languages with sequential semantics. Writing concurrent programs in these languages is much harder than using a specialized language. There's a reason Erlang and BEAM is preferred by many to write distributed systems as opposed to C++.

Languages designed with asynchronous, distributed, parallel semantics from the ground up allow a higher degree of expressivity when it comes to distributed systems. Obviously you can write anything you want in imperative languages, but the semantics really work against you to the point where concurrent programming is generally considered "hard" by users of these languages. It really don't have to be that hard, or at least not any harder than sequential programming.

I would say if you only know the languages listed, then learning a concurrent languages would expand your mind rather than burden it.

If language is half decent I personally do not feel any cognitive load of learning and using it (excluding brainfuck like things of course). I do not change language for the heck of it because I am a vendor / custom product developer and need to see financial reasons first, yet it happens often enough

> Portable programs: Inferno programs are written in the type-safe language Limbo and compiled to Dis bytecode, which can be run without modifications on all Inferno platforms.

The point is that this and similar operating systems have sufficiently different (and better) security models that extend to the virtual machine level, which makes creating a new languages that are compatible with them necessary. Other languages could be (re)written to compile to the bytecode, or at least live in emulated environments within the safe zones.

Our current operating systems, virtual machines and languages are laughably insecure, whereas these advanced systems can give the programmer and user more control over and guarantees about the behavior of these systems.

If we keep using the current models, we'll have to keep using and building domain specific languages, container protocols, browser sandboxes, mini-vm's, all kinds of incompatible and stacked interfaces, whereas well designed systems recursively nest sandboxes gracefully.

Resource (e.g. cpu time, memory space) and access security have been utterly neglected in currently popular languages, which will haunt us again and again until we finally learn better. Newer systems like WebAssembly are starting to begin to consider at least the latter, where a program can be isolated in a sandbox with a well defined and airtight interface.

https://medium.com/agoric/pola-would-have-prevented-the-even...

https://github.com/void4/notes/issues/41

https://en.wikipedia.org/wiki/Inner-platform_effect

Reply on news.ycombinator.com