Systems

• Persistent Memory Programming: DAX Mappings, PMDK Libraries, Crash Consistency Without Write-Ahead Logging, and the Optane Legacy · 2021-06-14

  A deep exploration of persistent memory — how DAX enables direct byte-addressable access to non-volatile memory, how the PMDK libraries solve the crash consistency problem at the instruction level, and the lessons of Intel Optane.

• NVMe and the Storage Stack: The NVMe Command Set, Submission/Completion Queues, SPDK, and the Death of the SCSI/SATA Bottleneck · 2021-05-31

  A deep exploration of NVMe technology — how the command set and queue model eliminate the SCSI bottleneck, and why user-space storage via SPDK achieves microsecond-latency I/O on commodity flash.

• User-Space Networking: Snabb Switch, FD.io VPP (Vector Packet Processing), AF_XDP, and the Philosophy of Kernel Bypass · 2021-05-14

  A deep exploration of user-space networking — how Snabb, VPP, and AF_XDP achieve line-rate packet processing by bypassing the kernel, and the architectural trade-offs of moving the network data plane into user space.

• eBPF Internals: The In-Kernel Verifier, Safety Proofs, JIT Compilation to Native Code, Map Types, and XDP/TC Hooks · 2021-05-08

  A deep exploration of eBPF internals — how the Linux kernel verifier proves safety, the JIT compilers that turn BPF bytecode into native instructions, the map infrastructure that enables stateful processing, and the XDP/TC hooks that make programmable networking possible.

• System Calls: The Gateway Between User Space and Kernel · 2021-04-18

  An in-depth exploration of how applications communicate with the operating system kernel through system calls. Learn about the syscall interface, context switching, and how modern OSes balance security with performance.

• Trusted Execution: Intel SGX Enclaves, AMD SEV-SNP, Attestation Protocols, and the Confidential Computing Promise · 2021-03-25

  A deep exploration of trusted execution environments — how SGX and SEV encrypt computation, the attestation protocols that verify enclave integrity, and the promise of confidential computing that protects data even from the cloud operator.

• Capability-Based Security: CHERI Architecture, Hardware Capabilities, Spatial and Referential Safety, and Compartmentalization · 2021-02-26

  A deep exploration of the CHERI capability architecture — how hardware-enforced capabilities provide spatial memory safety, referential integrity, and fine-grained compartmentalization at the instruction level.

• Region-Based Memory Management: Tofte & Talpin's Region Inference, the ML Kit, Safety Proofs, and the Relationship to Rust's Lifetimes · 2020-12-01

  A deep exploration of region-based memory management — how Tofte and Talpin's region inference eliminates garbage collection while preserving memory safety, and how their ideas echo through Rust's ownership and borrowing system.

• Network Sockets and the TCP/IP Stack: How Data Travels Across Networks · 2020-11-08

  A comprehensive exploration of network programming internals, from socket system calls through the TCP/IP protocol stack to the network interface. Understand connection establishment, flow control, and the kernel's role in networking.

• Garbage Collection Advanced: Incremental, Concurrent, Snapshot-at-the-Beginning, and Pauseless Collectors from Azul C4 to ZGC Colored Pointers · 2020-10-31

  A deep exploration of advanced garbage collection algorithms that eliminate stop-the-world pauses — incremental marking, concurrent collection, the snapshot-at-the-beginning barrier, and the pauseless collectors that make Java viable for low-latency applications.

• JIT Compilation: Tracing vs Method JITs, V8's Ignition+TurboFan Pipeline, HotSpot's C1/C2 Tiered Compilation, and Deoptimization · 2020-10-28

  A deep exploration of just-in-time compilation — how V8 and HotSpot turn JavaScript and Java bytecode into native code through multi-tier compilation pipelines, and the art of deoptimization that makes speculative optimization safe.

• Wasm Runtime Internals: V8's Liftoff and TurboFan, Wasmtime's Cranelift, Linear Memory Sandboxing, and the Stack Machine Model · 2020-10-15

  A deep exploration of WebAssembly runtime internals — how V8 and Wasmtime compile and execute Wasm bytecode, the linear memory sandbox that enables secure execution, and the stack machine model at Wasm's core.

• Container Internals: Linux Namespaces, cgroups v2, OverlayFS, and the OCI Runtime Spec Under the Hood · 2020-09-28

  A deep exploration of the Linux kernel primitives that power container runtimes — the seven namespace types, cgroups v2 resource control, OverlayFS copy-on-write storage, and the OCI runtime specification that ties them together.

• Compiler Optimizations: From Source Code to Fast Machine Code · 2020-09-23

  A deep dive into how modern compilers transform your code into efficient machine code. Explore optimization passes from constant folding to loop vectorization, and learn how to write code that compilers can optimize effectively.

• Hypervisor Internals: VT-x, AMD-V/SVM, Nested Paging, and the Mechanics of Trap-and-Emulate · 2020-07-25

  A deep exploration of hardware virtualization support — how Intel VT-x and AMD-V enable efficient hypervisors through VM control structures, nested paging, and the clever elimination of slow trap-and-emulate paths.

• Unikernels: Specializing the OS for a Single Application, from MirageOS to IncludeOS and the Performance-Security Trade-offs · 2020-05-26

  A deep exploration of unikernel architecture — how compiling an application directly into a specialized operating system kernel produces dramatic performance and security benefits while challenging decades of OS design orthodoxy.

• Exokernels & Library OS: MIT's Radical Vision, Secure Multiplexing, and the Unikernel Lineage · 2020-04-01

  A deep exploration of exokernel architecture from MIT's Aegis/XOK/ExOS stack through the secure multiplexing problem to the modern unikernel renaissance that vindicated the library OS philosophy.

• Consistent Hashing: Distributing Data Across Dynamic Clusters · 2020-03-28

  A deep dive into consistent hashing, the elegant algorithm that enables scalable distributed systems. Learn how it works, why it matters for databases and caches, and explore modern variations like jump consistent hashing and rendezvous hashing.

• Microkernel vs Monolithic: The L4 Experience, IPC Optimization, seL4 Verification, and Zircon's Ascent · 2020-02-24

  A deep exploration of microkernel design from L4's high-performance IPC through seL4's formal verification to Zircon's pragmatic reimagining for Fuchsia. Understand why the microkernel-monolithic debate refuses to die.