# Operating System
All Operating System notes →1 — What is an Operating System?
Covers the evolution of operating systems, the goals of an OS, types of operating systems, kernel vs. user space, monolithic vs. microkernel vs. hybrid kernels, system calls, and the boot process overview.
2 — Computer Architecture Essentials
Covers CPU architecture, registers, the memory hierarchy, caches, interrupts, DMA, timers, device controllers, and NUMA basics — the hardware substrate an OS manages.
3 — OS Interfaces
Covers ABI vs. API, POSIX, the shell, the CLI, libraries, executables, the ELF format, and dynamic linking.
1 — Process Fundamentals
Covers the process lifecycle, the process control block (PCB), process states, process context, the process image, and parent/child process relationships.
2 — Process Creation
Covers fork(), exec(), wait(), copy-on-write, zombie processes, orphan processes, and daemons.
3 — Context Switching
Covers kernel mode vs. user mode, saving registers, scheduling context, context switch cost, and process switching.
4 — Interprocess Communication
Covers pipes, named pipes, shared memory, message queues, signals, sockets, RPC, and mmap().
1 — Threads
Covers threads vs. processes, the thread lifecycle, user threads, kernel threads, thread pools, and thread-local storage.
2 — Multithreading
Covers thread scheduling, thread creation models, thread safety, false sharing, and CPU affinity.
3 — Synchronization Primitives
Covers mutexes, spinlocks, read-write locks, semaphores, condition variables, barriers, and futexes.
1 — Race Conditions
Covers critical sections, atomic operations, compare-and-swap (CAS), load-link/store-conditional (LL/SC), and memory visibility.
2 — Deadlocks
Covers the necessary conditions for deadlock, prevention, avoidance, detection, recovery, and the Banker's algorithm.
3 — Classical Synchronization Problems
Covers the dining philosophers, readers-writers, producer-consumer, sleeping barber, and cigarette smokers problems.
4 — Memory Ordering
Covers CPU reordering, compiler reordering, acquire/release semantics, sequential consistency, memory fences, and happens-before relationships.
1 — Scheduling Fundamentals
Covers scheduling goals: throughput, turnaround time, waiting time, response time, and fairness.
2 — Scheduling Algorithms
Covers FCFS, SJF, SRTF, round robin, priority scheduling, multilevel queue scheduling, MLFQ, and lottery scheduling.
3 — Modern Scheduler Design
Covers the Linux Completely Fair Scheduler (CFS), the Windows scheduler, CPU affinity, load balancing, and NUMA-aware scheduling.
1 — Memory Fundamentals
Covers logical vs. physical memory, address spaces, relocation, protection, and memory allocation basics.
2 — Paging
Covers pages, frames, page tables, multi-level paging, huge pages, and the translation lookaside buffer (TLB).
3 — Virtual Memory
Covers demand paging, page faults, swapping, working sets, and thrashing.
4 — Page Replacement
Covers FIFO, LRU, the clock algorithm, second chance, LFU, and Belady's anomaly.
5 — Memory Allocation
Covers the buddy allocator, the slab allocator, the heap, malloc(), and fragmentation.
1 — File System Basics
Covers files, directories, metadata, inodes, and links.
2 — File System Internals
Covers journaling, copy-on-write, and the internals of ext4, XFS, Btrfs, NTFS, and APFS.
3 — Storage Management
Covers disk scheduling, RAID, SSD internals, TRIM, and the filesystem cache.
1 — I/O Architecture
Covers blocking I/O, non-blocking I/O, buffered I/O, DMA, and device drivers.
2 — Event Driven Systems
Covers select(), poll(), epoll(), kqueue(), IOCP, and io_uring.
1 — Operating System Security
Covers user accounts, permissions, ACLs, capabilities, SELinux, and AppArmor.
2 — Isolation
Covers chroot, namespaces, cgroups, containers, and sandboxing.
1 — Linux Kernel Overview
Covers the Linux kernel architecture, the scheduler, the memory manager, the VFS, and the networking stack.
2 — Linux Process Management
Covers procfs, sysfs, signals, jobs, nice, and cgroups.
3 — Linux Performance
Covers top, htop, vmstat, iostat, perf, strace, ltrace, and eBPF basics.
1 — OS in Cloud Computing
Covers virtual machines, hypervisors, containers, microVMs, and resource isolation.
2 — Operating Systems for Kubernetes
Covers cgroups, namespaces, OverlayFS, the PID namespace, the network namespace, and the mount namespace.
3 — Operating Systems for Observability
Covers process metrics, CPU metrics, memory metrics, I/O metrics, context switches, syscalls, and eBPF observability.
1 — Lock-Free Programming
Covers compare-and-swap (CAS), the ABA problem, hazard pointers, and RCU.
2 — NUMA Systems
Covers memory locality, CPU pinning, and NUMA-aware scheduling.
3 — Kernel Synchronization
Covers spinlocks, RCU, seqlocks, wait queues, softirqs, and tasklets.
4 — High Performance I/O
Covers zero-copy I/O, sendfile(), splice(), mmap(), and io_uring.
5 — Emerging Operating System Technologies
Covers unikernels, library OSes, WebAssembly runtimes, confidential computing, and secure enclaves.
1 — Classic Interview Problems
Covers producer-consumer, readers-writers, dining philosophers, deadlock detection, memory allocation, page replacement, and scheduling problems as interview prompts.
2 — System Design Connections
Covers how threads in web servers, process models, database memory management, scheduler impact on latency, caching/paging, and storage systems connect back to OS fundamentals.
3 — Linux Interview Questions
Covers common Linux questions, debugging scenarios, process investigation, memory leak investigation, high CPU diagnosis, the OOM killer, and kernel panic basics.
4 — MAANG Interview Masterclass
Covers frequently asked questions, whiteboard explanations, common pitfalls, optimization techniques, and mock interview scenarios.
Operating Systems for MAANG Interviews
A book-shaped table of contents for operating systems at MAANG interview depth: foundations through processes, threads, concurrency, CPU scheduling, memory management, file systems, I/O, security & isolation, Linux internals, cloud/Kubernetes/observability, advanced kernel topics, and interview preparation — cross-linking existing sre/linux-networking, kubernetes-security, and patterns/concurrency notes instead of duplicating them.