Hacker News Reader

There have been plenty of new OSes and computing paradigms over the years, a plethora of them. They weren't 'killed', they just never got any traction. The interesting question is why that is.

Unix at it's core tries to be as simple an interface to the hardware as possible, and as un-opinionated as possible. It's written in a language that is a thin layer of syntax over assembly. Files are arrays of bytes. Most devices just look like files. It imposes the absolute minimum of abstractions over how these things are implemented in hardware.

Alternate OS designs are generally far more opinionated. File systems are either relational or object databases. Networks and machines are abstracted away so you don't even know they're there. Lots of fancy virtualisation. The problems are many. First of all this imposes a cost in resources and performance on even the simplest applications. Second these things are best thought of not as operating systems, but as applications. They're providing services similar to those of Oracle, or Hadoop, or VMWare, etc but you don't get to choose which implementation you want, you get the particular combination of ones provided by the OS and either like it or lump it.

The minimalism of the base Unix layer is it's superpower. Whatever additional services you want on top is fine by Unix. That's why it makes a great underlying layer for the Mac, iOS and Android. Even if you do want to build an opinionated high level system, why not build that on top of Unix? We don't need a workmanlike unopinionated new base layer OS that provides efficient access to hardware resources, and nobody want's to write one. They want to write high level fancy abstraction-laden half-OS half-application monstrosities. STOP! You're not writing an OS, you're writing an application. Even if anyone does want to write a lean efficient base OS layer nobody cares, because we already have Unix.

Unix was a relatively simple (but not minimal) base layer around a 1970s minicomputer architecture, one with no networking, no graphics support, and dramatically constrained storage, with users on text-only terminals.

It is a very poor fit to a single-user personal workstation.

If you think that all other OSes are more complex, then I suggest that you investigate the fairly rich space of other OSes designed for single-user workstations.

Notably, I urge you to study the 1980s and then 1990s successors to Unix from Unix' own creators:

Plan 9, for networked graphical machines.

Then Inferno, for whole heterogenous networks of machines with dissimilar CPU architectures.

In parallel non-Unix spaces:

If you have a Raspberry Pi, try RISC OS. It's a single-user, fully-graphical, internet-capable multitasking OS whose core fits into about 6MB. I ran it in the 1980s on an ARM workstation in 1MB of RAM.

Also Niklaus Wirth's Oberon Project, which is an entire multitasking single-user OS with a tiling-window interface in a type-safe language, which is about the size of a very basic Linux console text editor such as nano.

And its successor A2, which is a little bigger (but still smaller than, say, Vim) which has a full GUI, is SMP aware and can just about access the WWW.

For networked use, perhaps read up on Novell Netware. Arguably the peak was Netware 3.11 but Netware 4 is also instructive. In its day it had a performance advantage over the best-tuned competition of around 4 digits in percentage, i.e. it was around 10x-30x faster than any rival UNIX of its time at what it did.

For the space of supporting dissimilar CPUs in a single binary, look into Taos and its successors Elate and Intent.

There are a lot of OSes out there that make even 1980s UNIX look bloated and over-complicated.

> Plan 9, for networked graphical machine.

Oddly enough, I quickly googled, and it seems AT&T decided to target the embedded market with Plan9 which feels like a bit of an weird niche to put it.

There’s no way I can see a new operating system dethroning the NT/*nix world at least not without somehow catching up to decades of hardware no one but those two support.

9front is still alive and maintained, and there are two forks that I know of, Jehanne and Harvey.

Inferno has been ported to at least one smartphone.

Both run natively on certain models of Raspberry Pi.

Another strategy is what OpenVMS is doing initially: there is a single model of reference hardware, but the initial version 9.2 now available runs on and supports Xen, KVM, VMware and Virtualbox. Hyper-V is coming in 9.2-1.

But the real question is: should it support decades of hardware? Why, if it's something new, doing something different? Perhaps it only needs to support its own hardware, and if it proves viable, then additional models and support can be added?

I did a Fosdem talk on this general idea, and it's been a recent HN discussion. The title was "Starting Over". You might find it interesting.

> If you think that all other OSes are more complex, then I suggest that you investigate the fairly rich space of other OSes designed for single-user workstations.

The problem with a lot of these alternate OSes was that they were still too opinionated. Plan 9 tried to abstract away individual computers and impose a particular approach to sharing resources. Oberon was as you say type safe and object oriented and tied to a particularly peculiar Ui paradigm. Netware was barely an OS, really just a highly optimised network file system.

Tellingly a lot of the services and applications that were parts of these OSes made their way into Unix. That’s because these were application level services that had been tied into the OS at a low level. Too opinionated. If you wanted to access compute resources using a different model to Plan9, then Plan9’s implementation got in your way. If you didn’t want to run software using the Oberon language, the Oberon OS got in your way. If you wanted to do something other than access files using the Netware protocol, Netware got in your way.

To the extent any of these OSes were simpler or easier to develop on than Unix, their advantage simply wasn’t enough of a win to make it worthwhile.

That’s the historical argument though. For the forward looking situation, there is a lot of interesting work being done but it’s all at levels above that of the OS. Network services, storage systems, programming paradigms, resource abstraction. There’s plenty of innovation in these going on, it just doesn’t need to be done as something baked into a new underlying OS. There’s nothing wrong with building it as a service on top of Unix.

I think they only look to opinionated if you happen to primarily know and be familiar with Unix's opinions. :-)

I personally was not.

Unix was the about the 8th OS I learned when I was in my teens, and I still find it highly "opinionated" and not very comfortable to this day.

Not everything is a file, it only pretends that. Lots of things aren't.

Some things are case-sensitive, unless they're not.

Files don't have extensions unless they do, in which case they might be critically important, or they might not.

Programs communicate over console IO and pipes, unless they don't.

Command line switches can be a letter or a word or a phrase, might have a minus in front, might have two, might have none: do ya feel lucky, punk?

Standard UI? Don't make me laugh. It's as bad as DOS was in 1987.

It's a mess, and every successive version is worse not better.

Most of those things really aren't part of the OS as such, they're just applications. Command line tools and UIs for example. They're just utilities, they don't matter at the level we're talking about here, about the operating system as a platform for developing and running software. You're complaining about the software people run on it, not the base layer of the OS itself.

This is what I'm trying to point out, too many other OS projects rolled abstracted services into the base layer of the OS in order to make things easier to develop applications. That was a mistake because it tied them to particular implementations of those services.

I disagree.

In fact I'd go so far as to say that none of those things are applications.

But one of the problems of discussions about concepts and philosophies in computing, I find, is that people are very wedded to their ideas and will eagerly redefine them on the fly in an attempt to defend them.

So, for instance, I think that a fairly useful example of what counts as "part of the OS" today would be, for instance, what comes along with the OS on its installation medium. And to dodge questions of who-wrote-what, let's say that as an example let us talk about, say, FreeBSD or OpenBSD. They are the products of single teams of people, unlike any Linux distro.

I installed FreeBSD as recently as yesterday, as research for this article: https://www.theregister.com/2022/05/20/freebsd_131/

And as the piece mentions, OpenBSD in April, for this one: https://www.theregister.com/2022/04/22/openbsd_71_released_i...

So they are recent, they are current versions, and can reasonably be described as two of the most complete modern versions of UNIX that are the products of single teams.

Excluding Firefox, for example, as being manifestly an external component, albeit a FOSS one that can be installed directly from either OS's repos.

Both come with an X.11 server as a standard OS component. That is not an application. Both offer Xfce as a standard desktop. That too is not an application.

An X server is every bit as much an OS component of 21st century UNIX as is `awk` or `sed`. It is not 1974. We are not using PDP-11s any more.

Tell me, can you pipe things to an X server? Can you usefully pipe its output to another program?

I don't think that you can. And that, I submit, blows clean out of the water all the high-minded stuff about the conceptual purity of UNIX.

> That is a very good question! What we have now it's a bunch of old operating systems, no novelty, no new computing paradigm.

Entirely false, if you have kept up with the state of the art in operating systems.

Many still expose their old APIs by necessity of course, but the internals have undergone leaps and bounds improvements and new APIs and functionality are added all the time.

Hate to use a car analogy but just because you have a car called Corolla and has a steering wheel and pedals, does not mean it has had no meaningful advancements since this https://global.toyota/pages/corolla50th/history/era/01/image...

I agree completely. Just look at io_uring and PowerShell, to name some examples.

io_uring totally rethinks the notion of a "syscall". It is going to eat the world, and most of us are not even going to realize that it happened.

PowerShell is a really cool example of re-imagining input and output. Namely, it is record-oriented ("Object") rather than byte-oriented. No more stringing together chains of fragile "awk" commands to make pipelines do what you want. (I know there is prior art here)

If you think OS's are moving still, then you're the one stuck.

Just lots, wherever you look. io_uring and eBPF are the new hotness, but we've had operating systems scale up from a few CPUs to hundreds or thousands in the past few decades, we've had filesystems like ZFS and BTRFS with checksums and snapshots and versions, there's namespaces and containers, hypervisors built into the OS and paravirtualization, multiqueue devices with command queue programming models, all sorts of interesting cool things.

Before someone jumps in and says we've had all these things before, including io_uring and eBPF (if you squint) and scaling to hundreds of CPUs and versioning filesystems etc. That is true. IRIX scaled on a select few workloads on multimillion dollar hardware and even that fell in a heap when you looked at it wrong. The early log structured filesystems that could do versioning and snapshots had horrific performance problems. IBM invented the hypervisor in the 1960s but it was hardly useful outside multimillion dollar machines for a long time. Asynchronous syscall batching has been tried (in Linux even) about 20 years ago, as have in-kernel virtual machines, etc.

So my point is not that there isn't a very long pipeline of research and ideas in computer science, it is that said long pipeline is still yielding great results as things get polished or stars align the right way and people keep standing on the shoulders of others, and the final missing idea falls into place or the right person puts in the effort to put idea into code. And those things have been continually going into practical operating systems that everybody uses.

Unpopular opinion but the answer should be self-evident and has little to do with technical merit: cheap and just barely good enough beats expensive and better every time. And Linux is free as in beer. It's not unlike reports of how generous food donations to poor countries bankrupted local farmers; it's impossible for a wannabe new OS vendor to afford to pay its engineers long enough for their OS to gain traction over the incumbents, particularly when one of them is free.

The only two options I see are either one of the FAANGs spend the billions necessary on the long, hard slog to push a next generation OS until it takes off or another person of Linus Torvalds' stature pops up out of nowhere again to build an OS so amazingly good that it takes off on its own like Linux did. Both scenarios seem improbable.

Might be happening with Fuschia?

I think most people seriously underestimate the development effort a usable general purpose OS takes. It's actually global scale and the few companies still having their own can only do it because they captured large parts of the global market. And even if we ignore this, if someone comes up with objectively better apis, linux can just have a 80% solution with a few new syscalls (e.g. cgroups or io_uring), and the rationale for their potential users evaporates.

An alternative thought is that to endure the forces for change over 5 decades an idea must be really useful.

Or very strong Stockholm syndrome. We are clearly in era when not everything is text, but still it seems that is somewhat carrying idea...

I feel that in many cases whole Unix philosophy is outdated, if not even followed.

I've been thinking about that. I think the new "pipe" is filesystems instead of text. That's how I've been using Docker volumes in GitLab CI/CD the last couple of years.

EDIT: The alternative is PowerShell. You carry objects over the pipe instead of text. I don't like PS personally.

The whole all but violent upheaval caused by systemd (not rehashing it here/now) seems to stem from the Unix philosophy not being adhered to. Pulseaudio similarly used to draw a lot of ire (perhaps still does; I haven't seen as much of it lately).

Personally I love the Unix philosophy for most things because of how easy it makes automating a lot of things, but there are realities to crafting a modern graphical desktop system that can at times be incompatible with it. Sometimes a front end for a text based tool makes sense and things can be adhered to; sometimes not so much. Personally at LEAST including an API is my design preference, but, well, sometimes you work with the software you get.

Lindy Effect - https://en.wikipedia.org/wiki/Lindy_effect

I disagree with a lot of what you are saying.

OSes these days are a lot, a lot, more complex and richer than the "original" old ones. Sure there is some compatibility with Posix because it is a nice common factor to start from, and it incorporates some ideas about multitasking and multiuser systems but everything is substantially different.

POSIX permissions coexist with ACLs and much stronger security models, code signing, sandboxing, etc..

Compressed memory, copy-on-write, snapshotting filesystems, graphics as a privileged citizen, OS handling of energy efficiency, and so on and so forth...

We have long outgrown the "original" OSes and today commercial OSes have a ton of man-hours behind them that make every hobbyist OS pale in comparison.

It's not lipstick on old pigs, POSIX is an old lipstick to make the new pigs somewhat compatible with one another.

POSIX actually worked on a standard for ACLs, but never completed it.

Many UNIXish operating systems implement POSIX 1003.1e draft 17, the final (unratified) draft.

https://www.usenix.org/legacy/publications/library/proceedin...

We have a new OS, but its novel enough that it isn't recognized as one.