There is an inferno with lua project, on this theme; see https://news.ycombinator.com/item?id=9704517

I think you are the first person I've seen speak highly of Inferno. I've played with Plan 9 from time to time, so if you have a moment, can you tell me what you like about it?

Sure, are you aware of Inferno's web site?

http://doc.cat-v.org/inferno/4th_edition/

It contains quite some useful information, including the book "Inferno Programming with Limbo" http://doc.cat-v.org/inferno/books/inferno_programming_with_...

Being a security oriented developer, I like that they decided to use a managed language for the whole userspace (Limbo) leaving C for the kernel and compatibility with UNIX software.

Basically, the distributed computing ideas and Oberon influences from Plan 9, merged with type safety.

In a certain way, what Android came to be, almost 20 years before it existed.

Do you see a difference between a "managed language" vs. isolation (by means of containers and/or VMs).

Personally I don't; meaning it should be as good to run software in a jailed environment and not force the choice of language on developers.

I am curious to see what others think of this, though.

I see a difference when the language doesn't provide mechanisms to enforce program integrity.

With a type safe language, being used alongside isolation mechanisms, I get two layers of protection, at language level and at the sandbox level.

Like Android or ChromeOS do with their managed environments + Linux SE and on Samsung's case Knox.

If the language is unsafe, everything outside the jail might be safe, but the program integrity or the data inside of the container are exposed to the attackers.

If I get RCE in your mail client I read your email. Not letting me persist doesn't help much more.

How does the choice of language prevent that? Sure different languages might make that harder, but I don't know of many that don't allow arbitrary code, written by a random developer, to execute poorly defined HTML parser to possibly exec some hostile code.

There are facilities and standards in most languages to help prevent this, but can you point out why this is not possible in Limbo? I'm not personally familiar with it.

Sure preventing logical errors is hard, but it is already an improvement that typical C errors aren't possible.

Limbo does not support this, but both Java and .NET allow for security control at class and method level, however they tend to be misunderstood by most developers, which don't regularly use such features.

Inferno is cool.

I agree 100%. I do wonder if the Dis VM is a close enough match for Go as a target. Or perhaps we could start with a simple Go to Limbo translation transpiler. Want to see if it's possible?

> I do wonder if the Dis VM is a close enough match for Go as a target

obviously you would call this DisGo and the resulting system would be DisGo Inferno

Better just call it Dante or Dante's.

It's clever, but "Dante's Inferno" is one of the few names more difficult to google than "go"

You would google for golang

But this would need a Go with generics and polymorphism then. PolyGo or such. For simple server stuff Go is enough but for a dynamic VM with dynamic objects not.

Can you elaborate on your thoughts here? If you just wanted to target the Dis VM using Go as the starting point, I believe you could call most everything in the standard libraries.

That would be nice, but I'd probably prefer to have a UI that I could use without a three-button mouse...

Then you can either settle on Windows or OS X, I guess.

My X Windows is a bit rusty, but I remember most managers use all three buttons.

Most modern managers don't, or at least do not assume you have a middle mouse button.

The real issue for me is laptop trackpads. It's impossible to use Plan 9 (or derived works) with one in a natural fashion.