Design Principles of an OS

Operating systems are developed based on 3 fundamental design approaches.

1. Modularity
2. Layering
3. Extensibility

Modularity Approach

This is a principle where the huge system is broken down into separate smaller self contained modules. these modules will handle an specific set of tasks only. (e.g., file systems, network protocols, memory management).

These modules are loaded into kernel memory dynamically by the core kernel. The boot operations and other core functionalities are handled by core kernel.

Advantages

• This approach has a major performance improvement since the modules can directly talk to each other by high speed internal APIs without going thru layers.

• Since these modules are loaded dynamically, the whole kernel does not need to be rebuilt when a module is updated

Examples

• Linux .ko modules
• MacOS kext modules (Deprecated)

Layered Approach

This approach makes the entire architecture vertical thru layers. Not an ideal pattern and not widely used in modern era.

This is very similar to the Layered Architecture in networking. Layer 3 uses services from Layer 2, and so on down the hill. Each layer is independently testable assuming the layers beneath are fully working.

Advantages

• Layers are modular and easy to test. Same as in networking.
• Implementation details of the lower layers are abstracted from the higher ones.

Disadvantages

• All requests to layer 1 that comes from layer 5 must pass through all in the middle. This creates a performance overhead.
• Difficult to implement since things like storage in lower layers might need to use memory which is in higher layers.

Examples

• THE Multiprogramming System (historical)
• early Windows NT Hardware Abstraction Layer (HAL).

Extensibility

This is an approach operating systems use to make them future proof. An operating system must be able to handle hardware that might come in future. Also operating systems should be able to update into newer modern versions over time. When doing these, the existing functionalities should not be broken.

This is done by keeping the core simple and providing well-defined interfaces. Things like micro-kernel architectures are built this way. In a microkernel, non-essential services (like file systems and network protocols) are removed from kernel space and moved into user space as server processes.

Advantages

• Adding a new protocol or file system simply means launching a new user-space server program—no modification to kernel code is required.
• If an extended user-space service crashes (e.g., a custom print driver), it crashes in user mode without bringing down the entire operating system.

Examples

• QNX (used in automotive systems)
• Minix
• Windows NT (uses extensible system APIs).