OSDev.org

I'm curious what people here think are exciting OS-Level features that aren't in any of the mainstream OSes, (UNIX, NT)

Some I've found from reading Wikipedia:

Single-Level Store or the related Orthogonal Persistence in which programs need not differentiate between RAM and Disk and keep running throughout OS restarts. At a different level of abstraction, and with a cloud focus instead of OS focus, this seems similar to Durable Functions. Plenty of niche OSes have this including ones by big companies (IBM i) before my time, but it seems not to have caught on.

Capability Architecture with my favorite OS implementing them being Genode. It seems like a really principled way of doing security, and ofc. is present on UNIX and others with things like File Descriptors.

Alternatives to the Filesystem, for example using a database. Something explored by NewtonOS and probably others.

Typed interfaces, or "Everything is an Object"

Network Transparency / Distributed OSes like Plan9 or Amoeba


I'm surely missing a bunch of ideas here, especially since all of them have been tried out in the 80's already. What concepts do you find the most exciting?

Single-level store and orthogonal persistence are practically requirements to me. At least, my OS will have them. I'm still figuring them out though.

Capabilities are something I keep telling myself I need to learn about, but I always have something else to do. I recall Unix was considered to not have capabilities for many years. I don't know whether the change is due to added features or a new way of looking at file descriptors, though I think it's the former. Edit: I was thinking of ACLs rather than capabilities.

Typed interfaces are kind-of the reason I'm working on an OS to begin with. Rather than applications, I want to script smaller programs to work together, and I'm sick of doing it the Unix way.

I'll decide what kind of storage I want after I have SLS OP & typed interfaces all worked out. Traditional filesystems get in the way in some ways, but are very flexible in others.


It looks like the meaning of "distributed" has broadened again. When I was using Plan 9, it didn't fit the modern definition of "distributed"; its status as a distributed OS was a holdover from when the term was less tightly defined. Now however, everyone is calling it "distributed" again. I'm happy with this, but I'm just noting that it doesn't have process migration and other things which have in recent years been expected of distributed OSs.

For me its good compatibility for another operating system's executables. Kind of like bsd's compatibility with some linux apps.

Huh, that ones one of the least exciting to me - as a user at least. If I wanted to run Linux programs there's a pretty well supported way to do that already :p

I can see how as a creator it would be cool to make something and already have a userland waiting though

Single-level-store
I am a huge fan of the single-level store. Because i want to simplify the complexity of everything.
RAM = HDD = CloudStorage = Blockchain
However, storing data at blockchain needs a completely new programming style due to permission stuff.

Managed programming language
everything is in userspace or everything is in kernel space. if you have the object, you may use it.

security typed components
Every untrusted software component has to be of one component type.
For example, a component type being able to request local data shall be unable to send data to the internet.
A component that is able to send data to the internet shall not be able to directly access local data, but rather just be able request an "Open file..." dialog.

Dynamic generated UI
The operating system consists of a UI services which just visualizes objects. For example, if the Desktop-Object consists of a two dimensional array of Symbols, then you dont need to hardcode a desktop UI using a grid layout. As a 2d array always shall be displayed as a grid.

strong encryption
strong encryption by default with architectural considerations from androids per user encryption. hierarchical key handling. secure 5 digit passwords by using trusted external key retrieval which is useful for mobile phones.

abstraction
abstraction rather than code generation.

running untrusted code
I would like to run untrusted code as this is effectively introducing a new blockchain.

virtualization by design
virtualization is the wrong word though. i suggest container by design. when components ask for the Context, they might just receive a nested context with a different subset of services...

minimalism and maximalism
Although minimalism is possible there are always different implementations available.

audio
the operating system delivers a mixer that priorizes audio streams. music has to be decompressed, before mixing it with voice and effect channels of other applications, and then slightly compressing it again. And the volume shall be logarithmic.

bootstrapping with C
Despite using a high level language, everything should be bootstrappable by using a C compiler, and then working towards the high level stuff.

Commercial but open source
Commercial or kind of organized community for hosting the operating system with a long term reliability. Using capitalism as tool to calculate costs of additional code in base system in terms of maintenance. Updates can be downloaded only by paying users who dont need to tell their identity due to blind signatures are used to verify their licence. The organization strongly encourages to people stick with one programming language and only one library per purpose. Every modules needs to have an active mainainer. Everything has to be reviewed. The company can somewhat guarantee the security of their system and i think banks might spend money for this.

Conclusions
Maybe too much goals. But i am sure, the complexity today is hard. Its ok to have many features. But we need to get rid of the bloat and go the way towards abstraction.

I think JNode (Java) still shows a good base for a managed programming language, however, the architecture is more of a classic nature. As there are processes, files and so on...
Another problem: Java is not bootstrappable easily with C. JNode just relies on an existing java environment, when compiling things to binary.

The most exciting feature is: I can use the OS continuously, I can rely on it, without it changing under me somehow, disrupting my use of it.
Specifically, when it's not stealing my energy, internet bandwidth or data with ads and various spyware (often masquerading as antivirus sw).
And when it's not changing the GUI with every single release.
So much for all the technological progress. It goes out the window when you need to deal with such crap.

alexfru wrote: ↑Sun Sep 29, 2024 12:34 pm And when it's not changing the GUI with every single release.

And if its changing the UI, then at least use configurable themes and/or strategy patterns in code for configurable behaviour.

emarkus wrote: ↑Sun Sep 29, 2024 9:22 am Dynamic generated UI
The operating system consists of a UI services which just visualizes objects. For example, if the Desktop-Object consists of a two dimensional array of Symbols, then you dont need to hardcode a desktop UI using a grid layout. As a 2d array always shall be displayed as a grid.

That's an amazing idea! I've been thinking about adaptable UI since 1998 and something like a common object format since about 2014, but I never put them together until now. I'm writing this down. I'd want to go light on the 2D tables for adaptability's sake, but there are many other things which could benefit from autogeneration. Most of all, it could save a lot of time for sole coders like myself.

alexfru wrote: ↑Sun Sep 29, 2024 12:34 pm The most exciting feature is: I can use the OS continuously, I can rely on it, without it changing under me somehow, disrupting my use of it.
Specifically, when it's not stealing my energy, internet bandwidth or data with ads and various spyware (often masquerading as antivirus sw).
And when it's not changing the GUI with every single release.
So much for all the technological progress. It goes out the window when you need to deal with such crap.

That's 2 issues, changes and malware. Getting away from constantly-changing systems is my #1 interest in OS development, though it might be satisfied better by retrocomputing. If I make my own OS, I'll have to keep changing it for a while as I realise what improvements could be made. Running programs written 30+ years ago means no such changes.

Some kinds of malware will be trouble so long as you have a modern web browser. Thankfully, much useful data is now available through web APIs, avoiding scripted HTML entirely. There are also BBSs. My favourite telnet-based BBS went down a few years ago, but just yesterday I found I can check the UK weather via a very 80s-teletext style Telstar BBS with the help of BBC BASIC for SDL. It would be pretty easy to write a teletext-chip graphics emulator to access it in other OSs.


On the topic of what we don't want, I'd like freedom from animations too. I can see how animation helps in some ways, but it's not good for my poor old brain.