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.
Memory Management, Paging & Virtual Address Space
How the OS gives each process an isolated virtual address space and maps it onto physical memory: paging, page tables, the TLB, page faults, demand paging, and swapping. Covers the layout of a process address space (text, data, heap, stack), memory isolation and protection between processes, and how virtual memory enables overcommit and copy-on-write.
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.
Kernel Architecture & OS Internals
How an operating system kernel is structured and what it is responsible for: monolithic vs. microkernel designs, the role of kernel subsystems (scheduler, memory manager, VFS, drivers), kernel vs. user space, and the boot/initialization path. Includes how kernel modules and device drivers extend the kernel and how the kernel mediates access to hardware.
Real-Time Systems, RTOS Scheduling & WCET
Building systems with timing guarantees: hard vs. soft real-time, RTOS task scheduling (rate-monotonic, earliest-deadline-first), priorities and preemption, and jitter. Covers worst-case execution time analysis, schedulability, meeting deadlines deterministically, and the concurrency patterns used in real-time and control software.
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.
Process & Thread Management
The lifecycle of processes and threads: creation and termination, process states, the process control block, parent/child relationships, zombies and orphans, and the distinction between processes and threads. Covers how the OS tracks and isolates execution contexts and how threads share address space while maintaining separate stacks and registers.
Mobile Platform Internals & Resource Management
How mobile operating systems work beneath the app layer and how apps live within their constraints: the app sandbox and permission model, process and memory management specific to mobile, inter-app communication, and platform services, together with the app lifecycle and process suspension, background execution limits, battery and power optimization, and memory-pressure and thermal handling. Covers how iOS and Android reclaim resources and how a mobile engineer reasons about performance, security, and platform behavior at the OS level.
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.
Firmware Buffering & Ring Buffers
Low-level data movement and buffering in constrained systems: circular/ring buffers, producer-consumer queues, lock-free single-producer/single-consumer designs, and handling overflow and wraparound. Covers buffering strategies for streaming data between ISRs, DMA, and application code without dynamic allocation.