12.1.
1 Goals
To design a successful operating system (OS), clear goals are essential. The comparison between PL/I
(which lacked focus) and C (which had a clear goal) demonstrates the importance of having a well-
defined vision. PL/I attempted to be everything for everyone but lacked coherence, while C, with its
focused design for system programming, became hugely successful. This clarity in goals helps guide
design decisions and avoid complexity.
General-Purpose OS Goals:
Define abstractions: Abstractions like processes, files, and memory spaces need to be well thought
out. As technology evolves, newer abstractions (e.g., threads) become relevant.
Provide primitive operations: System calls allow users to manipulate abstractions.
Ensure isolation: Processes and users should be kept separate to prevent interference, while still
allowing controlled sharing. Isolation is crucial for both security and fault tolerance.
Manage the hardware: An OS must handle hardware complexities and provide interfaces for device
management, such as through device drivers.
12.1.2 Why Is OS Design Hard?
Designing an OS is challenging due to several factors, especially as systems become more complex
over time:
Size and Complexity: Modern operating systems consist of millions of lines of code (e.g., Linux and
Windows), making it impossible for any single person to understand the entire system. Interactions
between components (e.g., file systems and memory) can lead to unforeseen issues, unlike more
isolated systems like aircraft carriers.
Concurrency: OSs must manage simultaneous operations (e.g., multiple users or devices), leading to
issues like race conditions and deadlocks that don't arise in simpler, sequential applications.
Hostile Users: Operating systems must handle users trying to break security or steal data, something
most application programs don’t need to worry about.
Selective Sharing: Despite the need for isolation, OSs must allow secure sharing of resources
between users.
Longevity: OSs often need to last for decades (e.g., UNIX, Windows), requiring designers to think
about future-proofing their systems.
Unpredictable Usage: OS designers cannot predict every use case. For example, systems like UNIX
and Windows weren't initially designed for modern tasks like running web browsers or streaming
video.
Portability: OSs must run on diverse hardware platforms, handle varying configurations (e.g., little-
endian vs. big-endian), and support countless I/O devices. This diversity complicates design.
Backward Compatibility: Maintaining compatibility with older systems often constrains modern OS
design. Developers need to preserve compatibility with legacy systems, even when these systems
impose outdated restrictions (e.g., file names or word lengths).
