Hacker Newsnew | past | comments | ask | show | jobs | submitlogin
Ask HN: How would a new OS be different?
58 points by Jormundir on Dec 28, 2013 | hide | past | favorite | 54 comments
It seems like all of the new operating systems coming out are really just different flavors built on the unix kernel. If a new operating system were to be built from the ground up today, would it be significantly different? I know the linux core is improved all the time as an open source and constantly evolving project, but I just wonder if given the chance to build something with no legacy to maintain, would an operating system have any greatly different architectures or components?


I find the L4 Microkernel [0] pretty interesting. The goal of L4 is to make the microkernel architecture performant by making IPC fast. They did this by making the implementations processor dependent; they wrote the IPC code in optimized assembly. A variant [1] of it is actually commonly used in baseband processors. See this paper [2] for a good overview.

[0] - http://os.inf.tu-dresden.de/L4/overview.html

[1] - http://www.ok-labs.com/products/okl4-microvisor

[2] - http://homes.cs.washington.edu/~bershad/590s/papers/towards-...


Not only that, but seL4 [0] is a cool NICTA effort that's been ongoing for almost a decade now to produce a secure, machine-verified microkernel based on L4. It seems like there's lots of room for L4 and its children to occupy interesting spaces in OS design.

[0] http://ssrg.nicta.com.au/projects/seL4/


L4 is also a very clean, simple codebase. I like it a lot.


The biggest legacy of Unix is C.

With Unix, runtime provisions effectively end where C picks up. C is "good enough" to build applications on, and it can be written portably, most of the time. But there is plenty of reason to challenge the idea that we need a baseline of C. There are benefits to having richer data types built in, to having garbage collection, and all of those typical higher-level programming arguments. And if it's done at the OS level, the whole OS may also benefit from that - it opens up more options for organizing data, for configuration interfaces, and for communicating between processes. The system is likely to be more stable and more secure as well.

The downside is also known - losing lower-level control, losing lower-level performance. But each time our hardware situation morphs, there's an incentive to abandon the lower-level stuff to get better portability. So in time, as hardware usage changes(not just in terms of devices and their internal HW management, but also the increasing complexity of our networks) we're likely to incrementally adopt the higher-level paradigms.


I found/find it interesting that the Oberon system is written in a language that has garbage collection built in (the Oberon programming language). I haven't checked how it is dealing with allocation in interrupt handlers, though. I should, it is a small system and probably deserves reading the code of.


C isn't all about performance, can you map your unknown high level language with it's great features to assembly? Do you know what assembly is going to be produced out of this language? If not good luck with debugging, understanding performance.


Greenspun's tenth rule writ large.


Greenspun's tenth rule is result of "If you have a hammer, all around looks like a nail" applying value "Lisp" to "hammer" metavariable. Specifically Lisp is not good at writing a OS for existing hardware, though I agree that there should be more progress at system programming language level.


Yes you certainly can: At my university they are building a new operating system from scratch with multicore/multi CPU systems in mind, their vision is that someday we might have 5-10 specialized "CPU"s in our machines for better parallelization.

Current OS have a hard time dealing with such heterogenous systems so they decided to start from scratch: The entire OS is structured as a distributed system with a dedicated mini-kernel running on each core of the processor and potentially also your network card etc. They even disallow shared memory between the core kernels and solely communicate through a message passing system.

If you are interested in their approach check out the Barrelfish website: http://www.barrelfish.org

And here is a great overview of the architecture: http://www.barrelfish.org/TN-000-Overview.pdf


Some ideas for inspiration:

--- Low level ---

Highly reliable, flexible, and secure http://www.minix3.org/

Filesystem that's intuitive, easy to learn, and makes sense http://www.gobolinux.org/?page=at_a_glance

Declarative configuration management http://nixos.org/nixos/

Support applications and drivers written for windows http://www.reactos.org/

Better Security http://www.openbsd.org/security.html

Update software silently and instantly http://www.codinghorror.com/blog/2011/05/the-infinite-versio...

Application Permissions http://codezqr.com/blog/wp-content/uploads/2012/04/Android-P...

--- User level ---

Remove X11 http://wayland.freedesktop.org/

Application Directories http://en.wikipedia.org/wiki/Application_directory

http://rox.sourceforge.net/desktop/

Amazing basic applications http://www.apple.com/osx/apps/

Unify notifications http://growl.info/

http://www.apple.com/osx/whats-new/#notifications


Half of these things aren't really operating system features in the narrow sense – which is what I think the OP meant. X11 isn't part of the Linux kernel, but part of your GNU/Linux system. Likewise for notification, bundled applications, etc.


Sorted


I know that the question was about OS architecture but I really feel like the UX is not as good as it could be. One thing I've been thinking about recently is that it could be interesting if there was some GUI system that would follow the Unix principle of having many small, task specific applications that could be easily composed together. It happens to me a lot that there are 3 applications each of which does something better than the other 2 but in the end of the day none of them is ideal. If I could pick the best of the 3 and put it together myself, that would be great.

Later, I realized that Mac OS' Automator/Applescript might have been an attempt to do something like this but it feels somewhat half-assed. Given something like this is probably impossible to bolt on later so you'd have to design the OS from the beginning to allow for this.


You might be interested in tangible functional programming, which aims to bring useful composition to GUI programs.

http://conal.net/blog/posts/tangible-functional-programming-...


That looks interesting, I'll check it out, thanks.


If I were to create a new OS today, it would basically look like an iPad-ish screen of icons as a front-end to Xen. Each "app" would be a stand-alone virtual machine image custom configured to run a /single/ application each.

I'm speaking out of my rear end, but it seems like that's where we're all headed in order to achieve the security/configurability/reliability/simplicity/etc that we all want. As examples, I point to sandboxed mobile/browser/cloud/game console apps as well as config sandboxing such as VirtualEnv and .Net's dll versioning. Might as well drop the half-measures and go all the way. Skip DLL/API/browser version hell and just ship a complete OS image that has been configured and tested to work reliably for the app.

It's my understanding that the Xbox One has basically implemented this already. Game discs contain an OS image that runs as a guest OS on the Box. In addition to improved security, this should greatly reduce the back-compat test burden as future Xbox OS revisions come out.


http://www.xenproject.org/developers/teams/mirage-os.html http://openmirage.org/


I think what you actually want is static linking, with an OS that supports kernel ABIs going back many years (like FreeBSD) and good process/user-level restrictions. Running an entire operating system for every application is a bit heavyweight.


Perhaps an OS that is built over distributed components. A process you run, or even a "thread", can execute in an AWS instance. Applications can be shared between multiple devices. Storage can be anywhere. A distributed web service is just an "application" under this OS.


On the other end, would be cool if all of your devices were aware of each other and syncronised apps in realtime. For example the browser on your phone has the same tabs open as your desktop. The image you're photoshopping on your desktop is viewable on your mobile in a mobile specific version of photoshop (so all apps have multiple views for each different device).


That's already common. I'm typing this on Firefox for Android which has Sync enabled, and all the tabs from my laptop are here (and vice versa). You just need to choose applications with support for that.


ICloud?


I used to give some thought to OS design some time ago (I'm a hobbyist OSdev). I've come to a more conservative point of view: what problem do we try to solve with the new system design? Are our systems large and flabby enough to fall apart from within under their own weight? Are there profound hardware changes that require architectural re-thinking?

An OS kernel by definition is a small layer of hardware resources management/abstraction software. Has hardware changed? Yes and no. The most prominent changes are multi-core CPUs, ubiquitous networking, a lot of peripheral devices, support for OS virtualization, but generally hardware architecture is not that far from 70s when Unix was invented. From the software side: the beauty of programming is in its abstraction power and most of software progress is advancing at levels abstracted far from OS (html5/virtual machines/language environments/etc). So, I don't see a burning need for changing the underlying service layer. Microkernels are nice, language-based systems are nice also, but their time has not come yet, the inertia of existing code base is huge, so the incentive to depart from it must be also huge.

I agree that user-space level organization may be more consistent from modern point of view, but it's not clear where to head. Ideas are welcome, but power of organic evolution also should not to be underrated.


It would be interesting to see an OS in which audio and video streams were first class objects. Where the primary display was a video stream composited out of main memory from a render tree that was the core data structure and which treated memory as being made of tagged video and audio buffers ( some of which were infinite in length or were memory mapped from disk or network sources ).

BeOS had some of this, but the core ideas have not been explored as fully as they might have been.


I think there is lots of potential for innovation in the file system area. There could be a content-adressable file system right in the kernel and serve as a base for the operating system. Or some kind of object storage. Or at least with much richer meta data (and Unicode file names!) than current file systems. And maybe with transaction support over multiple files/directories.


There is a very interesting storage system designed for Apple's Newton OS that was buried when Steve Jobs killed the Newton: http://en.wikipedia.org/wiki/Apple_Newton#Data_storage

In short, it's a modular object storage with a rich set of indexing and quering mechanisms, tailor-made for NewtonScript. It isn't some quirky experiment that never got out of CS academia's ivory tower - it had real-world applications and a noticeable installed base.

EDIT: changed the link


- Built in support for the online services from the ground up. From the filesystem to the drivers the system should be built around the idea that it can be updated easily from the web and kept up to date. - Ideas like DropBox and Backup services aren't a 3rd party feature/add-on they are core to online nature of the OS. - Perhaps a new way to manage files & folders. I can't believe we still use filename.ext. iOS has some interesting things here.


Isn't this pretty much ChromeOS?

* Obviously built with online services in mind

* OS is automatically updated from the web

* All (or most— downloads are sill local) data / config / etc. automatically synced with Google account

* Uses GDrive for managing files/folders


They should call it PrismOS.


Look at Plan 9. http://en.wikipedia.org/wiki/Plan_9_from_Bell_Labs


Plan 9 certainly has some cool ideas, but I have a really hard time believing that a project that originated in the 80s and has yet to "make it" in any meaningful sense is really the way of the future.


Because (sadly) compatibility with the existing software ecosystem and support for common hardware is king, at least if we're talking about a general purpose OS. Who cares about your project if it can't run the N million line behemoth the modern web browser is? With all its deps...

But I'd really love to have an OS that sweeps the pile of legacy cruft we've built up and replaces it with something simpler & smaller. In a sense Plan 9 is just that. But I'm sure one can go further down that road.


Some of Google's internal architecture is inspired by plan9, e.g., gfs. Plan9 also included a language called Aleph which has today evolved into golang.

Union mounts have been particularly interesting: something plan9 implemented, but no one else has successfully.


Built-in sandboxing with user-defineable data flow policies.


I'd love to see integrated package management and versioning handled by the OS in such a way that each independent language community wouldn't have to reinvent a new distribution channel. Something like Ruby's Bundler or .NET's GAC+Nuget or "App Stores for Libraries" at the OS/vendor level.


Like Linux distributions have done since 1997? <http://en.wikipedia.org/wiki/Package_management_system>

Am I misunderstanding you?


Rather earlier than 1997, though full dependency resolution and such came around then (I actually thought it was earlier). APT in particular saw its first release in 1998. It was built as a front-end to the earlier dpkg (anyone else remember dselect?), released in 1994.

Ian Murdoch's observation on package management advances driven by Linux, and Debian in particular, are on mark (from the Wikipedia article).


Like apt/yum, but with multiple sandboxed versions and installable in users' home directories.


When I think "Next-Gen OS" I think of boot-to-Erlang with a very high fault tolerance.


Here it is: http://erlangonxen.org/


I'm spending this next year to build a new operating system. If you're truly interested in changing the future of computer email me: dan at techendo dot co


Haiku. Yeah, it's sort of UNIX-like, but it's APIs are phenomenal, and it's focus on performance is slightly different to other OSes


it's like BeOS


It's the successor to BeOS.


Look at ReactOS: http://en.wikipedia.org/wiki/ReactOS


It is basically an open-source reimplementation of Windows XP.


a related kickstarter: http://www.kickstarter.com/projects/thorium/thorium-core-clo...


Declarative configuration management http://nixos.org/nixos/

This.


I really liked the sound of WinFS with a filesystem that you could query like a database.


Id like to see OS with exokernel.


Most innovation is driven by at most a few individuals, but the bar is so high for a viable practical modern operating system that individuals are going to tend to take their innovation elsewhere.

This is not the ideal situation. Ideally, big companies like Microsoft or Apple would enable the right individuals to innovate in this area, unfortunately they are very bad at this. They do not know how to select these individuals, and even more importantly, leaving aside the rare likes of Elon Musk, the notion of radical innovation is rather contradictory to the institution of big business in our era.


From Microsoft:

"Singularity is a research project focused on the construction of dependable systems through innovation in the areas of systems, languages, and tools. We are building a research operating system prototype (called Singularity), extending programming languages, and developing new techniques and tools for specifying and verifying program behavior."

"The Singularity Research Development Kit (RDK) 2.0 is now available for academic non-commercial use. You can download it from CodePlex, Microsoft's open source project hosting website"

http://research.microsoft.com/en-us/projects/singularity/


Nothing on that page gives the impression that it's more than proposed feature enhancements (which in themselves may be wonderful of course), as opposed to a fundamentally novel approach to operating systems.


I agree with your sentiment regarding innovation is driven by a fee individuals. the good news is that its not about how high the bar is. you Don't need to compete on legacy metrics, you just need to do something that that the other system could never ( or at least with great difficulty ) do. another great thing about os's is they are really not that big once you take out all the vendor fragmentation from different device drivers.

you could really narrow things down by just targeting a specific hardware set set ( like a raspberryPi ). Actually now that I said it, that's the only hw I would target . reduced footprint , experimental user group , arm architecture. its the perfect platform to launch a 'different ' kind of os.




Consider applying for YC's Fall 2025 batch! Applications are open till Aug 4

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: