Archives
All the articles I've archived.
Rust vs C++ on the same LLVM: four programs, one 16-core server
Rust 1.100 and C++ (Clang 23 with the same LLVM, and GCC 16) running the same sort, word count, integer-key hash map and parallel word count on a 16-core DigitalOcean server. Medians of 10 runs, perf counters, heaptrack allocation counts, and the scripts to repeat it.
Redis 8.10 vs Valkey 9.1 under load: the same Go app, the same 4-core machine
Redis 8.10.3 and Valkey 9.1.3 from their official images with default settings, behind one Go app, pushed by k6 from 10,000 to 45,000 requests per second. Peak throughput, latency per step, per-thread CPU and memory, with io-threads 1 and 3, plus the scripts to repeat it.
One Express app on Node 26, Bun 1.4 and Deno 2.9: a load test with the same node_modules
The same Express 5 notes API, the same file and the same node_modules folder, run on Node 26.13.1, Bun 1.4.4 and Deno 2.9.8. k6 read, write, mixed and no-database tests on DigitalOcean, three rounds each, with requests per second, p95/p99, memory, event loop delay and startup, plus the repo with every script and raw result.
One Spring Boot jar on five JVMs: Temurin, Corretto, Zulu, Semeru and GraalVM under load
The same Spring Boot 4.1 notes API, built once and run on five Java 25 runtimes with default settings. k6 read, write and mixed tests on DigitalOcean, with startup, requests per second, p99, memory, GC and JIT compile time for each JVM, plus the scripts to repeat it.
Google login with Spring Security and React, without a token in the browser
A Spring Boot 4 + React app where Spring Security does the whole Google OAuth 2 / OpenID Connect login and keeps the tokens on the server. The browser gets an HttpOnly session cookie and a CSRF cookie, nothing else. Code, config, curl checks and the production list, following RFC 10017's backend-for-frontend design.
AWS IAM for a new account: root MFA, a budget, and an access key that needs a phone
Lock down a fresh AWS account from the CLI: check the root user, add a $10 budget alert, then build a developers group, a no-console user and an MFA-protected developer role. Then test it with the key as if it had leaked, prove that a deny beats an allow, and call AWS from Go without a key in the code.
Go encoding/json v1 vs v2 under load: Go 1.26, Go 1.27 and MarshalWrite
The same notes API built three ways (encoding/json on Go 1.26, the same code on Go 1.27, and encoding/json/v2) and loaded with k6 on a 2 vCPU DigitalOcean machine. Requests per second, p95 and p99, CPU profiles, and why MarshalWrite made the list endpoint slower here.
Postgres vs MySQL under load: reads, writes, updates and one open transaction
PostgreSQL 18 and MySQL 9.7 LTS behind the same Go shop on identical 2 vCPU machines, loaded with k6 until each one fails. Every run's result, the settings, why secondary index lookups cost InnoDB more, HOT updates, and the long transaction that turned the result around.
*sshole: the Alpine OpenSSH bug where an over-long password opens a locked account
OpenSSH 10.6p2 fixes a password authentication bypass on musl systems without PAM, such as Alpine's sshd. What has to line up for it, how to check a server or a container image, the fixed Alpine packages, and the one-line mitigation. No exploit.
Postgres vs SQLite under load: where each one stops on one machine
PostgreSQL 18 and SQLite 3.53 behind the same Go shop on identical 2 vCPU machines, loaded with k6 until they pass their limits. All result tables, the syscall and lock measurements, the single writer pool, and the setup where SQLite stops being an option.
CVE-2026-98432: the Linux TCP use-after-free, and how to check your server
How the IPv4 TCP race behind CVE-2026-98432 works, why two kfree_rcu lines fix it, why scores differ between 8.1 and 9.8, how to find multipath TCP listeners, and the fix status per distribution.
Postgres JSONB vs MongoDB under load: the numbers, the plans and the one GIN setting
PostgreSQL 18 JSONB and MongoDB 8.2 behind the same Go service, on two identical stacks run side by side with k6. Reads, inserts, updates, a mixed shop workload and 40-item documents, plus the EXPLAIN output that shows why the default GIN index makes Postgres fall over.
Keycloak with React and Go: login with PKCE, JWT checks and roles, from one compose file
What Clerk, Supabase Auth, Auth0 and Firebase Auth charge as users grow, then a self-hosted Keycloak 26.8 with a React app (keycloak-js, PKCE S256) and a Go API (go-oidc) that answers 401 for a bad token and 403 for a missing role. Every admin console step also as kcadm.sh and as an Admin REST call.
Golang profiling with pprof: a slow regex and a leaking slice, found and measured
A Go log search service averages 41 ms per search and its container grows to 399 MiB in a minute. pprof's CPU profile points at regexp.MustCompile inside a loop (86% of samples), a heap profile compared with -base points at one line, and both fixes are measured with k6. Plus what profiling costs in production.
Golang context, run in a terminal: timeouts, cancellation and graceful shutdown
A request that waits ten minutes, then one that gives up at 2 s. Three mirrors where the fastest wins and the others stop at 303 ms. A loop that stops after 5 of 20 images, a cancel with a reason, a server that finishes its open request on Ctrl+C, and a request ID in every log line. Every program and every output.
Go concurrency, measured: ten slow requests from 10.3 s to 1.3 s
Goroutines, sync.WaitGroup and wg.Go, the race detector, channels, a three-worker pool and a buffered-channel limit, each run against a local server that takes one second per request. Every program and every timing, plus what 100,000 goroutines cost in memory.
I built Uber's backend. Then one driver got 59 riders
Part 2 of a ride-hailing backend on kind: 10,000 drivers and 6,000 riders in an Istanbul-sized city push three Go pods to their CPU limit, a Redis geo index (GEOADD, GEOSEARCH) halves the work and fills the map again, and a check-then-set race hands one driver 59 riders until SET NX fixes it. Every manifest, command and number.
I built Uber's backend. It crashed at 5,000 drivers, and these three fixes held it up
A Go location service on a local kind cluster behind HAProxy, load-tested with k6. One pod gets OOMKilled at about 5,000 WebSocket drivers, three pods lose two thirds of the drivers, Redis pub/sub brings them back and a Horizontal Pod Autoscaler grows it to four pods at 10,000 drivers, with every manifest, command and number.
Microservices communication patterns on a real shop: retries, Kafka, the outbox and a saga
Four Spring Boot 4.1 services, Kafka 4.3, Postgres 17 and Debezium 3.7 in Docker Compose. A retry that charges a card three times, an idempotency key that stops it, a circuit breaker, an event lost to a dual write, the outbox that fixes it and a saga that refunds the money, with every command and output.
Nginx in front of two Node.js apps: proxy headers, failover, 429 and a cache HIT
One Nginx 1.31.6 container and two Node.js app instances in Docker Compose. Every config file, the headers the app receives, a stopped backend costing exactly one slow request, rate limiting with 429, gzip at 8x, a cache HIT in under a millisecond and TLS 1.3 with HTTP/2, with every command to repeat it.
Spring Boot logging, from log levels to Grafana Loki
A Spring Boot 4.1 service that logs at every level, writes JSON with one property, changes its log level at runtime through Actuator and ships everything to Loki with Grafana Alloy. Every config file, command and output, plus the LogQL that finds a failed payment and its stack trace.
Watching Kafka work: batches, log segments and an idle fourth consumer
Kafka 4.3.1 in one container, 3,000 keyed messages and three partitions. The segment files on disk, 900 messages stored in two batches, keys that always land in the same partition, a consumer that gets nothing, and every command to repeat it.
One index, 467x faster: reading a PostgreSQL B-tree from the inside
Five million rows, one customer, 54 ms with a sequential scan and 0.116 ms with a B-tree index. The EXPLAIN output line by line, the tree's real depth from pageinspect, what the index costs, and every command to repeat it.
HTTPS from the terminal: eleven checks with curl and openssl
Look at a real TLS 1.3 connection to Google, read its certificate chain, build a tiny certificate authority, break certificates on badssl.com and time every step of one request, using only curl, openssl and dig.
Postgres vs MariaDB on two dedicated CPUs: the setup, the settings and every run
PostgreSQL 18 and MariaDB 12.3 behind the same Go service, loaded with k6 up to 3,200 users. Reads, writes, 20 million orders and a spike, with the machine sizes, the config files, the per-level tables and what a single run cannot tell you.
An 11-year-old hole in the Rust borrow checker, reproduced on stable, nightly and Rust 1.4
Issue #164250 shows safe Rust with no unsafe block that reads a String after it was freed. Here is the program, the one-line change the compiler rejects, AddressSanitizer's verdict, a run on Rust 1.4.0 from 2015 in Docker, and what the open fix changes.
Ten Spring Boot speedups on one small app, with the commands and the numbers
An index found through pg_stat_statements, join fetch, JDBC batching that stays off with IDENTITY ids, a Caffeine cache, projections, open-in-view, keyset paging, parallel calls, gzip and a JDK AOT cache. Each one with the code, the command that measures it and the output from one laptop.
Python 3.15, measured: lazy imports, the Tachyon profiler and the JIT on four workloads
Numbers from CPython 3.15.0 on one laptop: where 34 ms of startup go and how the lazy keyword removes them, the rules the keyword has, what the new sampling profiler prints next to the old one, and a JIT that makes one script 2.3 times faster and another one 9% slower.
Repeating MotherDuck's DuckDB 2.0 benchmarks on my own laptop
Three tests from the article 'Why DuckDB 2.0 is faster', run again on DuckDB 1.5.5 and the 2.0 alpha: a Parquet file on S3, a recursive query, and JSON stored as VARIANT. With the SQL, the output, and the one query that got slower.
IPv4 and IPv6 on your own laptop: seven checks you can run
Seven small experiments with ping, dig, curl and Python: one address written four ways, the 1500 byte limit, the private ranges, why a laptop has six IPv6 addresses, and what happens when a site has no IPv6 at all.
A Redis cache in Node.js after the first request: five checks you can run
The cache-aside demo goes from one second to two milliseconds. Here is the same app under twenty requests at once, after an update, with a counter that never expires and with a memory limit, each one measured.
Java garbage collection in its own log: eight checks you can run
Eden, survivor spaces, tenuring and full collections are easy to draw and easy to forget. Here is one 25-line program and the JVM flags that make each step show up as numbers you can add up yourself.
A container is a process: seven checks you can run on your own machine
Namespaces, cgroups, OverlayFS and the build cache are easy to nod along to. Here are the commands that show each one on a running container, including on Docker Desktop, where the host is hidden inside a VM.
1000 trick questions for four decision models: what the numbers hide
I wrote 1000 questions with a trap in each and sent the same request to Jev, Nimble 9B, tev1 4B and Strands Decider 2B. The headline ranking is the least interesting result. Dataset, code and every request are public.
Trying Git 3.0 before it exists: SHA-256, reftable and what broke
Git 3.0 has no release date, but its breaking changes are already in the source behind one build flag. Lab notes from building it: what changed, what did not, and which errors you will meet first.
How AI agents actually work: what happens on a tool call
A language model can only write text, so who runs the tool? Next-token prediction, the raw prompt behind a chat, a tool call as plain text, and an agent loop with MCP, all on a laptop with real output.
What really happens when you kubectl apply
Kubernetes from the inside: the API server, etcd, watches, the scheduler and the kubelet, then a real app on a real cluster with Services, self-healing, rollouts, ConfigMaps and Secrets.
LLMs talk. Jev decides.
Most of what we send to LLMs isn't a writing task. It's a decision. Notes on Jev, TypeSafe's System One model: what it is, how it works, and where I wouldn't use it.