A Praise To Unix

MotyaKatz writes: "ZDnet has an article from Evan Leibovitch which he calls The Unix Phoenix. As he states, 'I come not to bury Unix, but to praise it'. He mostly deals with the aspects of Unix surviving during Linux growth."

Comments

Re:Beyond the UNIX model

[Kaufmann]

Congratulations, you've just reinvented Genera. Or Squeak, if you like "objects" better than "functions", or if you want to run it on top of an existing OS, or if you don't want to be tied to a specific (dead) hardware architecture. And ETH Oberon is yet another OS based on the same ideas. In any case, that you don't see it everywhere doesn't mean it hasn't been invented yet - and that it's (not) popular doesn't mean it's (not) good. (For the first case, see Haskell - "groundbreaking" parametric polymorphism in the late 80s; for the second case, see Windows.)

In any case, it will do you no good to use CORBA as it is today. Instead, use a dynamic, high-level language for user-level functionality, and just let applications people deal with objects in the language's natural idiom, making no syntactic distinction between "local" and "remote" objects.

In any case, have fun, and don't let those Unix weenies tell you that systems research is dead - if it were for the conformists and the naysayers, we'd be rendering polygons with abaci!

Beyond the UNIX model

[Animats]

As an old-line secure operating system designer, I've been thinking about where to go after Linux. My current thinking is along the following lines:

• The main job of the OS is to facilitate protected inter-object communication. What's needed is the ability to make a CORBA-type call almost as fast as an ordinary subroutine call. Applications can then be built as lots of little objects in different protection domains. (For example, anything that looks like executable web content needs to be sandboxed.)
• Processes are not a primitive. The basic primitives are threads and address spaces. Threads can cross address space boundaries through call gates. This replaces inter-process communication.
  Why? Because when one object calls another, what you want is a subroutine call. Most OSs make you marshall the parameters into a buffer, make an IPC call that works like an I/O operation with one or more process switches, and then unmarshall on the receiving side. On return, these steps are repeated. All this is time-consuming. This is the main reason software isn't usually constructed out of little objects in different address spaces - it's too slow. Fix that problem, and clean design becomes efficient.
  How? The MMU and protection hardware in x86 machines has lots of stuff that's almost never used, like call gates and variable-length segments. If used properly, cross-address-space calls can be quite efficient. You don't have to copy everything, and you don't have to give up security to get performance. (Or so the data books indicate. I'm assuming all that stuff, like call gates and rings of protection, actually works.)
• With fast, secure object calls, the pressure to dump stuff into the kernel disappears. File systems, networking, and drivers move outside the kernel.
• Security is applied at the object call setup level. Look at the CORBA security model for a starting point. Security decisions are made during object loading and call gate setup. Once it's been established that object A can call method M of object B, no further OS intervention is required for that call.
• Very little code is trusted. Writing a mail handler? Just about the only trusted part is the object that handles putting the mail in a local mailbox. A web browser? Maybe bookmark handling and some certificate functions; everything else is sandboxed. Most code needs no more privileges than an untrusted Java applet.

This is an idea I've been kicking around for a while. With the GNOME crowd going CORBA, this is starting to look more practical. An OS like this will have something to run on it.

Comments?

Linux rehashs 70s era OS.. wow, special.

[weezel]

I think the real future of Unix looks something like MacOS X, not Linux.

The communinity development model so far has been unable to do anything other than kludge together something as important of the GUI. Gnome and KDE are just the first iteration towards a useful user experience.

Apple, on the other hand, has taken the core of a Unix system and used a single vision/goal/thingy to synthesize something new and exciting from two fairly stagnant OSs. Borrowing from the low level functionality of Unix and the elegant UI of MacOS they have made a real step forward.

Linux so far is a step sideways at best.