The Traditional OS:

Traditional single-CPU operating systems share a number of common characteristics. Be careful with the book here in the sense that the authors do gloss over a number of concepts.
Characteristics often associated with a traditional OS:

• A single cpu
• System resources are shared among many users
• A virtual machine is implemented, in which each process perceives the system as being exclusive to the process. In this sense,
  • Applications are protected from each other
  • The operating system maintains control over resources, often through several modes of operation in the CPU (the book mentions two modes):
    • Kernel mode: CPU mode in which the whole computer and all instructions are available. This is available only to privileged processes (e.g. the code that implements the kernel).
    • User mode: CPU mode in which restrictions are placed on access to certain resources. This is available to any process.

The problem with having a kernel and user mode of operation is that in many operating systems, all of the operating system code tends to run in kernel mode where only a small portion of it is really needed to run that way. The point is that is results in a "large, monolithic" model of OS in which it's hard to maintain due to a lack of modularity, etc., poor reliability for the same reasons, difficult to upgrade, and so forth.
One alternative given here is the microkernel approach:

• Two parts of the OS:
  1. The microkernel, which contains kernel mode code yet is small, modular, executes quickly, etc.
  2. The user-mode modules for managing resources. It is often true that portions of the operating system's functionality can be executed outside of kernel mode. For example, the printing system can be managed entirely as a user-level subsystem without adversely affecting the operation of the system as a whole.
• Communication in this model is via message passing (even though shared memory may be available).

The main advantage of this approach is its flexibility. It's relatively easy to replace modules, providing performance upgrades, etc. User-level modules can theoretically be moved to other machines. The implication there is that this model is more suitable to being adopted as a distributed OS. In fact, its message-passing communication, which is one of its disadvantages, is another indicator of its suitability for distributed implementation.
Its disadvantages have to do with familiarity and performance. The familiarity aspect is that it's not. People fear change. The performance has to do with the message passing in the form of extra communication (among somewhat separated modules, instead of a unified monolithic structure), which results in a performance loss.