Operating Systems & Systems Programming Topics
Covers operating system fundamentals and systems programming topics, including process management, memory management, file system interfaces, inter-process communication, low-level kernel interactions, and system call interfaces (e.g., fork, exec, opendir, stat) across Unix/Linux and other OS environments.
File Systems & Storage Internals
How file systems organize data on storage: inodes, directories, file descriptors, hard vs. symbolic links, and metadata. Covers on-disk structures, journaling and consistency, the buffer/page cache, mounting and the virtual file system layer, and how block devices and storage stacks sit beneath the file system.
Interprocess Communication (IPC)
Mechanisms that let separate processes exchange data and coordinate: pipes and named pipes, message queues, shared memory, signals, and Unix domain sockets. Covers the trade-offs between IPC methods (throughput, latency, complexity, ordering) and when each is appropriate for a given systems design.
Linux System Administration & Networking
Operating and troubleshooting Linux hosts: users and groups, packages, cron, logging, and the /proc and /sys interfaces, together with host-level networking such as interfaces, routing, DNS resolution, ports, and firewall rules. Covers diagnosing connectivity and configuration issues with standard tooling on a running Linux system.
Kernel Architecture & OS Internals
How an operating system kernel is structured and what it is responsible for: kernel subsystems (scheduler, memory manager, drivers, interrupt handling), kernel vs. user space and the cost of crossing between them, and the boot and initialization path. Includes the core mechanisms the kernel provides: process and thread lifecycle (creation, zombies and orphans, uninterruptible sleep) and context switching, processes vs. threads as an architectural choice, CPU scheduling (CFS, priorities, preemption models, real-time policies on a general-purpose kernel), virtual memory (address translation, multi-level page tables and entry formats, TLB misses and shootdowns, page faults, copy-on-write, memory-mapped files, userfaultfd, swapping, page replacement, kernel allocators, process address-space layout, page-level protection such as NX and ASLR as mechanisms, hugepages, page coloring, overcommit and the OOM killer as kernel mechanisms), interrupts and softirqs, and how loadable modules and device drivers extend the kernel. Includes worked exercises such as page-replacement traces, address-translation arithmetic and small page-table, TLB or scheduler simulations. Covers the concepts and internals, not microcontroller interrupt and ISR design, RTOS and real-time scheduling theory, day-to-day host administration, system-call and POSIX API semantics, OS-level performance tuning, or forensic and security analysis of a host.
Linux Command Line & Shell
Working effectively at the Linux/Unix shell: core commands, file and text manipulation, pipes and redirection, process control, permissions and ownership, and shell scripting fundamentals. Covers navigating the filesystem, chaining tools, and the everyday command-line workflow expected of anyone operating Linux systems.
CPU Scheduling & Context Switching
How the operating system decides which runnable task gets the CPU and switches between them: preemptive vs. cooperative scheduling, algorithms such as round-robin, priority, and multilevel feedback queues, time slices, and the mechanics and cost of a context switch. Covers scheduling goals like throughput, latency, fairness, and starvation avoidance.
Service & Init System Management
Managing long-running services and the system init layer: systemd units, targets, dependencies, and journald, plus starting, stopping, enabling, and troubleshooting daemons. Covers service lifecycle, restart policies, and how the init system supervises processes on a modern Linux host.
System Calls & the Kernel Interface
The boundary between user space and the kernel: how programs request privileged services through system calls, the user/kernel mode transition, and the semantics of core POSIX calls such as fork, exec, wait, open, read, write, and stat. Covers syscall numbers, arguments, return values and errno, and how libc wrappers relate to the underlying trap. This is the foundational interface for all systems programming on Unix/Linux.
State Machines & Protocol Implementation
Modeling behavior and communication with explicit state: finite state machines, event-driven transitions, and implementing wire or hardware protocols with framing, timeouts, and error handling. Covers structuring long-lived logic as a state machine to keep firmware and systems code correct and testable.