Systems Programmer Course

Lesson 1 • Toolchain and Build Environment

Sets up compilers, linkers, assemblers, and debuggers used throughout the course. Ensures every student can compile, link, and inspect binaries from day one.

Lesson 2 • Operating System Abstractions

Introduces kernel vs. user space, system calls, and OS resource management. Connects hardware concepts to the software interfaces programmers use daily.

Lesson 3 • Process Memory Layout

Examines stack, heap, BSS, data, and text segments in a running process. Provides the spatial model required for pointer arithmetic and memory management.

Lesson 4 • Computer Architecture Essentials

Covers CPU registers, instruction cycles, and memory hierarchy. Establishes hardware vocabulary needed for every subsequent systems topic.

Lesson 1 • Data Types and Memory Representation

Covers integer widths, endianness, alignment, and padding in structs. Grounds students in how C types map to actual bytes in memory.

Lesson 2 • Error Handling and Defensive Coding

Introduces errno, return-code conventions, and assertion strategies in C. Builds habits that prevent silent failures in production systems code.

Lesson 3 • C Preprocessor and Macros

Explains include guards, object-like and function-like macros, and conditional compilation. Enables students to write portable, configurable systems headers.

Lesson 4 • Manual Memory Management

Covers malloc, calloc, realloc, and free, plus common allocation errors. Students learn to detect leaks and use valgrind-style tools for verification.

Lesson 1 • Inline Assembly in C

Teaches GCC extended inline assembly syntax, constraints, and clobber lists. Enables direct hardware access from C without a separate assembly file.

Lesson 2 • Core Instruction Set

Covers data movement, arithmetic, logical, and control-flow instructions. Gives students enough vocabulary to read compiler output and write small routines.

Lesson 3 • x86-64 Register Set and Calling Conventions

Maps general-purpose, segment, and SIMD registers to their roles. Establishes the ABI contract that C and assembly code must honor when interoperating.

Lesson 4 • Binary Analysis with Disassemblers

Uses objdump and similar tools to inspect compiled binaries and shared libraries. Connects source-level understanding to actual machine code in production artifacts.

Lesson 1 • Signals and Asynchronous Events

Explains signal delivery, masking, and handler registration with sigaction. Prepares students to write signal-safe code and handle asynchronous OS notifications.

Lesson 2 • Process Creation and Lifecycle

Covers fork, exec, wait, and exit semantics in POSIX environments. Students understand how the OS tracks process state from creation to termination.

Lesson 3 • POSIX Threads Fundamentals

Introduces pthread creation, joining, and detachment alongside thread attributes. Establishes the threading model used in all subsequent concurrency topics.

Lesson 4 • Synchronization Primitives

Covers mutexes, condition variables, semaphores, and read-write locks. Students apply each primitive to eliminate data races in shared-memory programs.

Lesson 1 • Memory Profiling and Leak Detection

Applies Valgrind Memcheck, AddressSanitizer, and /proc maps to find leaks and corruption. Students produce clean memory profiles for production-grade code.

Lesson 2 • Virtual Memory Architecture

Explains page tables, TLB operation, and address translation hardware. Provides the foundation for understanding mmap, huge pages, and NUMA effects.

Lesson 3 • Huge Pages and NUMA Awareness

Introduces transparent huge pages, explicit huge page allocation, and NUMA topology. Students tune memory placement for latency-sensitive systems workloads.

Lesson 4 • Custom Memory Allocator Design

Builds a slab-style allocator using sbrk and mmap as backing stores. Reinforces understanding of fragmentation, coalescing, and allocator metadata.

Lesson 1 • Advanced I/O: Scatter-Gather and Async

Introduces readv/writev, io_uring, and epoll for high-performance I/O. Enables students to build event-driven servers with minimal system call overhead.

Lesson 2 • Storage Performance Tuning

Applies fio, iostat, and blktrace to measure and improve I/O throughput and latency. Students identify bottlenecks in the storage stack from application to device.

Lesson 3 • Buffered vs. Unbuffered I/O

Contrasts stdio buffering with direct syscall I/O and explains when each is appropriate. Students measure the performance impact of buffering strategies on throughput.

Lesson 4 • POSIX File I/O API

Covers open, read, write, lseek, and close with all relevant flags and modes. Establishes the file descriptor model as the universal I/O abstraction in POSIX.

Lesson 1 • Kernel Module Development

Covers module init/exit, Kbuild system, and kernel coding style requirements. Students compile, load, and unload a minimal kernel module safely.

Lesson 2 • Kernel Memory and DMA

Explains kmalloc, vmalloc, and DMA-coherent allocation for driver use. Students choose the correct allocation API based on size, alignment, and DMA requirements.

Lesson 3 • Character Device Driver Basics

Implements file_operations callbacks: open, release, read, write, and ioctl. Students expose a kernel data source to user space through a device file.

Lesson 4 • System Call Internals

Traces a system call from user space through the syscall table to kernel handler. Students understand context switching, argument passing, and return paths.

Lesson 1 • Cache Optimization Techniques

Applies data structure layout, prefetching, and loop tiling to improve cache utilization. Students measure cache miss rates before and after each transformation.

Lesson 2 • Benchmarking Methodology

Covers microbenchmark design, statistical analysis, and avoiding common pitfalls. Students produce reproducible benchmark results that withstand peer review.

Lesson 3 • Compiler Optimization and Link-Time Optimization

Explores -O levels, PGO, LTO, and auto-vectorization flags. Students verify that compiler transformations produce correct, faster binaries.

Lesson 4 • Lock Contention and Scalability

Measures lock contention with perf lock and applies lock-free techniques where appropriate. Students redesign synchronization to scale across many CPU cores.