I am afraid you are the one who is talking out of his ass now.
A quick search of Google turns up this:
The unix paradigm includes a fundamental division between "kernel space" and "user space". Kernel space is memory in which the uncompromisingly crafted kernel interacts directly with the hardware, and where constraints on what a program can have in terms of hardware (memory, access to the disk drive, access to the video card, etc) are enforced. All other programs reside in "user space," and each has a segment of memory that belongs to it and it
alone. If something goes wrong with an individual process, it cannot affect other processes, nor can it corrupt what is going on within the kernel. All requests for memory go through the kernel, and if the kernel detects an attempt to access memory the requesting program does not normally have permission to read or write, the event is a SEGFAULT (A fault caused by accessing an invalid memory segment) and the program crashes-- but not the kernel, which usually just tidies up and keeps right on running.
In contrast, Windows does not have quite the same rigid distinctions. Individual programs *can* reach all the way down to
address the hardware directly, where one bug can cause all kinds of mischief. Microsoft made this decision back in Windows 3.0 because they assumed three things: one, that direct access to the hardware would make their software faster and therefore more game- and video-processing friendly; two, that for the desktop the assumption of "one machine, one user" meant that no user needed the security supplied by rigid address segmentation (no user would ever be running code that would compromise his system, right?); and three, desktop commodity software could use this performance increase because it did not need the stability of kernel-mediated address segmentation.
Another, similar example of this kind of division can be found in the X windows system. "Windows" is a monolithic program-- the OS, the windowing system, and individual programs running at any given time are all sharing a single common core. But, assuming that a small team (with a vast sea of bug-catchers) has made the kernel stable, another small team (with a similarly vast sea of bug-catchers) can make X stable. But X and X programs don't share a common core. Instead, X programs make requests to X-- "draw a window", "put this text here", "update this window with this frame", and the X program decides if the request made is possible and legal. Individual X programs can fail without tearing down X.
Also, Windows has a single point of failure - the registry - which is written to and read from almost constantly - where *nix has seperate config files and if one fails the rest continue to work.