Operating Systems Internals
A compact foundation for tracing how operating systems isolate work, cross kernel boundaries, schedule execution, manage memory pressure, coordinate concurrency, and expose evidence for host-level diagnosis.
Systems Internals
TRACKS
Storage and Filesystems
A compact bridge from operating-system foundations to storage design: choose a storage contract, separate metadata from data paths, trace caching and durability boundaries, follow an I/O request, and read operational pressure before entering implementation deep dives.
Operating Systems Implementation
A project-oriented bridge that turns operating-system mental models into traceable implementation decisions for a small kernel, from boot and privilege transitions through memory, scheduling, syscalls, I/O, isolation, and debugging.
Computer Architecture and Performance Models
Caches, pipelines, memory hierarchies, branch behavior, and the hardware performance models that shape software design decisions.
Concurrency, Memory Models, and Lock-Free Systems
Memory ordering, atomicity, lock-free design, wait-freedom, and the concurrency models behind scalable shared-memory systems.
I/O Stacks, Device Drivers, and Storage Paths
Interrupts, DMA, drivers, block and network I/O paths, and the kernel-to-device mechanics that shape latency and throughput.
Kernel Networking and eBPF
Draft track for kernel datapaths, packet processing, observability, and programmable networking hooks.
Compiler Construction, Runtimes, and Virtual Machines
Compiler and runtime systems from lexing, parsing, IR, dataflow, optimization, register allocation, and code generation through bytecode VMs, JIT tiering, deoptimization, GC interfaces, and runtime observability.
Memory Systems and Allocators
Memory behavior from virtual memory, page faults, cache locality, and NUMA through arena, stack, pool, free-list, buddy, slab, and general-purpose allocator design.
Filesystem and Storage Implementation
Journaling, copy-on-write trees, allocators, recovery, metadata engines, and the implementation trade-offs inside storage stacks.
Virtualization and Hypervisor Systems
Virtual machines, hypervisors, device emulation, paravirtualization, and the isolation mechanisms underneath cloud compute.
Linux Workstations: Ownership, Reproducibility, and Repair
Build a Linux workstation you can inspect, repair, and reproduce by tracing shell, filesystem, package, and service behavior before comparing Arch-style ownership with NixOS-style declaration.
Programming Languages: Rust, C++, Python, and API Craft
A comparative path through language trade-offs, memory, types, performance, ergonomics, bindings, and API design across Rust, C++, and Python.
Backend Runtime, I/O, and Performance
Runtime and kernel-level performance for backend services: event loops, syscalls, zero-copy I/O, memory mapping, GC tuning, virtual threads, actors, memory barriers, and lock-free design.