Microkernels are Retarded Object-Orientation

I realized quite a while ago something amusing to me about the microkernel design for the UNIX style
of operating systems: It's an admission that one has a chance of writing correct C language programs
only when they're very small.  The core of QNX was at one time measured in mere hundreds of lines of
code; even I'd concede that such a program can be proven correct trivially in not even a day's work.

The team behind the Linux kernel likes to boast about catching one attempt to insert a backdoor into
the kernel: What was supposed to be two equals signs was instead one.  Now, at some point, I concede
that one line of code can damn an entire system; this should make anyone not stupid seek to minimize
such lines across the system, but the Linux kernel instead has many millions of lines with new flaws
aligning holes in the Swiss cheese regularly popping up and destroying whatever security model fools
claim it to have.  It's very clear how the microkernel is one such shrinking, and one so successful.

Object-Orientation concerns itself with passing messages.  That lowest level of such a system relays
messages between objects and handles any most primitive messages itself.  An object's unable to make
havoc unless allowed through machinations beneath it and beyond its control.  A microkernel concerns
itself also with passing messages between programs seeing private address spaces and other illusions
provided by hardware.  It's fairly clear to me how the microkernel is an inefficient form of object-
orientation: Rather than tiny objects, the antiquated UNIX notion of a process is that smallest unit
permitted under this model, one which needs specialized hardware to enforce its security boundaries.

Worse are the messages themselves under microkernels.  After a cursory glance through documentation,
I found very little of interest: Messages appear to be the contents of an address space belonging to
one process transferred to that of another.  In better Object-Oriented systems such as Smalltalk and
Erlang, a message is a high-level and dynamically typed object; in Smalltalk, the reply to a message
is but an invitation to send yet more messages to yet another object; in Erlang, bedrock is hit more
easily, though the language has a special type specifically for communicating with yet more objects.
I've seen one microkernel that permits passing capabilities to other processes, but that's about it.

With this perspective, the microkernel is less of a good idea in itself and more of a much different
good idea made to carry many bad.  A good language can much more easily enforce security without any
specialized hardware or semantics.  The microkernel approach bolts some of this onto the C language.
.