Because they're monolithic, bloated, and written in C.
(Rust guys, please don't screw up. We need a win there.)
Because they're monolithic, bloated, and written in C.
(Rust guys, please don't screw up. We need a win there.)
While it's true that Rust would help here, it is very unlikely that a Rust kernel project would get as far as e.g. Linux and let alone replace it.
Of course, rewriting and existing kernel stepwise would be interesting, if possible.
Perhaps it's possible to write a new kernel in Rust, and have it be backwards compatible with Linux, by "wrapping" the Linux kernel and drivers in sandboxes?
So a Rust kernel with some kind of built-in environment isolation, in which it can run the real Linux kernel. The running Linux kernel would then access physical hardware through a wrapper in the Rust kernel, while the Rust kernel would access hardware directly.
That's really the only way I see this project gaining widespread adoption: by leveraging Linux. Linux simply has too much momentum to be replaced with something non-compatible.
Of course, a Rust kernel could be useful for all kinds of things other than replacing Linux. Like a Mirage OS-type kernel that uses Rust to write drivers in Rust (instead of OCaml).
I'm not convinced that Linux is unkillable, though. This thread is about OS X, I'm typing this on an OS X machine, etc. I suspect that if you do a good job of working with people's hardware (Apple has an advantage, of course), you can run Chrome, and you can run anything that's portable between OS X and Linux, you can get pretty far.
Linux as a UNIX clone, will never use anything else other than C.
Replacing C in MirageOS sounds more likely.
for an overview of what's going on in this area. If you're running containers on a hypervisor, with files on storage servers elsewhere, most of the Linux kernel is dead weight. Most of the kernel can be replaced by a modest glue library. Here's one, written in OCaml: http://anil.recoil.org/papers/2013-asplos-mirage.pdf
As containers catch on, we'll see more systems specialized to run nothing but containers. They will be much simpler than Linux or Windows. System administration will be external, as it is for cloud systems like Amazon AWS now.
My list goes as:
- kernel memory and userspace memory is hardware separated as it was originally with some early architectures
More about it here: http://phrack.org/issues/64/6.html#article
- microkernels
Having a formally verified ring0 execution block and everything else is running in a less privileged space, this would allow kernels to protect themselves against bad drivers and other parts of the operating system that can be used as attack surface today
- safe userland
this is I guess where Rust could help the most, having a memory safe low level language
UNIX is married with C, so any attempt to replace C, means breaking with the UNIX mindset, which has proven very hard to do.
Even successful research projects like Oberon, failed to cater the industry, and this was before UNIX became widespread.
Regarding microkernels, most of the embedded space OS are actually using microkernels.
I am following MirageOS, HaLVM and Microsoft's Ironclad as possible safer OS.
This is why also also like what Apple, Google and Microsoft do on their mobile OS to reduce the amount of allowed unsafe code. Even though it isn't at kernel level.
I don't believe this is particularly true, although I haven't explored it very far. UNIX is married with the API/ABI exposed by the so-called "C" library. So far, there have been no languages that offer native interoperability with C and have gained significant popularity, other than C++, and C++ is certainly pretty popular on UNIX (Qt, gcc, etc.). Rust does offer that and is (evidently) picking up a ton of steam, and you can get to the point where stupid tricks that previously required a C derivative can be done in Rust.
http://mainisusuallyafunction.blogspot.com/2015/01/151-byte-...
In fairness, this often also requires things like "C" strings, the "C" locale, etc. But those things can either be done smoothly enough from Rust, or are wrong anyway, that I think there's a chance to break the C stranglehold here.
UNIX and C were developed together. Like most system programming languages before it, and even those that failed in the market, C's original purpose was to bring its host OS to life.
So to remove C from a UNIX compatible OS, you need to remove C from UNIX culture, which is impossible.
The resulting OS wouldn't be UNIX any longer, it would be Plan9, Inferno, something else.
As for C++, is pretty popular nowadays because it also came from AT&T, so it has been part of the UNIX culture from the mid-80's. But never at kernel level.
There are OS written in C++, like Symbian, BeOS, IBM i and others. None of them are UNIX compatible OSs.
I cannot imagine any commercial UNIX vendor to allow anything else other than C on their kernels, nor I do see it happen in the FOSS world.
Alternative OS that try to research new paths in OS architectures, yes. But not OS that try to clone UNIX culture.
If you look at my comment history, I am not very found of C, but I just don't see it happen from the social point of view of how comunities behave.
(And I'm personally not a fan of UNIX culture, at least in 2015, partly _because_ it's a culture that thinks C is a defensible language to program in, at least in 2015.)
> And I'm personally not a fan of UNIX culture
Personally, I have learn a lot from UNIX and it allowed me quite a few interesting job opportunities in my career.
But I was also part of Amiga, BeOS, Windows, Demoscene, Oberon cultures, so in the end I enjoy systems that try new paths.
And even though I don't agree with Rob Pike ideas for Go, I surely agree with his opinion about UNIX.
Yes, microkernels and hybrid kernels too. Yet Linux/FreeBSD/Random Unix Clone are monolithic.
It is the time for a new safer kernel! :)
None of the systems you're suggesting have formal proofs of correctness, and this one not only has such proofs, but is written in C.