Ten Philosophical Principles of Operating System Design

Operating system design pursues four primary goals: ensuring the OS itself runs correctly, providing as many functions as possible, maximizing efficiency, and, while doing so, striving for fairness.

Principle 1 – Layered Architecture: A hierarchy prevents cyclic calls and deadlocks, improving reliability. Functions are divided into modules where each lower layer offers services to the layer above and can only be controlled by its direct superior. Common examples include the 3‑tier web architecture (presentation, business logic, data access), MVC, Alibaba’s four‑layer model, domain‑driven design layers, cloud IaaS/PaaS/SaaS stacks, and big‑data platform layers.

Principle 2 – No Absolute Right or Wrong: Different OS scheduling strategies (e.g., round‑robin vs. priority scheduling) are context‑dependent; none is inherently correct, only more suitable for certain fairness or hierarchy goals.

Principle 3 – Lazy Philosophy: Techniques such as fork and copy‑on‑write create a child process without immediately copying address spaces, deferring duplication until a write occurs. This lazy copying saves resources but incurs performance costs when copies are finally made.

Principle 4 – Let the Burden Fall on People: OSes protect their own metadata (e.g., directory structures) but often leave user data unprotected, shifting responsibility to users. Similarly, modern commercial OSes avoid dynamic deadlock avoidance, leaving deadlock handling to applications.

Principle 5 – Leave Room: Filesystem records reserve extra bytes (e.g., 10‑byte reserved space in DOS directory entries) to allow future extensions without redesign, a practice later utilized in Windows 98.

Principle 6 – Illusion of Infinite Memory: Users perceive a linear, virtually unlimited address space, while physical memory is limited; the OS abstracts this discrepancy.

Principle 7 – Space‑Time Trade‑off: Large structures like page tables are hierarchically paged, keeping only portions in RAM and storing the rest on disk, which reduces space at the cost of additional translation time; TLBs mitigate this latency.

Principle 8 – Separation of Policy and Mechanism: Scheduling policies can be user‑configurable while the OS provides the underlying mechanisms, mirroring design separations in UI, security standards, and communication protocols.

Principle 9 – Simplicity Is Beauty: As Einstein said, solutions should be as simple as possible but not simpler; OSes adopt simple byte‑stream file storage rather than more complex structures.

Principle 10 – Moderation: The final principle advises avoiding extremes, echoing the Chinese doctrine of the “middle way” to ensure balanced, sustainable system design.