A deep dive into Write Ahead Logs (WAL) - the fundamental technique that ensures data durability in distributed systems, databases, and streaming platforms.
How readiness-based I/O (epoll/kqueue) lets C servers scale: level vs edge triggering, drain-until-EAGAIN, fair scheduling, timers, and backpressure—without 3 a.m. incidents.
How the Linux page cache actually works, what mmap buys you over read/write, where readahead and writeback help (or hurt), and when O_DIRECT is the right tool—not the default.
Implement lock-free stacks/queues in C and reclaim memory safely: ABA, tagged pointers, hazard pointers, and epoch-based reclamation—what they are, when they win, and how to use them without footguns.
Pick the right engine; exploit Apache Arrow and expression pipelines to get faster, more memory‑efficient DataFrames in Python—without painting yourself into a corner.
A production-first tour of CPython’s memory model: what refcounts really guarantee, how the cyclic GC works, why RSS doesn’t always go down, and how to reason about growth without guesswork. Part 1 lays the mental model and refcounting truths.
A practical, low-overhead toolbox for Python performance: what to use (and when), how to keep overhead in single digits, and how to read profiles you can trust.
Make Python types carry their weight: combine static checking (mypy/pyright) with fast runtime validation (Pydantic v2) to turn annotations into contracts that prevent bugs, speed up onboarding, and keep hot paths fast.
The shortest safe path from Python to C-speed: a practical roadmap for choosing Cython, cffi, HPy, or the raw C API, with a minimal wheelable extension, packaging/ABI mental models, and performance guardrails you can apply today.
Build async services that stay responsive under load: apply backpressure with bounded queues, adopt structured concurrency, and make cancellation a contract with deadlines.
A practical guide to Python’s GIL today—where threads help, where they don’t—and what the emerging no-GIL path means for the way you write concurrency, performance, and extension code.
Techniques for making concurrent C code reproducible: deterministic RNG and seeding, time and clock control, schedule capture, and record/replay so tests fail once and explain why.
Demystify CPython 3.11's specializing/adaptive bytecode interpreter—quickening, inline caches, and the patterns that help your code hit the fast path without changing a line.
Demystifying strict aliasing and effective types in C: what the standard actually says, how miscompiles happen, and the safe, high-performance patterns that keep the optimizer on your side.
Apply streaming and event-driven patterns to robust C backends: bound queues, honor deadlines, retry the right way, and make handlers idempotent so failure doesn’t cascade.
A hands-on tour of C’s memory model: from pre-C11 sequence points to C11 atomics, data races, fences, and practical patterns to avoid undefined behavior in systems code.
Build an LSM-ish key-value store in C: from append-only segments and fsync discipline to SSTable format, compaction (tiered vs leveled), and Bloom filters that dodge disk seeks.
A minimal, production-minded Write-Ahead Log (WAL) in C: append-only records, checksums, segment management, fsync discipline, and recovery guarantees.
Async in C without 3 a.m. incidents: understand POSIX AIO, io_uring, and thread-pool strategies; compare latency/throughput/complexity; and build a thin, testable abstraction with real cancellation.
Struct/layout tactics, padding, and prefetch patterns to minimize cache misses and false sharing in real C code.
Practical zero-copy techniques on Linux: when bytes can skip userland, how sendfile/splice/vmsplice/mmap actually move data, and how to avoid hidden copies and stalls.
readv/writev, nonblocking I/O, partial writes, and EINTR-safe loops for production C.
Sampling vs tracing, symbolizing, and pinpointing cache-miss hotspots; guiding real optimizations in C.