Inferno notes

[liam_on_linux]

Plan 9 is Unix but more so. You write code in C and compile it to a native binary and run it as a process. All processes are in containers all the time, and nothing is outside the containers. Everything is virtualised, even the filesystem, and everything really is a file. Windows on screen are files. Computers are files. Disks are files. Any computer on the network can load a program from any other computer on the network (subject to permissions of course), run it on another computer, and display it on a third. The whole network is one giant computer.

 

You could use a slower workstation and farm out rendering complicated web pages to nearby faster machines, but see it on your screen.

 

But it's Unix. A binary is still a binary. So if you have a slow Arm64 machine, like a Raspberry Pi 3 (Plan 9 runs great on Raspberry Pis), you can't run your browser on a nearby workstation PC because that's x86-64. Arm binaries can't run on x86, and x86 binaries can't run on Arm.

 

Wasm (**W**eb **AS**se**M**bly) is a low-level bytecode that can run on any OS on any processor so long as it has a Wasm runtime. Wasm is derived from asm.js which was an earlier effort to write compilers that could target the Javascript runtime inside web browsers, while saving the time it takes to put Javscript through a just-in-time compiler.

 

https://en.wikipedia.org/wiki/WebAssembly

 

eBPF (extended Berkeley Packet Filters) is a language for configuring firewall rules, that's been extended into a general programming language. It runs inside the Linux kernel: you write programs that run _as part of the kernel_ (not as apps in userspace) and can change how the kernel works on the fly. The same eBPF code runs inside any Linux kernel on any architecture. 

 

https://en.wikipedia.org/wiki/EBPF

 

Going back 30 years, Java runs compiled binary code on any CPU because code is compiled to JVM bytecode instead of CPU machine code... But you need a JVM on your OS to run it.

 

https://en.wikipedia.org/wiki/List_of_Java_virtual_machines

 

All these are bolted on to another OS, usually Linux.

 

But the concept works better if integrated right into the OS. That's what Taos did.

 

https://wiki.c2.com/?TaoIntentOs

 

Programs are compiled for a virtual CPU that never existed, called VP.

 

https://en.wikipedia.org/wiki/Virtual_Processor

 

They are translated from that to whatever processor you're running on as they're loaded from disk into RAM. So *the same binaries*  run natively on any CPU. X86-32, x86-64, Arm, Risc-V, doesn't matter.

 

Very powerful. It was nearly the basis of the next-gen Amiga.

 

http://www.amigahistory.plus.com/deplayer/august2001.html

 

But it was a whole new OS and a quite weird OS at that. Taos 1 was very skeletal and limited. Taos 2, renamed Int**e**nt (yes, with the bold), was much more complete but didn't get far before the company went under.

 

Inferno was a rival to Java and the JVM, around the time Java appeared.

 

It's Plan 9, but with a virtual processor runtime built right into the kernel. All processes are written in a safer descendant of C called Limbo (it's a direct ancestor of GoLang) and compiled to bytecode that executes in the kernel's VM, which is called Dis.

 

Any and all binaries run on all types of CPU. There is no "native code" any more. The same compiled program runs on x86, on Risc-V, on Arm. It no longer matters. Run all of them together on a single computer. 

 

Running on a RasPi, all your bookmarks and settings are there? No worries, run Firefox on the headless 32-core EPYC box in the next building, displaying on your Retina tablet, but save on the Pi. Or save on your Risc-V laptop's SSD next to your bed. So long as they're all running Inferno, it's all the same. One giant filesystem and all computers run the same binaries.

 

By the way, it's like 1% of the size of Linux with Wasm, and simpler too.

 

Comments

Taos and Inferno

[dboddie]

It would be interesting to see Taos running somewhere, and also the source code for it. Given that the c2 article about it talks about object orientation, I wonder how that was exposed to high level programming languages. The archives posted to the stardot thread about TAOS are probably worth exploring. The Developers Edition looks like it might work in a suitably old Windows environment.

Inferno is a lot more pragmatic, I'd say, being in many ways an incremental update to Plan 9. In my experience, it's certainly simpler than other operating systems, but not necessarily simple unless you are playing at the same level as the Bell Labs folks. ;-) At least there's a book about it that covers how it works to some extent. I think the system is a good starting point for something else, perhaps, but it needs some updating for the modern world, of course.