Learning path

Operating systems

Study CPU scheduling, page replacement, deadlock avoidance, synchronization, and virtual memory through small simulations.

About this subject

An operating system manages the hardware for every program: it decides which process runs, hands out memory, and lets programs share resources without corrupting each other. Its main ideas are processes and threads, scheduling, memory management, synchronization, and files.

This path simulates the core algorithms: first-come first-served, shortest-job-first, and round-robin scheduling, page replacement policies, the banker's algorithm for deadlock avoidance, locks and the bounded buffer, and address translation. Each lesson uses a small, complete program that runs on its own. Python has the full sequence. The other languages listed below add lessons that use that language's own idioms and standard library, such as Java threads, C++ smart pointers, C# LINQ, or Node.js streams, and appear only for the topics the language supports. The programs are simplified models chosen to make an idea visible, so they are a foundation for further study rather than a replacement for a full course or for production-grade software.

Before you start: Programming fundamentals, lists and dictionaries, and basic data structures.

1
Python
Readable code for automation, data, and first programs.
CPU scheduling: FCFS and shortest job first
Compare average waiting time when the scheduler runs jobs in arrival order or by shortest burst.
Round-robin scheduling and the time quantum
Share the CPU fairly by running each job for at most one quantum, then rotating the queue.
Page replacement: FIFO, LRU, and optimal
Count page faults for three replacement policies and see Belady's anomaly with FIFO.
Deadlock avoidance with the banker's algorithm
Grant a resource request only if the resulting state is safe: every process can still finish.
Synchronization: locks and the bounded buffer
Protect shared data with a lock and coordinate a producer and consumer with a blocking queue.
Virtual memory: address translation with a page table
Split a virtual address into page number and offset and map it to a physical frame.
2
C
Learn memory, pointers, and efficient systems programming.
C: simulating round-robin scheduling
Give each job a fixed time slice in turn and compute the turnaround time of each.
C: protecting a shared counter with a POSIX mutex
Run two threads that increment one counter and use pthread_mutex_lock so no update is lost.
3
C++
Build fast applications with modern types and classes.
C++: page replacement with FIFO and LRU
Count page faults for two replacement policies and see Belady's anomaly.
C++: protecting shared data with std::mutex
Run two threads that increment one counter and use a lock to keep every update.
4
Java
Understand object oriented programs and the JVM.
Java: simulating round-robin CPU scheduling
Rotate jobs through a ready queue with a fixed time slice and record when each one finishes.
Java: mutual exclusion with synchronized
Protect a shared counter from lost updates when two threads increment it.
5
C#
Build typed applications on .NET.
C#: first-come-first-served versus shortest-job-first
Compare the average waiting time of two scheduling policies for the same set of jobs.
C#: protecting shared state with lock
Start two threads that update one counter and use lock so that no update is lost.
6
JavaScript
Add behavior to the web and build applications.
JavaScript: the event loop as a cooperative scheduler
Predict the order in which synchronous code, nextTick, promises, and timers run in Node.js.
JavaScript: LRU replacement with a Map
Use Map's insertion order to evict the least recently used page and count page faults.
7
TypeScript
JavaScript with static types for dependable code.
TypeScript: a process lifecycle as a typed state machine
Allow only legal transitions between process states and reject the rest.

About this subject

Python

CPU scheduling: FCFS and shortest job first

Round-robin scheduling and the time quantum

Page replacement: FIFO, LRU, and optimal

Deadlock avoidance with the banker's algorithm

Synchronization: locks and the bounded buffer

Virtual memory: address translation with a page table

C

C: simulating round-robin scheduling

C: protecting a shared counter with a POSIX mutex

C++

C++: page replacement with FIFO and LRU

C++: protecting shared data with std::mutex

Java

Java: simulating round-robin CPU scheduling

Java: mutual exclusion with synchronized

C#

C#: first-come-first-served versus shortest-job-first

C#: protecting shared state with lock

JavaScript

JavaScript: the event loop as a cooperative scheduler

JavaScript: LRU replacement with a Map

TypeScript

TypeScript: a process lifecycle as a typed state machine