Before you can compare monolithic vs microkernel vs hybrid, you must own a handful of ideas the parent note leans on without slowing down. We build each one from nothing: plain words → a picture → why the topic needs it.
The picture: a sandwich. Top slice = your apps. Bottom slice = the hardware. The OS is the filling that everything passes through.
Why the topic needs it: "OS structure" is about how we organize the filling. You cannot argue about organizing something until you know what it is made of.
The picture: a long numbered street. Each program owns a fenced-off block of houses; it may walk freely inside its own block but the fence stops it from wandering into a neighbour's.
Why the topic needs it: the whole reliability argument hinges on this fence. If two services share one address space, a bug in one can scribble over the other's memory. If they live in separate address spaces, the fence protects them. "Monolithic = shared address space" and "microkernel = separate address spaces" is the entire reliability story in one sentence — but only if you already picture the fence.
The CPU itself enforces the fence. It runs in one of (at least) two modes.
Why the topic needs it: this is the dial every OS design turns. Putting a service in the inner ring makes it fast (no permission checks between friends) but dangerous (its bugs can wreck everything). This is prerequisite reading in Kernel mode vs User mode.
If user-mode code can't touch hardware, how does your app ever read a file? It asks the kernel.
Why the topic needs it: every time a request hops from user mode to kernel mode (or back), that is one crossing, and crossings cost time. The parent's whole speed argument is "count the crossings." See System calls and traps.
Once you know services may live on either side of the fence, there are exactly two ways they can communicate.
The picture: function call = passing a note to the person sitting next to you. IPC = mailing a letter across town — envelope, postage, delivery time.
Why the topic needs it: monolithic kernels use function calls (fast); microkernels use IPC (slow). That single difference is the speed axis of the whole comparison. Details in Inter-process communication (IPC).
Why the topic needs it: IPC between two user-mode servers usually forces a context switch (the CPU must actually swap from the sender process to the receiver process). This is why each microkernel crossing costs so much — it is not just a doorway, it's a whole change of who is on the CPU. See Context switching.
Read it top-down: hardware needs a memory fence, the fence needs privilege modes, privilege needs a doorway (traps), doorways get counted, the count feeds the cost model, and the cost model plus the driver-risk idea is exactly what lets you compare the three structures.
