Hacker News Reader

Comment by Ericson2314 | Hacker News Reader

Thank you.

The computing world loves to be relentless positive about things. Ergo all the over-promising and hype-cycles and whatnot. I don't want to descend into nihilism, but I think we need more criticism to balance it out. If people don't know what's bad, how can that appreciate what is good?

A lot of people revere Bell Labs a lot. I dunno, I think the original version in Manhattan with a train running through the building might have been cooler! There was a huge diversity of computers and operating systems in the late 1960s and 1970s. It can easily be argued that technical merits had less to do with Unix's winning than the monopoly law that preventing AT&T from commercializing it.

Starting with an elementary schooler's negative sentence is a good way as any to break from the relentless positivity and widespread Unix worship :)

View on HN

I think the Unix model is a local maxima in the design space we've been living in for decades. It's incredible how well we've managed to scale and tweak the concepts but onto the systems we have today, but I'd love to see more experimental OS architectures again.

Definitely more experimentation would be good.

On the light experimentation front, a longstanding goal of mine is to see NixOS support multiple kernels, because the status quo of having to cobble together a userland from parts for each kernel is a huge productivity drag. Having a "userland assembly toolkit" that lets you plan out what software you want to support with what patches could dramatically lower the barrier to entry.

Trying to carve out a driver layer would also be fantastic. This should be analogized to LLVM making a reusable compiler backend, and the dramatic effect that had on programming language diversity allowing things like Rust to come into existence.

At the same time, kinda what I am saying here is that maybe it isn't quite a local maxima.

Today most kernel work is motivated by performance, maybe security. The mistakes that are already worked around with more ugliness in other layers is usually not prioritized --- we have the workarounds, what's the problem? If more OS work was thought of in productivity terms --- we want to make writing correct, secure, performant, etc. software easier and more natural --- I think we would find the gradient might be bad in many directions, but still good in others.

The stuff I include here is are all things that I think could be refactored into existing "heritage" kernels without much difficulty. I actually looked a bit at FreeBSD and Linux for the process-spawning parts, for example. Just need to slice up the fork/exec code and then call it in a different order.

> Ergo all the over-promising and hype-cycles and what not. I don't want to descend into nihilism, but I think we need more criticism to balance it out.

And then you continue with “ But file descriptors are good.”

Which arguably could be one of the points against UNIX IMHO. As opposed to object-oriented interfaces like for example Windows NT, which allows for elegant shells like PowerShell.

Now let the downvotes flow in… ;)

When I say "but file descriptors are good" I mean https://en.wikipedia.org/wiki/Object-capability_model is the goal.

I don't believe "object-oriented" has any concrete meaning, so I have a hard time interpreting what you mean by that. Window's HANDLE * is good though, and I recall in some cases NT made some things handle-based ahead of Linux / BSDs doing so. (e.g. is `NtCreateFile` older than `openat`? Maybe?)

Powershell is nicer than bash, but doesn't PowerShell run on linux? I would think the integration with a proper standard library and language runtime (C#'s, CLR) is more important than what the system calls look like.

No downvote from me :)

What I mean with “object-oriented” vs “file-oriented” is more the philosophical approach of the systems. I think the “everything is a file” approach of UNIX has its strengths but it also breaks down at some point.

So with the example of PowerShell (on Windows), I like that I can actually pass around objects which I then can query for details if I want to, but which can also hide their details if they’re not needed.

In contrast to files (or rather text), where details are always exposed. This is often seen as an advantage as it’s directly “human readable”, but in my experience it often makes for more complex command lines.

As said, both philosophies have their pros and cons, I just don’t see the UNIX one as the one and only truth.

But I generally try to be pragmatic and will happily use Windows or some UNIX derived system (or something else) depending on the use case.

I think Unix fails at "everything is a file" but that's actually good.

When you say "pass around", what do you mean? Is this some userland struct future syscalls will inspect manipulate? Or are you passing HANDLE * references to an opaque resource?

I very much agree text is bad. :)

I mean (for example) that in the shell I can pipe the output of one command to another, like on UNIX. But what gets passed is not text, but an object.

The difference between Windows and Unix is the design of the OS. Unix famously handles "everything as a file". In Windows, everything is an "object" of some sort. This means that to be efficient in Unix, you need to be focused on files and text. But in Windows, you need to understand the OS objects, and how to work with them. Powershell excels at that. Someone ported Bash to Windows, but I'm still not sure why. It's a better shell than "CMD", but neither are well-matched to the Windows abstractions. I've never tried Powershell on Unix, but I suspect it'd suffer from the same "impedance mismatch" as Bash on Windows; it's just not designed to work on the right abstractions.

I’ve tried PowerShell on macOS, and yes, it feels a bit like Bash on Windows

> elegant shells like PowerShell

Microsoft really should push that harder and create some sort of standardized /usr/bin-alike so people can install CLI tools (both local user equivalent to ~/bin and globally requiring admin) in a controlled manner.

PowerShell is an awesome shell.

Shame about the language

Can you explain?

> /usr/bin-alike

This is called C:\Program Files.

> ~/bin

This is called %LOCALAPPDATA%, which lives in C:\Users\<Username>\AppData\Local.

There are exact equivalents to Unixisms on Windows; it's just that Unix developers don't want to use these equivalents.

So, putting executables in C:\Program Files will work to make them available to you on the shell?

No; to make an executable available on the shell, you add its directory to PATH, same as on *nix.

> As opposed to object-oriented interfaces like for example Windows NT, which allows for elegant shells like PowerShell.

Now let the downvotes flow in…

No downvote from me!

I always found UNIX's everything-is-a-bag-of-bytes to be a huge pain, and file descriptors even worse.

This is a hard pill to swallow for many *nix die-hards, but I would say that objectively speaking, Windows NT has a better core OS model than Unix-like OSs, including the driver model, the filesystem API, the process management API[1], and the overall plug-and-play-ness of NT.

[1]: The OP article mentions this paper by Microsoft Research, but claims it doesn't offer alternatives—it does. It explicitly mentions posix_spawn and CreateProcess. https://dx.doi.org/10.1145/3317550.3321435

I've found delving into the structure of Windows NT (and Windows in general) is an endless stream of fascination after another. Almost 30 years of being a Windows wizard and I'm still like a kid in a toy store any time I go through it.

On the surface it seems like madness, but taking a proper look quickly shows there were and are very smart and wise people behind Windows's core.

Reply on news.ycombinator.com