Notes on Operating Systems: Concepts & Practical Exercises

Overview

Notes on Operating Systems combines clear conceptual explanations with practical exercises designed to build a working understanding of how operating systems coordinate hardware and software. Based on teaching notes by Dror G. Feitelson, the guide emphasizes core systems concepts—process and thread management, memory and virtual memory techniques, file-system structure, I/O behavior, CPU scheduling, synchronization, and security—paired with projects and simulations that make abstract mechanisms tangible.

Learning outcomes

• Develop a precise mental model of process lifecycle, context switching, and how threads enable concurrent execution.
• Understand memory management fundamentals, including paging, segmentation, address translation, and trade-offs in page-replacement algorithms.
• Explain file-system design choices such as metadata organization, directory structures, linking, and techniques for ensuring consistency after crashes or concurrent updates.
• Recognize I/O subsystem architecture, driver interactions, buffering strategies, and the differences between synchronous and asynchronous I/O.
• Analyze protection and access-control mechanisms, threat models at the OS layer, and basic defenses that mitigate privilege escalation and data leakage.
• Translate theory into practice by building simulators and small implementations that reveal runtime behavior and algorithmic trade-offs.

Approach and pedagogy

The notes follow an explanation-first pedagogy: concepts are introduced with concise definitions and illustrative diagrams, followed by worked examples and analytic discussion of algorithmic trade-offs. The text frequently maps abstractions to Unix-like behaviors, showing how kernel data structures and system calls implement high-level policies. Emphasis is placed on reasoning about performance, correctness, and complexity rather than on platform-specific minutiae.

Hands-on exercises and projects

Exercises range from focused problems that test core intuition to multi-step projects that simulate OS components. Typical assignments include scheduler and paging simulators, implementations of directory lookup or hashed file access, simple interprocess communication emulations, and concurrency-safe renaming/linking schemes. Each exercise offers suggested steps, testing scenarios, and visualization tips so learners can observe internal state changes and validate designs.

Intended audience

The guide is well suited for undergraduate and graduate students in systems courses, instructors looking for lecture and lab material, and software engineers or system administrators seeking deeper systems-level reasoning. It supports both self-study and structured classroom use: conceptual sections prepare readers for hands-on work, while projects serve as practical assessments or portfolio pieces.

Study recommendations

• Read concept sections and then solve the paired exercises to reinforce understanding.
• Implement lightweight simulators (schedulers, page replacement, basic file-system operations) to observe algorithmic trade-offs under controlled inputs.
• Pair theoretical work with experiments on a Unix-like system to connect abstractions to system calls, kernel logs, and administrative tools.
• Create simple diagrams of control flow and key data structures (process tables, page tables, inode layouts) to aid retention and debugging.

Key terms highlighted

• Process / Thread: execution contexts with distinct scheduling and memory semantics.
• Context switch: saving/restoring CPU and kernel state to enable multitasking.
• Paging / Virtual memory: mechanisms for address translation and working-set management.
• Semaphore / Mutex: synchronization primitives used to coordinate concurrent access.
• File descriptor / Inode: runtime and on-disk abstractions for open files and metadata.

Why use these notes

By blending rigorous explanations with practical exercises, the notes help learners move from conceptual understanding to actionable skills: designing resource-management algorithms, reasoning about concurrency hazards, and diagnosing system-level problems. The hands-on projects are particularly useful for building demonstrable competencies for coursework, research, or interviews focused on systems design.

Quick FAQ

Q: Should I implement every project?
A: Prioritize simulations that reveal dynamic system behavior—paging, scheduling, and synchronization. Smaller implementations deepen intuition; complete projects are valuable for mastery and assessment.

Tip: Combine reading with interactive experiments on a Unix-like system and discuss solutions with peers or online study groups to accelerate learning and uncover alternative designs.