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.
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.
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.
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.
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.
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.
Build async services that stay responsive under load: apply backpressure with bounded queues, adopt structured concurrency, and make cancellation a contract with deadlines.
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.
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.
A minimal, production-minded Write-Ahead Log (WAL) in C: append-only records, checksums, segment management, fsync discipline, and recovery guarantees.
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.
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.
Struct/layout tactics, padding, and prefetch patterns to minimize cache misses and false sharing in real C 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.
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.
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.
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.
A deep dive into Write Ahead Logs (WAL) - the fundamental technique that ensures data durability in distributed systems, databases, and streaming platforms.
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.
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.
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.
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.