Questions: Introduction to Operating Systems

Question 1

A program compiled on macOS runs without modification on a new Mac that uses a completely different SSD controller and storage architecture. Which fundamental role of the operating system makes this possible?

• A. Resource management — the OS schedules the program's disk requests efficiently
• B. Protection — the OS prevents the program from overwriting the SSD controller firmware
• C. Abstraction — the OS presents a uniform interface (like a file system) that hides hardware differences
• D. Scheduling — the OS gives the program CPU time regardless of hardware generation

Answer: (C)

The program doesn't need to know about the SSD controller because the OS provides an abstraction layer — a uniform system call interface for file operations like `open()`, `read()`, and `write()`. The same call works whether the underlying storage is a spinning disk, NVMe SSD, or network filesystem. This is abstraction: hiding hardware complexity behind a consistent interface. Resource management and scheduling are real OS roles, but they don't explain hardware portability — abstraction does.

Question 2

Without OS memory protection, what would happen when multiple programs run simultaneously on the same computer?

• A. Programs would run more slowly because they must negotiate access to shared memory
• B. Programs could accidentally or maliciously read and overwrite each other's memory, corrupting data and potentially crashing each other
• C. The computer would only allow one program to run at a time until protection was re-enabled
• D. Programs would be unable to access the network or disk without kernel permission

Answer: (B)

Memory protection is what makes multitasking safe. Without it, any program could read or write any address in physical memory — including addresses belonging to other programs or the OS itself. A bug in one program could overwrite another's data; a malicious program could steal passwords from a browser's memory; a crash in one program could corrupt the OS. The OS uses hardware mechanisms (memory management units, privilege levels) to give each program its own protected address space, invisible to others.

Question 3

The system call interface is the boundary between user-level programs and the privileged OS kernel, allowing programs to request hardware services without directly accessing hardware.

• T. True
• F. False

Answer: True

System calls are the mechanism by which user-space programs (running with limited privileges) request services from the OS kernel (which runs with full hardware access). When a program calls `write()` to save a file, it doesn't write directly to the disk — it invokes a system call that crosses the privilege boundary into the kernel, which validates the request and performs the hardware operation. This boundary is fundamental to both abstraction and protection: programs can use hardware capabilities they don't understand and can't directly access.

Question 4

Without an operating system, well-written programs that are carefully designed to avoid conflicts could safely share hardware resources simultaneously.

• T. True
• F. False

Answer: False

Even perfectly written programs cannot safely share hardware without an OS mediator. Hardware resources like CPU time, physical memory addresses, and I/O device registers have no built-in sharing mechanisms — they simply do whatever the last instruction told them to do. Two programs both writing to physical memory address X will simply overwrite each other, regardless of intent. Safe sharing requires arbitration (deciding who goes next), isolation (enforcing boundaries), and abstraction (presenting virtual resources) — all of which require the OS as an active intermediary, not just good intentions from program authors.

Question 5

Why can't application programs simply manage hardware themselves, and what problem does the OS solve that software discipline alone cannot?

Model answer: Hardware resources are shared and have no inherent concurrency control. Without an OS, two programs writing to the same memory address, or two programs sending data to a printer simultaneously, produce corrupted results regardless of how carefully each program was written. The OS solves this by acting as an exclusive hardware manager: only the OS kernel directly accesses hardware, and it serializes and arbitrates all requests. Programs interact with virtual abstractions (virtual memory, files, virtual CPUs) that the OS manages, preventing conflicts by construction.

The core issue is that hardware is fundamentally shared and non-concurrent: a CPU can only execute one instruction at a time, a memory address can only hold one value, a disk head is in one position. The OS creates the illusion of exclusive, concurrent access through virtualization — each program thinks it has the whole machine, but the OS is actually time-slicing, memory-mapping, and buffering to create that illusion safely. This isn't something programs can do for each other; it requires a privileged mediator with direct hardware control.