23 comments

[ 3.0 ms ] story [ 53.5 ms ] thread
ZeroFS [0] is very thankful for what it brought to Linux with the v9fs [1] subsystem which is very nice to work with (network native) compared to fuse :)

[0] https://github.com/Barre/ZeroFS

[1] https://docs.kernel.org/filesystems/9p.html

I believe that the Windows Subsystem for Linux (WSL, really a Linux subsystem on Windows) uses the Plan 9 network protocol, 9p, to expose the host Windows filesystem to the Linux virtual environment.
>9front.org frequently questioned answers

Knowing that project am I going to be rickrolled?

People wanting a Retina-capable drawterm to access Plan9/9front from their Macs are welcome to have a look at https://github.com/rcarmo/drawterm
Thanks for the improvements! Two small quality of life fixes over the original that I particularly appreciate:

  - Window resize works as expected,
  - Doesn't lose input focus on resize or move, and
  - *Dyamic* scaling.
That last one has been really nice when screen sharing with colleagues.
The transition step between UNIX and Inferno, and between C and Limbo as main userspace language, by its authors.

Which tends to be forgotten when praising Plan 9.

Is there Plan9 port for RISC-V (RV32I) ?
IMO, the biggest curse of the Internet age is how Distributed OS's did not become mainstream. Maybe we should repackage these as Unikernels and run our apps using their distribution services directly on a hypervisor.
I’m not sure it still makes sense to do OS research so close to the metal. Most computing is done up on the application level, and our abstractions there suck, and I haven’t seen any evidence that “everything is a file” helps much in a world of web APIs and SQL databases
Idk I still find low level OS stuff super interesting because it hasn't had a rework in so long. With everything we've learnt since the age of modern computing, drives larger than a few MBs, super fast memory and fast cryptography to name a few.

It's interesting to imagine a new OS that incorporates these changes from it's infancy.

I appreciate all of the effort put in by Linux, BSD, Android, QNX and closed source OSs' have put in to building upon existing ideas and innovating gradually on them. But man I really want to see something better than everything is a file. I really enjoyed the stuff BeOS was pitching.

Indeed, no, we shouldn't be sure everything-is-a-file makes sense to do OS research. I don't think this is particularly necessarily what need to considered close to the metal. But it is os research.

I think you're right about where computing is today. It's mostly at the app level.

I think you once again hit a super hard conventionality chord & speak to where we are by saying we don't have much evidence of "everything is a file* helping, anywhere. Broadly.

But analyzing where we are & assessing they everything-is-a-file isn't a sure thing doesn't dissuade me. Apps have wanted control, and there's beenfew drivers to try to unite & tie together computing. App makers would actively resist if not drag their feet against giving up total dominion of the user experience. OS makers don't have the capital to take over the power from apps. The strain of unweaving this corporate power interests is immense.

There have been some attempts. BeOS tried to do interesting things with enriching files, with making their more of a database. Microsoft's cancelled WinFS is rumored to have similarly made a sort of OS filesystem/database hybrid that would be useful to the users without the apps. But these are some of the few examples we have of trying anything.

We're in this era where agents are happening, and it's clear that there's very few clear good paths available to us now for agents to actuate & articulate the changes they could and should be doing. Which is just a reflection of app design where the system state is all bundled up deeply inside these bespoke awkward UIs. App design doesn't afford good access, and part of the proof is that other machines can't control apps short of enormous visual processing, which leaves much ambiguity. If agents can't it also strongly implies humans had little chance to master and advance their experience too.

I strongly think we should have some frontiers for active OS research that are user impactful. We ought be figuring out how to allow better for users, in ways that will work broadly & cross cuttingly. Everything is a file seems like one very strong candidate here, for liberating some of the power out of the narrow & super specific rigid & closed application layer.

I think Dan was also super on point writing A Social Filesystem. Which is that social networks & many online systems are everything-as-a-file under the hood. And that there is generic networked multi-party social networking platform available, that we have a super OS already here that does files super interestingly. And Dan points out how it unlocks things, how not having one specific app but having our online data allow multiple consumers, multiple tools, is super interesting an opening.

So, everything is a file is very webful. A URL logically ought be. A multi-media personal data server for every file you can imagine creates an interest powerful OS, and a networked OS.

And users have been warped into fitting the small box their apps demand of them so far. They've had no option about it. All incentive has been to trap users more and more to have no off roads to keep your tool being the one tool for the job.

Distribute the power. Decentralize off the app. Allow other tools. Empower broader OS or platform to let users work across media types and to combine multiple tools and views in their workflow. Allow them to script and control the world around them, to #m2m orchestrate & drive tool use.

I don't disagree with anything you said I just think it's a 30 year old basis you stand from, one that hasn't helped had gotten better and which has ongoingly shrunk what is possible & limited the ability to even start trying for more or better. I don't think we are served by what it feels like you are trying to highlight. And I think "everything is a file" could be an incredible way to start opening up better, possibly, maybe!! but I'm very down to hear o...

I guess I feel like if we’re rewriting device drivers then we’re in a turing tarpit. I think there’s room for innovation at what is traditionally considered the application level - we run git, postgres, document stores etc as applications. I think the way to solve the next generation of coordinating is by doing more interesting stuff on this layer.
That's why it's a research OS, a lot of people (or at least some) think that the current range of mainstream OS are not very well designed, and we can do better.

I'm not saying Plan 9 is the alternative, but it is kind of amazing how un-networked modern Operating Systems are, and we just rely on disparate apps and protocols to make it feel like the OS is integrated into networks, but they only semi-are.

The most "research" thing I'm aware of 9front (since you're speaking in present tense) doing is that GEFS needed to work out a lot of things for itself that weren't in the Bε-tree proof-of-concept FS that came before.

I dunno how "close to the metal" you'd consider that.

("GEFS" being a disk filesystem that's been discussed on HN.)

Why did BSD make Unix sockets something outside of the file system?

I can do this in bash but I always thought it would be more elegant to do a similar thing in C. I thought Plan 9 handled it more like this?

cat < /dev/tcp/localhost/22

SSH-2.0-OpenSSH_10.0

They did not have the original unix vision. and it is a lot easier to to design an interface as a programming interface than shoehorn it into a filesystem interface.

I think having a filesystem interface is pretty great, and plan9 showed it could be done. but having to describe all your io in the [database_key, open(), close(), read(), write(), seek()] interface. can be tricky and limiting for the developer. It is pretty great for the end user however. Having a single api for all io is a super power for adaptive access patterns.

I think the thing that bothers me the most about the bsd socket interface is how close it is to a fs interface. connect()/bind() instead of open(), recv()/send() instead ot read()/write() but it still uses file discripters so that stuff tends to work the same. We almost had it.

As much as I like BSD and as great an achievement that the socket interface was, I still think this was their big failure.

> A printed version of the proceedings will be provided to the attendees

How adorable!

I was hoping it would explain "what is Plan 9", or rather, "why is it called plan 9, and what were the other 8 plans?"...