Operating System Course

Lesson 1 • OS Boot Process and Initialization

Covers firmware, bootloader, and kernel initialization sequences. Students understand the steps that bring an OS to a running state.

Lesson 2 • Historical Evolution of Operating Systems

Traces OS development from batch systems to modern multicore designs. Provides context for why current design decisions exist.

Lesson 3 • 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 4 • System Calls and OS Interfaces

Explains how user programs request OS services through system calls. Connects interface design to security and performance boundaries.

Lesson 1 • Process Creation and Termination

Covers fork, exec, and exit semantics for process management. Students trace parent-child relationships and resource cleanup.

Lesson 2 • Multiprocessor and Real-Time Scheduling

Extends scheduling to multicore and real-time constraints. Students apply rate-monotonic and EDF algorithms to deadline-driven workloads.

Lesson 3 • Threads and Lightweight Processes

Distinguishes threads from processes and examines threading models. Students evaluate when multithreading improves responsiveness and throughput.

Lesson 4 • Process Concepts and Lifecycle

Defines a process as a program in execution with associated state. Establishes the lifecycle model used throughout scheduling discussions.

Lesson 1 • Mutex Locks and Semaphores

Covers binary and counting semaphores alongside mutex semantics. Students implement producer-consumer and readers-writers solutions.

Lesson 2 • Monitors and Condition Variables

Presents monitors as a high-level synchronization construct. Students use condition variables to implement bounded-buffer solutions.

Lesson 3 • Concurrency Fundamentals

Introduces shared-memory concurrency and the critical-section problem. Establishes why uncontrolled access produces nondeterministic bugs.

Lesson 4 • Lock-Free and Wait-Free Algorithms

Introduces atomic hardware instructions and non-blocking data structures. Students compare lock-free approaches to mutex-based designs.

Lesson 1 • Physical Memory Organization

Covers address spaces, memory hierarchy, and allocation strategies. Provides the physical foundation before virtual memory is introduced.

Lesson 2 • Segmentation and Combined Schemes

Presents variable-size segments and segment-plus-paging hybrids. Students compare segmentation benefits against paging simplicity.

Lesson 3 • Paging and Page Tables

Explains fixed-size page frames and multi-level page table structures. Students calculate physical addresses from virtual addresses.

Lesson 4 • Page Replacement Algorithms

Analyzes FIFO, LRU, Clock, and optimal replacement policies. Students compute page-fault rates and identify Belady's anomaly.

Lesson 1 • Device Driver Architecture

Explains the layered driver model and kernel-driver interface. Students trace a read request from user space to hardware.

Lesson 2 • I/O Buffering and Caching

Covers single, double, and circular buffering strategies. Students analyze how the page cache reduces disk access latency.

Lesson 3 • I/O Hardware and Bus Architecture

Describes controllers, ports, and bus protocols connecting devices to the CPU. Establishes the hardware model underlying all I/O software.

Lesson 4 • I/O Performance and Optimization

Applies asynchronous I/O, I/O scheduling, and vectored I/O techniques. Students measure and improve I/O throughput in realistic scenarios.

Lesson 1 • RAID and Storage Reliability

Covers RAID levels 0 through 6 and their fault-tolerance properties. Students calculate storage efficiency and rebuild costs.

Lesson 2 • File System Concepts and Interfaces

Defines files, directories, and metadata abstractions. Connects user-visible file operations to underlying OS data structures.

Lesson 3 • File System Implementation

Covers inodes, block allocation, and free-space management. Students trace how a file path resolves to disk blocks.

Lesson 4 • Journaling and Log-Structured File Systems

Explains write-ahead logging and crash-consistency guarantees. Students compare journaling modes and their performance trade-offs.

Lesson 1 • Protection Mechanisms and Access Control

Covers access control matrices, capability lists, and ACLs. Students model least-privilege policies for processes and files.

Lesson 2 • Auditing, Logging, and Intrusion Detection

Explains kernel audit frameworks, log integrity, and anomaly detection. Students design audit policies that balance security and performance.

Lesson 3 • Kernel Exploit Mitigations

Covers ASLR, stack canaries, NX bits, and SMEP/SMAP protections. Students evaluate mitigation effectiveness against known attack classes.

Lesson 4 • Authentication and Identity Management

Examines password hashing, tokens, and multi-factor authentication. Students assess credential storage and session management risks.

Lesson 1 • Containers and OS-Level Virtualization

Explains namespaces, cgroups, and union file systems enabling containers. Students contrast container isolation with full VM isolation.

Lesson 2 • Distributed OS and Remote Procedure Calls

Introduces distributed transparency, naming, and RPC semantics. Students design fault-tolerant distributed services using OS primitives.

Lesson 3 • OS Performance Analysis and Tuning

Applies profiling, tracing, and benchmarking to identify OS bottlenecks. Students use system metrics to guide kernel parameter tuning.

Lesson 4 • Real-Time and Embedded OS Design

Covers hard vs. soft real-time constraints, priority inversion, and RTOS kernels. Students configure schedulers for deterministic response times.