Interactive essays on the machinery of software. The method is interactive experimentation: every figure lets you change an input, test an assumption, and watch what follows. The articles work best when you play with all of them.

• October 2026 The Collective

  How isolated agents found shared memory, turned persistence into collective research, and crossed from gaming a benchmark into compromising an external service.

• September 2026 The honest probability

  Jev returns decisions instead of sentences: the logits every LLM already had, how RLHF unlearns calibration, the proper scoring rule at the heart of RLCD, and a game where you are the model and honesty is the winning move.

• September 2026 The clock problem: how PromQL landed inside Elasticsearch

  TSTEP grids anchored to the query instead of the wall clock, windows that look backward, without() grouping discovered at runtime, and the 2,000-query corpus behind the 80% number.

• September 2026 The machinery underneath

  How LLMs actually work, told to a reader who knows search engines: tokens over letters, meaning as geometry, attention as retrieval, heads in parallel, the residual stream, the FFN where facts live, a temperature slider, and the KV cache that makes it fast.

• August 2026 The machine, whole

  Document store, columnar store, vector store: three specialized engines wearing one coat, and one query scrubbed through every one of them, ten million documents to ten.

• July 2026 The language of time: TS and PromQL

  Why ordinary aggregation lies about counters, the TS command's series-first grammar, the blank-chart bug, and PromQL running natively against the same columns.

• July 2026 Columnar logs: stored once

  Why the document store keeps three copies and earns them, what happens when the workload turns analytic, the cardinality slider behind 25× compression, block pruning, and the columnar mode that stores the truth once.

• July 2026 ES|QL: one language for the whole machine

  From pipes to plan trees to pages of blocks: the parser, the optimizer, LOOKUP JOIN, and the vectorized compute engine.

• June 2026 The metrics engine

  25 bytes per data point down to 3.75, a query window you drag across the day's blocks, one night on call with a lying rate(), the cores you extinguish at ingest, and the published benchmarks.

• May 2026 Growing old cheaply

  Data streams and rollover, lifecycle tiers from hot to frozen, and searchable snapshots: how keeping years of logs stopped being a luxury.

• April 2026 HNSW: the graph that finds meaning

  The index behind vector search: watch it build one insertion at a time, descend its layered highways, and tune ef_search against measured ground truth.

• April 2026 Ingest: from chaos to schema

  Pipelines, an editable grok playground, enrichment, and the common schema that makes every source speak one language.

• March 2026 Semantic search in practice

  ELSER expansions you can read, chunking as a tunable trade, late interaction token-by-token, a reranker you can toggle, and the three k's that price every RAG pipeline.

• March 2026 The vector database

  Meaning as geometry: embeddings, filtered vector search, BBQ quantization, the oversample-and-rescore net, and hybrid ranking with reciprocal rank fusion.

• February 2026 The cluster: elections, allocation, and disasters

  Replica promotion, the quorum election that prevents split-brain, shard rebalancing, snapshots, and cross-cluster replication.

• February 2026 Numbers at scale

  Doc values, aggregations, HyperLogLog in 256 bytes, and t-digest percentiles: honest approximations at scale.

• January 2026 Where: geo search

  Location as a first-class filter: draggable radius, box and polygon queries, the BKD tiles that prune them, and geotile aggregations that draw the map itself.

• January 2026 One machine from many

  Distributed search in two phases, the global-rarity problem DFS solves, and adaptive replica selection.

• December 2025 Inside the inverted index

  The engineering under the idea: a term dictionary you can type into, posting lists compressed to bits, and the skip pointers that keep AND queries fast.

• December 2025 Segments: how writes really work

  Immutable segments, the translog and a crash you control, tiered merging, and the live write-path simulation.

• November 2025 Ranking: the science of first

  BM25 from intuition to formula, rarity measured, the explain tree, three ways to combine fields, recency decay, and how the top ten is found without scoring the rest.

• November 2025 Anatomy of a search

  How a document becomes five data structures, how the inverted index answers without reading, why text and keyword answer different questions, and how queries compose, forgive typos, and respect word order.