Operating Systems Course

Lesson 1 • What an Operating System Does

Defines the OS as a resource manager and abstraction layer. Anchors all subsequent topics by clarifying the OS's dual role.

Lesson 2 • System Calls and APIs

Explains how user programs request OS services via system calls. Bridges the gap between application code and kernel execution.

Lesson 3 • OS Boot and Initialization

Covers firmware, bootloaders, and kernel startup sequences. Gives students a concrete picture of how an OS comes to life.

Lesson 4 • OS Architecture Styles

Compares monolithic, microkernel, and hybrid designs. Prepares students to evaluate architectural choices in later chapters.

Lesson 1 • Threads and Lightweight Processes

Distinguishes threads from processes and covers user-level vs. kernel-level threading. Prepares students for concurrency topics ahead.

Lesson 2 • Process Concepts and Lifecycle

Defines processes, PCBs, and state transitions. Establishes the vocabulary used throughout scheduling and synchronization chapters.

Lesson 3 • Multiprocessor and Real-Time Scheduling

Extends single-CPU scheduling to multicore and real-time constraints. Covers load balancing and deadline-driven policies.

Lesson 4 • CPU Scheduling Algorithms

Analyzes FCFS, SJF, Round Robin, and priority scheduling. Students calculate turnaround and waiting times to compare policies.

Lesson 1 • Classic Synchronization Problems

Applies semaphores and monitors to producer-consumer, readers-writers, and dining philosophers. Reinforces correct reasoning about concurrent correctness.

Lesson 2 • Semaphores and Monitors

Introduces counting semaphores and monitor constructs for structured synchronization. Connects to classic problems solved in the next section.

Lesson 3 • Race Conditions and Critical Sections

Identifies data races and defines the critical-section problem. Motivates the need for synchronization primitives introduced next.

Lesson 4 • Deadlock Detection and Prevention

Defines deadlock conditions and covers avoidance, detection, and recovery strategies. Completes the concurrency chapter with liveness guarantees.

Lesson 1 • Virtual Memory and Demand Paging

Introduces lazy loading, page faults, and swap space. Enables programs larger than physical RAM to execute correctly.

Lesson 2 • Segmentation and Memory Protection

Covers segment-based addressing and hardware protection bits. Connects memory isolation to OS security discussed in later chapters.

Lesson 3 • Physical Memory Organization

Covers address spaces, memory hierarchy, and contiguous allocation. Establishes the physical layer before virtual memory abstractions.

Lesson 4 • Page Replacement Algorithms

Analyzes FIFO, LRU, and optimal replacement policies. Students compute page-fault rates to select appropriate algorithms.

Lesson 1 • Direct Memory Access

Explains DMA controllers and their role in offloading bulk transfers from the CPU. Covers cache coherence issues introduced by DMA.

Lesson 2 • Device Driver Architecture

Describes the layered driver model, character vs. block devices, and driver interfaces. Connects hardware specifics to OS-level abstractions.

Lesson 3 • Interrupt and Polling Mechanisms

Compares interrupt-driven and polling I/O for latency and CPU utilization. Explains interrupt vectors and deferred processing.

Lesson 4 • I/O Hardware and Bus Architecture

Covers device controllers, buses, and port-mapped vs. memory-mapped I/O. Establishes hardware context for driver and interrupt discussions.

Lesson 1 • File Operations and Access Methods

Explains open, read, write, and seek semantics at the OS level. Connects system call interfaces to underlying file system structures.

Lesson 2 • Disk Scheduling Algorithms

Compares FCFS, SSTF, SCAN, and C-SCAN policies for disk access. Students calculate head movement to evaluate throughput and fairness.

Lesson 3 • Journaling and Crash Consistency

Introduces write-ahead logging and ordered journaling for durability. Prepares students to reason about file system reliability under failures.

Lesson 4 • Disk Hardware and I/O Basics

Describes disk geometry, seek time, and I/O request lifecycle. Grounds file system performance analysis in physical hardware behavior.

Lesson 1 • Auditing and Intrusion Detection

Introduces system call auditing, log analysis, and anomaly detection. Closes the security chapter with monitoring and response strategies.

Lesson 2 • OS Hardening Techniques

Covers kernel hardening, capability dropping, and sandboxing. Reduces attack surface through principle-of-least-privilege configurations.

Lesson 3 • Authentication and Credential Management

Explains password hashing, tokens, and multi-factor authentication at the OS level. Connects identity verification to access control enforcement.

Lesson 4 • Access Control Models

Covers DAC, MAC, and RBAC models with OS enforcement mechanisms. Students map policies to real permission structures.

Lesson 1 • OS Performance Profiling

Covers tracing tools, flame graphs, and bottleneck identification in OS subsystems. Enables data-driven tuning of scheduling, memory, and I/O.

Lesson 2 • Virtualization and Hypervisors

Covers Type 1 and Type 2 hypervisors, trap-and-emulate, and hardware-assisted virtualization. Connects to container isolation discussed next.

Lesson 3 • Emerging OS Architectures

Surveys unikernels, library OSes, and OS designs for persistent memory. Prepares students to evaluate next-generation system software choices.

Lesson 4 • Distributed OS Concepts

Introduces remote procedure calls, distributed shared memory, and consistency models. Extends single-node OS knowledge to networked environments.