Systems

• Database Internals: Storage Engines, Transactions, and Recovery · 2025-12-21

  A deep technical walkthrough of how databases store data, ensure correctness, and recover from crashes — covering B-trees, LSM-trees, write-ahead logging, MVCC, isolation levels, and replication.

• CPU Microarchitecture: Pipelines, Out-of-Order Execution, and Modern Performance · 2025-12-04

  An in-depth exploration of CPU microarchitecture: instruction pipelines, hazards, branch prediction, out-of-order execution, register renaming, superscalar and SIMD units, and how software maps to hardware for performance.

• Distributed Systems: Consensus, Consistency, and Fault Tolerance · 2025-10-20

  Fundamentals of distributed systems: failure models, consensus algorithms (Paxos, Raft), CAP theorem, consistency models, gossip, membership, CRDTs, and practical testing strategies like Jepsen.

• The Quiet Calculus of Probabilistic Commutativity · 2025-09-27

  A practical calculus for quantifying when non-commutative operations in distributed systems can be safely executed without heavyweight coordination.

• Memory Allocation and Garbage Collection: How Programs Manage Memory · 2025-02-20

  A deep dive into how programming languages allocate, track, and reclaim memory. Understand malloc internals, garbage collection algorithms, and the trade-offs that shape runtime performance.

• Write-Ahead Logging: The Unsung Hero of Database Durability · 2024-09-10

  Dive deep into write-ahead logging (WAL), the technique that lets databases promise durability without sacrificing performance. Learn how WAL works, why it matters, and how modern systems push its limits.

• Bloom Filters and Probabilistic Data Structures: Trading Certainty for Speed · 2024-08-22

  Explore how Bloom filters, Count-Min sketches, and HyperLogLog sacrifice perfect accuracy for dramatic space and time savings—and learn when that trade-off makes sense.

• Lock-Free Data Structures: Concurrency Without the Wait · 2024-07-18

  Explore how lock-free algorithms achieve thread-safe data access without traditional locks. Learn the theory behind compare-and-swap, the ABA problem, memory ordering, and practical implementations that power high-performance systems.

• Concurrency Primitives and Synchronization: From Spinlocks to Lock-Free Data Structures · 2024-03-15

  A comprehensive exploration of concurrent programming fundamentals, covering mutexes, spinlocks, semaphores, condition variables, memory ordering, and lock-free programming techniques that enable safe parallel execution.

• Unicode and Character Encoding: From ASCII to UTF-8 and Beyond · 2024-03-15

  A comprehensive guide to how computers represent text. Understand the evolution from ASCII through Unicode, the mechanics of UTF-8 encoding, and how to handle text correctly in modern software.

• File Systems and Storage Internals: How Data Persists on Disk · 2023-09-22

  A comprehensive exploration of file system architecture, from inodes and directories to journaling and copy-on-write. Understand how operating systems organize, protect, and efficiently access persistent data.

• Memory Allocators: From malloc to Modern Arena Allocators · 2023-09-14

  A deep dive into memory allocation strategies, from the classic malloc implementations to modern arena allocators, jemalloc, tcmalloc, and custom allocators that power high-performance systems.

• TCP Congestion Control: From Slow Start to BBR · 2023-02-11

  A comprehensive exploration of TCP congestion control algorithms, from classic approaches like Tahoe and Reno to modern innovations like BBR. Learn how these algorithms balance throughput, fairness, and latency across diverse network conditions.

• Floating Point: How Computers Represent Real Numbers · 2023-02-08

  A deep exploration of IEEE 754 floating point representation, the mathematics behind binary fractions, precision limits, and the subtle bugs that can arise when working with real numbers in code.

• Garbage Collection Algorithms: From Mark-and-Sweep to ZGC · 2022-11-22

  A comprehensive exploration of garbage collection algorithms, from classic mark-and-sweep to modern concurrent collectors like G1, Shenandoah, and ZGC. Learn how automatic memory management works and the trade-offs that shape collector design.

• CPU Caches and Cache Coherence: The Memory Hierarchy That Makes Modern Computing Fast · 2022-07-12

  A comprehensive exploration of how CPU caches bridge the processor-memory speed gap. Learn about cache architecture, replacement policies, coherence protocols, and how to write cache-friendly code for maximum performance.

• Virtual Memory and Page Tables: How Modern Systems Manage Memory · 2022-05-19

  A comprehensive exploration of virtual memory, page tables, and address translation. Learn how operating systems provide memory isolation, enable overcommitment, and optimize performance with TLBs and huge pages.

• Process Scheduling and Context Switching: How Operating Systems Share the CPU · 2022-05-18

  A deep dive into how operating systems decide which process runs next and how they switch between processes. Understand scheduling algorithms, context switches, and the trade-offs that shape system responsiveness.

• Branch Prediction and Speculative Execution: How Modern CPUs Gamble on the Future · 2021-08-15

  Explore how modern processors predict branch outcomes and execute instructions speculatively, the algorithms behind branch predictors, the performance implications for your code, and the security vulnerabilities like Spectre that emerged from these optimizations.

• Virtual Memory and Page Tables: How Operating Systems Manage Memory · 2021-08-12

  A comprehensive exploration of virtual memory systems, page tables, address translation, and the hardware-software collaboration that enables modern multitasking. Understand TLBs, page faults, and memory protection.

• B-Trees and LSM-Trees: The Foundations of Modern Storage Engines · 2021-07-14

  An in-depth exploration of B-Trees and LSM-Trees, the two dominant data structures powering databases from PostgreSQL to RocksDB. Learn their trade-offs, internal mechanics, and when to choose each for your workload.

• CPU Caches and Memory Hierarchy: The Hidden Architecture Behind Performance · 2021-06-22

  A deep exploration of CPU cache architecture, from L1 to L3 caches, cache lines, associativity, replacement policies, and cache coherence. Learn how memory hierarchy shapes modern software performance.

• 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.

• 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.