

Ask HN: Where might a fundamental rethink of operating systems lead? - hoodoof

Imagine everything we know about operating systems was tossed out the window.<p>An entirely clean slate approach to rethinking how operating systems and software should work.<p>Does that concept make sense at any level? What might come out of such an exercise?<p>Is it even possible to make a dramatic innovation given that we already have such strong ideas in our heads about how operating systems work? Perhaps it&#x27;s not possible to imagine things dramatically differently from what we have already experienced.
======
humbledrone
Urbit is exactly this: "We got tired of system software from the 1970s. So we
wrote our own on top. From scratch."

It is _dramatically_ different from what we have already experienced. It's
really far out there, so far that it's hard to wrap your head around, but
there are some really neat ideas wrapped in the extreme weirdness. Fun to read
about, at any rate.

[http://doc.urbit.org/](http://doc.urbit.org/)

~~~
myhf
The Urbit demo video is really cool:
[https://vimeo.com/75312418](https://vimeo.com/75312418)

------
UnoriginalGuy
The closest thing I can think of to this was:

[http://en.wikipedia.org/wiki/Singularity_%28operating_system...](http://en.wikipedia.org/wiki/Singularity_%28operating_system%29)

Which was a complete re-design at almost every level. Unfortunately the entire
project got shelved, but it was a pretty interesting experiment while it
lasted...

------
nostrademons
Two interesting ideas from the past:

[http://en.wikipedia.org/wiki/Exokernel](http://en.wikipedia.org/wiki/Exokernel)

[http://c2.com/cgi/wiki?NeoKernel](http://c2.com/cgi/wiki?NeoKernel)

Another that's been tried a couple times: what if you get rid of the operating
system entirely and run a VM (for, say, a scripting language) directly on bare
metal? What kind of optimizations could you do? Maybe you'd expose disk
blocks, page tables, and the TLB directly as language APIs. What could you
build with that, and are there any use-cases (databases? high-performance
message buses?) where you could get order-of-magnitude improvements in
performance with this?

~~~
hoodoof
Kinda like DOS apps?

~~~
nostrademons
The bare-metal OS was common in a lot of early microcomputers...even the
Macintosh (before System 7) had something that was more akin to an application
support library than a real OS. DOS I think was a real OS; you communicated
with it by invoking INT21 and putting a subfunction (syscall) number in AH,
rather than jumping directly to a library function's address as I believe the
Mac did.

I'd be curious if it would work even better today because so many language
runtimes have many common OS services in them, eg. Erlang and Go have green
threads, many have garbage collection. Making the GC aware of the page table
seemed to be very useful in Lisp Machines.

~~~
ksherlock
The Classic MacOS toolbox used reserved instructions ($A000--$AFFF were
reserved in the 68000 instruction set) which invoked the interrupt handler.
Tool calls covered everything from string comparisons to windows and graphics
but also included undeniably OS level stuff like opening files and allocating
memory.

You could use a toolbox call to get a function's address and call it directly,
but that was mostly used for patching the toolbox.

------
reynoldsbd
The ultimate goal of an operating system is to provide some abstraction level
so that application programmers don't have to worry about things like disk
I/O, scheduling, etc... The key here is that the OS takes care of things that
are done the same way each time so that programmers have less work to do.

Currently, the de facto abstraction is to (as an application programmer)
generate machine code either by direct compilation or by interpreting at run
time. Programs are written as if they're the only process on the CPU, and the
OS takes care of keeping multiple running processes from overwriting each
other or starving each other of CPU time.

In other words, everything ends up as machine code. This is the same every
time.

I think a really radical OS redesign would target a higher level of
abstraction. Instead of programmers designing procedural programs resulting in
machine code, why can't programmers design a static system of components and
let the OS orchestrate their interaction?

If the overarching goal of an OS is to support application programmers, then I
think an important notion to challenge is that all applications must be
imperative.

------
insoluble
Each "program" could be an octopus with arms. Each arm would represent a
standard interconnective role with respect to the grand system. To be able to
utilise those resources available to a particular role, the program would need
to be granted the pertaining privilege by the user. For example, one role may
give read access to personal photographs stored on the system. Another may
permit uploading data to the Internet. And yet another may permit making
sounds through the system's sound output devices.

Any such given privilege could be revoked at any time by the user.
Furthermore, activity on the arms of each octopus could be monitored visually
or in an event-log-based format.

Instead of file (data object) permissions being based on user accounts, each
file would have a set of flags indicating what types of data it contains. Only
those programs with privileges for access to said types of data could see or
access the file. If there were user accounts on the system, those accounts
would have limited access to certain types of files (based on flags) and
certain roles (from the octopus arms). When a given user ran software, only
those roles granted to that user account could be enabled on the software
being used. Nevertheless, any user could grant the software fewer roles than
the user itself had.

------
mflindell
Exactly like this:
[https://www.youtube.com/watch?v=pUoBSC3uoeo](https://www.youtube.com/watch?v=pUoBSC3uoeo)

------
throwway999
Two things come to mind, from less-far-out to further-out:

\- A capability-based operating system, see:
[http://en.wikipedia.org/wiki/Capability-
based_addressing](http://en.wikipedia.org/wiki/Capability-based_addressing)

\- Anything microkernel-based (Minix!) For pete's sake guys, why don't we have
this already in our mainstream OSes? I'd happily take a performance hit of 10%
in return for the enormous benefits (stability, security, design elegance).

Personally I don't think compile-time guarantees are a good idea, because the
resulting system strikes me as very vulnerable to that one thing the
developers overlooked.

------
manidoraisamy
Operating system should cater to 3 different target audience:

1) Consumers need an invisible OS that understands natural interfaces like
voice, mind.

2) Developers need a productivity OS that connects to their apps running in
production and helps them in debugging/monitoring.

3) Servers need virtual OS that natively support containers to run apps in
distributed environment.

------
pkinsky
NixOS isn't quite clean slate, but it does completely reimagine package
management.

------
zurn
I think the reason all the comments are referencing old OS ideas is that
people who understand your question can't answer it.

Recognizing a novel OS idea requires familiarity with the state of the art and
history of OS research and someone like that wouldn't be answering from a "all
knowledge tossed out of the window" perspective. Also, the very notion of "OS"
is pretty loaded and brings along a lot of conventional thinking.

I guess a serious attempt could have some computer culture-oblivious people
generating ideas and then some veteran people filtering out the reinvented
wheels. It would still be hard to tell any worthwhile ideas from the garbage.

------
ccvannorman
While we're at it, why don't we reinvent hardware and networking?

No, seriously. One idea I had was to physically separate parts of the computer
so that it was impossible to infect the core without a human manually throwing
a switch at some point to allow a connection to (ideally sanitized) inputs
from the net.

hoodoof, this is something I am considering pursuing for my next startup! I'd
love to chat -- I'm charlie@mathbreakers.com

~~~
hoodoof
Hey Charlie, I like to think about this sort of stuff but I'm not smart enough
to contribute technically. Good luck with it though! One day someone will
reinvent computing in an unexpected way and change the world. Maybe you!

------
java-man
\- based on type safe language

\- strong sandboxing of individual OS processes

\- runtime encryption of data in RAM and storage

~~~
stonogo
I don't think you've grasped 'rethink' here. The things you are describing are
bandaids applied to current bad designs, and would be natural byproducts of
better operating system planning.

------
brudgers
Unikernels are a step toward rethinking the operating system for modern
infrastructure.

------
bandrami
A Forth system. I wrote one for my Raspberry Pi and really enjoy it.

