A modern CPU fills its multi-stage pipeline by guessing, correctly around 95 to 99 percent of the time, which way an if-statement is going to go before it actually knows the answer. That guess is what branch prediction is, the guess going wrong is a pipeline flush that costs 15-20 wasted cycles, and the 2018 discovery that the guess leaves observable side effects even when it's wrong is what Spectre exploits.
Performance
-
Branch Prediction -
HTTP/3 and QUIC in Production What QUIC actually changed at the wire level, the head-of-line blocking fix, the 0-RTT replay risk and how to harden it, the deployment reality across Cloudflare, Google, and Apple, and the honest performance gains versus HTTP/2 five years after RFC 9000 shipped.
-
KV Cache Engineering: PagedAttention, Continuous Batching, Attention Variants, and the Bandwidth Wall The KV cache is the single biggest lever for LLM inference cost and throughput. How it works, why naive allocation wastes 60–80% of GPU memory, how PagedAttention and continuous batching fix that, what prefix caching actually saves, how FP8/INT8 quantization and GQA/MLA shrink the cache, and why long context is fundamentally a memory-bandwidth problem.
-
A Modern CDN, Honestly A multi-line description of two to three lines: how a modern CDN actually works — edge routing, request coalescing, image/video transformation, the cache-key engineering that decides hit rate, and where the big providers differ.
-
Database Indexes Explained A working engineer's guide to database indexes: when each index type (B-tree, hash, GiST, SP-GiST, BRIN, GIN, columnstore) is the right answer, what an index actually costs you on every write, and how the query planner decides whether to use one at all.
-
Hash Functions Explained Cryptographic hash functions are the workhorse primitive of modern computing — every TLS handshake, git commit, password store, blockchain, and code signature relies on them. We walk what a hash function actually guarantees, the Merkle-Damgard versus sponge construction split that separates SHA-2 from SHA-3, the BLAKE3 parallel Merkle tree, the length-extension attack history, and what each function is good for.
-
DDR5 and Why Memory Latency Stopped Improving DRAM capacity grew 128x and bandwidth 20x in two decades while latency barely moved 1.3x. Why the time to fetch the first byte has been stuck near 13 nanoseconds since DDR3, what DDR5 actually changed — dual sub-channels, more bank groups, on-die ECC, the PMIC — and why every one of those wins is about bandwidth and reliability, not the latency wall it cannot break.
-
NVMe-over-Fabrics: Block Storage at Near-Local Latency Over the Network NVMe-over-Fabrics extends the NVMe queue model across a network so a host can talk to remote SSDs the same way it talks to local ones. This post is about how the queue-pair model actually maps to RDMA, TCP, and Fibre Channel transports, why TCP made the protocol mainstream, how namespaces and ANA multipath behave in practice, and where NVMe-oF beats and loses to plain iSCSI and direct-attached disk.
-
Queueing Theory for Capacity Planning: Why Latency Explodes at 80% Queueing theory gives engineers a rigorous foundation for capacity planning. Little's Law, the M/M/1 utilization-latency formula, and the hockey-stick curve explain why latency degrades catastrophically near saturation — and exactly where to set thresholds for thread pools, connection pools, and HPA.
-
QUIC and HTTP/3 Deep Dive A technical deep dive into why QUIC replaces TCP under HTTP/3: head-of-line blocking, the integrated TLS 1.3 handshake, independent streams, connection migration, and the honest operational reality of deploying it with nginx, Caddy, and Cloudflare.
-
The Browser as a Platform How the thing on the other end of your API actually works — the DOM and the rendering pipeline (parse, style, layout, paint, composite), the event loop and the microtask queue, what reflow and repaint actually cost, the Web Platform APIs worth knowing, and the security model (same-origin, CORS, CSP). The mental model that makes frontend performance and bugs make sense.
-
Web Performance Engineering Making pages fast, measured properly — Core Web Vitals (LCP, INP, CLS) and what actually moves them, the critical rendering path, resource hints, lazy loading and code-splitting, caching and CDN strategy, image and font optimization, and measuring with lab tools and real-user monitoring. The SRE mindset applied to the frontend.
-
ClickHouse for Analytics Workloads ClickHouse columnar storage, the MergeTree engine family, primary key vs sorting key, materialized views for pre-aggregation, query profiling with EXPLAIN, replication with ClickHouse Keeper, distributed tables for sharding, and when to choose ClickHouse over PostgreSQL.
-
Linux Performance Analysis Systematic Linux performance analysis: the USE method, CPU profiling with perf and flamegraphs, memory pressure with vmstat and /proc/meminfo, I/O profiling with iostat and blktrace, dynamic tracing with bpftrace one-liners, and strace for syscall inspection.
-
PgBouncer and PostgreSQL Connection Pooling Why PostgreSQL's process-per-connection model requires a connection pooler, PgBouncer session vs transaction vs statement pooling modes and their tradeoffs, pgbouncer.ini configuration, monitoring with SHOW commands, and a comparison of PgBouncer, Pgpool-II, and Supavisor.
-
PostgreSQL Internals and Tuning How PostgreSQL works under the hood: MVCC for non-blocking reads, heap and TOAST storage, WAL for durability and replication, VACUUM and autovacuum mechanics, EXPLAIN ANALYZE output explained, index types, pg_stat_statements for query analysis, and key postgresql.conf tuning parameters.
-
Redis Architecture and Persistence Redis data structures and their use cases, RDB vs AOF vs hybrid persistence, Redis Sentinel for high availability, Redis Cluster for horizontal scaling with hash slots, eviction policies, diagnostic commands, and an honest look at when Redis is the right tool.
-
HAProxy Deep Dive: Load Balancing, ACLs, and SSL Termination at Scale The HAProxy configuration DSL from first principles: frontends, backends, ACL-based routing, all load balancing algorithms, stick tables for rate limiting, SSL termination with automatic certificate renewal, the runtime API, and Prometheus observability — all without a sidecar.
-
PostgreSQL Full-Text Search vs Elasticsearch: Where the Line Actually Is tsvector/tsquery, pg_trgm fuzzy matching, ranking and highlighting, multilingual support, and an honest answer to when Postgres FTS is enough and when you actually need a dedicated search engine.
-
Rust for Systems Engineers: A Practical Onramp Ownership and borrowing without the theory lecture, practical patterns for network services and CLI tools, safe interop with C, and an honest account of where Rust genuinely beats Go and where it does not.
-
eBPF for Observability: Writing Your First Program What eBPF actually is, how the verifier and JIT compiler work, bpftrace one-liners for immediate production insight, writing a real tracing program in C with libbpf, and the production tools built on top of it — Cilium, Pixie, and Parca.
-
Quantization Deep Dive: GPTQ, AWQ, GGUF, AQLM, and MLX A rigorous look at every major LLM quantization format: how GPTQ's Hessian-guided rounding works, why AWQ's activation-aware scaling beats naive per-channel approaches, when GGUF k-quants are the right choice, where AQLM wins at sub-3-bit, and how MLX handles Apple Silicon. Includes conversion workflows, a perplexity shootout, and a decision guide.
-
Semantic Caching for LLM Applications: Cutting Cost and Latency How embedding-based semantic caching works, why threshold tuning is the hardest part, cache invalidation patterns that prevent staleness, and practical implementations with GPTCache, LiteLLM, and a from-scratch Redis + FastAPI setup.
-
Speculative Decoding: Draft Models, EAGLE, and How to Actually Use It How speculative decoding achieves 2–4x inference speedup without changing model outputs, covering the rejection-sampling proof, EAGLE and EAGLE2 draft strategies, ngram lookahead, and production configuration for vLLM and llama.cpp.
-
vLLM vs SGLang vs TensorRT-LLM: Inference Engine Shootout 2026 A thorough comparison of the three dominant LLM inference engines: how each one works internally, where each wins on benchmarks, and which to reach for given your hardware, workload, and operational tolerance.
-
BPF Performance Tools Tour: bcc, bpftrace, and libbpf A tour of the eBPF performance tooling that has reshaped Linux observability — bcc, bpftrace, and libbpf — with practical one-liners and scripts for tracing kernel and userspace events at production scale.
-
Flamegraphs: Reading and Generating How to read and generate flamegraphs — the visualization that turned profiling into something engineers enjoy — covering CPU, off-CPU, and differential flamegraphs, and the perf and eBPF pipelines that produce them.
-
perf: Linux's Best Profiler A practical guide to perf, the profiler that actually shows you what the CPU is doing — sampling, hardware counters, call graphs, and the workflows that feed flamegraphs — written for engineers starting serious Linux performance work.
-
The USE and RED Methods: Systematic Performance Investigation Two checklists that turn flailing performance investigations into systematic ones — Brendan Gregg's USE method for resources and the RED method for request-driven services — and when to reach for each.
-
PCIe for Systems Engineers PCIe for people who currently stop at `lspci` — lanes, generations, bifurcation, and IOMMU explained well enough to diagnose a GPU training at half speed or an NVMe drive hitting a third of its rated IOPS from `lspci -vvv` output.
-
fio Benchmarking Cookbook: Stop Using dd, Start Measuring What Matters Why `dd` tells you almost nothing about storage, and how to measure what matters with fio — building realistic jobs for IOPS, throughput, and latency across queue depths so your numbers reflect real workloads rather than cache.
-
OpenMP: Threading Without Pthreads (And Without the Nightmares) OpenMP as the sane way to parallelize C, C++, and Fortran — pragmas instead of pthread plumbing for parallel loops, tasks, and GPU offload — plus the data-sharing and scheduling details that decide whether you get speedup or bugs.
-
RDMA and InfiniBand From the Ground Up: Why It's Fast and How to Diagnose It Why RDMA and InfiniBand deliver 400 Gbps at single-microsecond latency with the CPU idle — how kernel-bypass and the verbs model work, how RoCE differs, and how to diagnose a fabric that isn't hitting its datasheet.
-
XFS Tuning and Internals: Allocation Groups, Log Layout, and Real Workload Tuning What's actually happening underneath the Linux filesystem you've used by default for years — XFS allocation groups, the journal layout, and the tuning that matters for real workloads like large, full, write-heavy volumes.
-
GPU Programming Without CUDA: OpenCL, ROCm, Vulkan, Metal, and WebGPU The full landscape of non-NVIDIA GPU compute: OpenCL for portability, ROCm on AMD hardware, Vulkan Compute shaders, Metal for Apple Silicon, and WebGPU for cross-platform GPU work in the browser and beyond.
-
Linux Memory Management Deep Dive A comprehensive guide to Linux virtual memory, huge pages, NUMA topology, OOM killer tuning, /proc/meminfo interpretation, and using perf mem to find memory bottlenecks.
-
Julia: High-Performance Scientific Computing A technically deep guide to Julia for engineers and data scientists who already know Python — covering multiple dispatch, JIT compilation, type system, the scientific ecosystem (DifferentialEquations.jl, Flux.jl, Turing.jl), parallel computing, interoperability, and an honest Julia vs Python comparison.
-
Mojo: Python Syntax, Metal-Level Performance A deep technical guide to Mojo — Modular's MLIR-based language that combines Python syntax with C/Rust-level performance for AI and ML workloads. Covers the type system, SIMD intrinsics, memory ownership, metaprogramming, Python interop, and an honest assessment of where Mojo stands today.
-
C# and .NET for Backend Engineers ASP.NET Core, minimal APIs, Entity Framework Core, Native AOT, and the performance story that makes .NET a serious choice for backend development in 2026.
-
PHP: The Comeback Kid PHP 8.x features including fibers, enums, property hooks, and named arguments. Laravel 11, Livewire, Reverb, and why modern PHP deserves a second look from developers who wrote it off.
-
Ruby: The Language That Still Ships Ruby 3.x performance with YJIT, Ractors, RBS type signatures, Rails 8's Solid Stack, Kamal deployment, and why the self-hosting renaissance suits Ruby perfectly.
-
Swift on the Server: A Technical Deep Dive for Experienced Engineers A technically rigorous guide to Swift beyond iOS and macOS — covering Swift NIO, Vapor, Hummingbird, the Swift 6 concurrency model, embedded Swift, Lambda deployments, and an honest assessment of where server-side Swift wins and where it doesn't.
-
Pyroscope: Continuous Profiling in Production Pyroscope brings always-on profiling to production systems — flame graphs for CPU hotspots, memory leaks, and goroutine issues, correlated with your traces and metrics.
-
API Rate Limiting Patterns: Algorithms, Redis Implementations, and Client Communication A deep dive into rate limiting algorithms — token bucket, sliding window log, sliding window counter, fixed window, and leaky bucket — with production Redis implementations, distributed rate limiting, and how to communicate limits to clients.
-
Capacity Planning for Engineers: Forecasting Growth, Load Testing, and Avoiding Surprise Scaling Events A comprehensive guide to capacity planning—covering demand forecasting, bottleneck identification, load testing with k6, headroom targets, Kubernetes autoscaling, and building the muscle to never be surprised by traffic growth again.
-
HAProxy Deep Dive: Load Balancing, Health Checks, ACLs, and Production Tuning A comprehensive guide to HAProxy — covering load balancing algorithms, health checks, ACLs and routing logic, SSL/TLS termination, rate limiting, observability, and tuning for high-traffic production workloads.
-
PostgreSQL Performance Tuning: From Slow Queries to a Database That Purrs A practical deep dive into PostgreSQL performance: reading pg_stat_statements, analyzing slow queries with EXPLAIN ANALYZE, choosing the right index type, tuning autovacuum, and scaling connections with PgBouncer.
-
DPDK and High-Performance Networking: Kernel Bypass for Line-Rate Packet Processing A deep dive into DPDK — how kernel bypass works, poll-mode drivers, memory management with hugepages, building packet processing applications, and when DPDK is (and isn't) the right tool.
-
eBPF for Observability A practical guide to using eBPF for deep observability — tracing system calls and kernel events with bpftrace, profiling applications with BCC tools, and building network visibility with Cilium.
-
PostgreSQL for Developers: Indexes, EXPLAIN ANALYZE, JSONB, and Tuning for Real Workloads A practical deep-dive into PostgreSQL for developers — understanding indexes and when to use them, reading EXPLAIN ANALYZE output, using JSONB for flexible schemas, and tuning the key configuration knobs that matter for real workloads.
-
Rust for Systems Programming: Ownership, Safety, and Where It Beats C/C++ A practical guide to Rust for systems programmers — the ownership and borrowing model, lifetimes, practical use cases, building a real CLI tool, and an honest look at where Rust outshines C and C++.
-
SQLite in Production: When It's the Right Choice, WAL Mode, Backups, and Litestream Replication SQLite is more capable in production than most developers realize. This guide covers when to choose it over Postgres, WAL mode for concurrent reads and writes, proper backup strategies, and continuous replication with Litestream.
-
Gaming on Linux in 2026: Better Than You Think A comprehensive guide to gaming on Linux in 2026 — Steam and Proton compatibility, native games, Lutris, Wine, GPU drivers, performance tuning, and the distributions best suited for gaming.
-
Profiling Applications: Finding Bottlenecks in Go, Python, and Node.js Stop guessing why your application is slow. This guide covers systematic profiling tools and techniques for Go (pprof), Python (cProfile, py-spy, line_profiler), and Node.js (clinic.js, V8 profiler) so you can find the actual bottleneck and fix it with confidence.
-
strace and ltrace: Debugging Processes at the System Call Level A practical deep-dive into strace and ltrace — the essential Linux tools for understanding exactly what a process is doing at the kernel and library level. Covers real debugging scenarios, filtering techniques, performance tracing, and interpreting output.
-
Caching Strategies for Performance How to implement caching effectively at different layers of your application.
-
Linux Performance Tuning and Monitoring Advanced techniques for monitoring and optimizing Linux system performance.