Recently added

What's new

Essays arrive in groups rather than one at a time. The most recent group is below in full, and every earlier one after it, newest first.

Essays arrive in groups rather than one at a time, and a group usually opens up a subject not covered before. Between one group and the next nothing changes, so a reader who has seen the most recent group has seen everything.

1 November 2026

17 essays on when the algorithm is a table, one pass, and no room, the floors, counting, when it does not fit, the data that is not a number, when the algorithm flips a coin, the other axis, the index that replaces the text, what a bound is, what the machine does, what the libraries do and two parameters

When the algorithm is a table

A second word judged by its own share

A spelling checker that offered its commonest nearest word alone when that word's count was many times the next, and two or three words otherwise, beat a coin's mix of one-word and three-word lists by at most two and a half points, and a plain list of two did better. The ratio measures how dominant the first word is, not how likely the second is. Judged instead by its own share of everything within two edits of the misspelling, the second word is shown only when that share is at least 0.15: on short words drawn by use the checker then sits 4.5 points over the coin's line at 1.32 words a query, nearly twice the ratio's lift and above the list of two, and the weight given a two-edit word moves the result by a tenth of a point. A second word with a share under 0.01 is never the source. On misspellings drawn evenly the share is no guide at all, and the list of two wins.

4 figures One pass, and no room

A variance that had seen one hash

A budget of 40,960 bits split between a HyperLogLog and a bottom-k sample answers an intersection best by weighting the two estimates by their variances, except in one corner: a sample of 160 hashes asked about sets sharing one key in a thousand, where the weighting's worst regret was 4.46. The sample was said to see nothing, report a variance of nought and be believed completely. Its variance was never nought — it was taken at one shared hash whenever none was seen — and it was believed too little, not too much. Half a shared hash in the variance gives the sample more weight and cuts the corner's regret to 3.08, not under the 2.5 predicted; half a hash in the estimate too gives 3.74 there, and 1.61 at five eighths of the budget in registers, the lowest worst regret any split and rule has reached. No weighting measured gets the corner under the sample's own 2.30: 160 hashes expecting a sixth of a shared one is a limit, not a formula.

5 figures The floors

A bar that wins rarely meet

A merge of two sorted lists of repeated values saves most of a textbook merge's comparisons by galloping along a run of equal answers once a bar of them have come in a row, with the bar lowered after a gallop that pays and raised after one that does not. Timsort keeps the same kind of bar for the other kind of stretch, one list winning repeatedly, and a merge of repeated values meets both. One count and one bar for either kind was predicted to save a further tenth under Zipf 1 and change nothing on uniform values. It saves at most 1.0% under Zipf 1, costs up to 1.3% on uniform values, and two separate bars do no better. In two lists drawn from the same distribution a stretch of wins long enough to gallop over is rare: under Zipf 1 at most 18% of the shared bar's gallops are over wins, and where wins dominate the gallops, at a thousand uniform values, the runs of either kind are too short for any gallop to pay.

4 figures Counting

A register dropped by what it already knew

Two registers beside a two-ended selection sort's extremes cut the reading of its record of adjacent order to a forty-fifth on short runs, and made it worse than reading the record plainly on long ones: 53.5 words a question on a sorted array of 1,024 keys against 22.1. The swaps were blamed, and the proposed repair kept the part of a broken run beyond the break as a register of its own. It changes the reading by under 1% anywhere. On the sorted array the survivors are kept 523,775 times and asked 1,022 times, and the sort makes no swap at all: every one of the 263,167 relearning drops there is a pair the record already held, rewritten at the same value by a neighbour's question that the previous scan's chains answered. The swap never broke the register. Learning what it already knew did.

5 figures When it does not fit

A span the queries do not see

A rule for dividing a levelled store's range-filter memory by its levels' sizes, with a floor of half a bit a key, came within five points of the division fitted to the store's own queries at every budget from one bit up — but at half a bit the shuffled and the clustered store wanted opposite divisions of identically sized levels. A level's fences, its first and last keys, say how much of the key space it spans, and a clustered level spans little. Scaling each level's bits by that span was predicted to close the half-bit gap and change nothing above. It changes nothing at half a bit — where the floor is the whole budget, so there is nothing left to scale — and from one bit up it puts the clustered store 30 points behind the fitted division, where the floored rule was within one. A level holding one cluster spans 0.4% of the key space and meets 4.4% of the queries, because half of them start at a stored key: the fences measure the key space, and the queries are aimed at the keys.

5 figures The data that is not a number

A layout the traffic does not move

A bidirectional index whose bit vectors code each block as an arrangement or a gap code saved bits at equal work once the choice was priced where a workload's ranks land. Traffic changes, so a layout fitted once was predicted to lose most of that gain when the searches moved from one half of a text's commonest patterns to the other's, and an index that recoded its blocks every thousand searches from their own counts was predicted to keep it. Neither happened, because nothing needed to be kept. Priced on the first half's patterns and never changed, the layout does 8.24 units of in-block work a rank on the second half's, 1% above a layout refitted to them for free; recoding every thousand searches rewrites 48 of 385 blocks, 0.71 bits a character, and ends no better. The busy blocks are where the text's common substrings sort, and both halves share them: 27 of the 39 busiest blocks under one half's patterns are among the 39 busiest under the other's.

5 figures Counting

A register kept through a confirmation

Two registers beside a two-ended selection sort's extremes, holding where the run of known order from each one ends, read 53.5 words a question on a sorted array of 1,024 keys, more than reading the record plainly — because 263,167 times a neighbour's question, answered by the previous scan's chains, rewrote a pair at the value it already held, and each rewrite dropped a register. Kept through such a confirmation and dropped only when a pair is forgotten or turns round, the registers read 0.347 words a question on that array, a 154th, and 0.345 on 4,096 keys: the reading stops growing with n. They become the cheapest record at every run length, 49 to 73 times under the next on runs and 5.75 times under the run list's search on the sorted array, and the price of a saved comparison now falls as runs lengthen, from 3.97 word reads at runs of four to 0.35. The dearest saving is now the short run's, and it is still above the 3.1 at which a table of compared pairs breaks even.

5 figures When the algorithm flips a coin

A walk that stops at two lines

A blocked filter's threshold table, its lines sized for the mean number of closed blocks and each line's surplus carried forward into the next lines' empty slots, was cheapest in bits — 3.113 a block — and dear in lines, 2.183 a lookup, because a carried value joins a queue with no slack and walks 12.8 lines. Capping the walk was predicted to keep most of the bits, about 3.13, for under 2.02 lines, two hundredths under a reserve sized for the spill. Capped at two lines, the walk sends 53% of its carried values to overflow, and the table costs 3.180 bits a block for 2.027 lines. That is a hundredth under the spill-sized reserve at the same lines and a few thousandths under the uncarried line's curve: at room for the mean most of what joins the queue would wait more than two lines, so the overflow becomes the reserve by another name. With room to spare, every cap loses to the reserve.

3 figures The other axis

A second level that pays in one band

A select on a chunked bit vector can be helped two ways: a select sample every t values says where to start but not how far to scan, and a rank sample every s bits bounds the scan but must be searched for. A directory with both — select samples that name a rank block, rank samples that bound the scan — was predicted to reach under 70 bits read a select for under 3.6 bits a value on an r-index's run starts over exact copies, a point neither kind reaches. It reaches 62 bits read for 3.76 bits a value, which neither kind reaches, and costs 3.73 within 70 bits where the better single kind costs 3.93; but under 3.6 bits a value it reads 84. The select sample names a block two rank samples away, not one. Across eight sets the second level saves more than a twentieth of a bit a value on three, and only between about 65 and 100 bits read a select: outside that band either single kind is as good.

5 figures The index that replaces the text

A price that cannot see the array

A growing directory's document array, refitted when the share of characters behind its escape passes twice what the escape's code word assumes and held until the characters have grown by a quarter, loses 0.098 bits a symbol for 4.52 final arrays of reading. A hold set by price instead — refit when the bits wasted since the last refit reach a constant times the characters a refit reads — was predicted to do at least as well, refitting early where refits are cheap. It does worse: about 0.119 at the same reading. The array's size multiplies both sides of the rule, so the price never sees it; what the rule watches is the loss summed over versions, and that refits late in the small, fast-growing early history where the fixed hold refitted often. The price also counts only the refits' reading, while waiting is paid in rebuilds of the escape, so the total reading stops falling at about 4.3 arrays however high the price goes.

6 figures What a bound is

A buffer that does not shift its tail

The read-only family of sorts scans its input once for each batch of the smallest values not yet output, keeping them in a buffer; charged for the dirty lines it sends back to slow memory, its least transfers × fast memory rose from 1.29 of n²/B to 1.87, because a sorted buffer takes each value by shifting every larger entry one place. Kept as a max-heap instead, the buffer was predicted to write back about a third of the lines it reads below its own size and to bring the product back towards 1.29. At a buffer of 64 cells it writes back 33% at its best memory, against 45%, and its least product falls to 1.71: right about the share, wrong about the product, since a third written back is still a third more transfers. At 256 cells the heap does more than predicted — 1.47 million accesses against 6.94 million, a third of the misses — and its least product, 1.62, is under any buffer's on the earlier charge. At 16 cells it does nothing.

5 figures The index that replaces the text

The quarter was a lucky number

A growing directory's document array was refitted best by a clock read off its escape and held until the characters had grown by a quarter: 0.098 bits a symbol for 4.52 final arrays read. A price that weighed the refit against the loss alone did worse, because the array's size cancelled and the price left out the reading that waiting costs. Priced with that reading — refit when the escape rebuilds since the last refit, plus the waste a refit would remove at an exchange rate, pass the characters a refit reads — the rule beats the hold wherever both read more than about five arrays: 0.080 for 5.04 against the hold's best 0.088, 0.052 for 6.38 against 0.066. It loses only at the quarter's own point, and the quarter turns out to be a lucky setting: held to 1.2 or to 1.33 the clock is worse on both counts, because two bursts of growth arrive two versions at a time and only a quarter refits after both halves.

6 figures What the machine does

A kick that moves the oldest

A cuckoo table full to 95% makes room for a new key by kicking a resident of the full bucket to its other bucket, and blind kicks under a cap of two were the cheapest design for lookups as well as insertions — with every key drifting outward with age, so that overflow held the oldest keys. Choosing which resident to kick, the oldest rather than one at random, was predicted to bring a lookup asked by recency from 1.09 reads to about 1.04 and to change nothing for even lookups. It brings recency to 1.040, and even lookups fall too, from 1.420 to 1.331, because a table that always kicks the oldest sorts itself by age: the newest three tenths of the keys almost never leave their first buckets, and the oldest tenth is 56% in overflow. It is the cheapest design at every mix of lookups to insertions measured. The risk named, chains that lengthen, arrives only with the cap: at a cap of 32 the oldest kick leaves 6.6% of keys in overflow where random kicks leave none.

5 figures What the libraries do

Every number of rounds, priced

A library merge sort given a file whose last tenth arrived late sorts the tail a buffer's worth at a time and then either sends every sorted piece into the head or merges the pieces first. A rule priced from measured tables chose the cheaper of the two ends at every buffer. Priced the same way at every number of rounds in between, it was predicted never to choose a partway number and to price every one within 6%. It chooses the cheapest number of rounds at all seven buffers on that input and at 14 of 15 settings across reaches and buffers; the one partway optimum among them — six rounds of seven, by 1% — it misses by choosing five, 3.8% dear. But the estimates are not all within 6%. At the three smallest buffers the first round is priced 15% to 25% wrong, high at one buffer and low at the others, because its pairs of pieces cross the head in a way no table of single runs describes; the rule survives it because one round is never close to the cheapest.

4 figures Two parameters

A gap between off and on

A landmark watch switched to the corners whenever a count of the traffic's last stretch ends read under 1,600 queries, and back on when a silence of 1,600 overruled the count. A count that only decides when traffic is fast need not use the silence's threshold, so a second, lower one was given it: keep the corners only once the count reads under 1,200. At one jump of the destination in 2,500 queries, on three stretch ends, that saves 3.5 cells a query — 117.8 against the override's 121.3 — but keeps the corners 13% of the time, not under 5%, and stays 1.4 cells above the watch rather than within one. At one jump in 1,000, where the corners are right, the gap costs 1.7 cells; on five stretch ends it saves nothing anywhere; and at slower paces, on traffic that changes pace and on drift, it changes nothing. The two jobs do want two numbers, but only one count length wants them.

5 figures What the machine does

An old key is a crowded key

A cuckoo table that makes room by kicking each full bucket's oldest resident keeps its newest keys at home and brings a lookup asked by recency to 1.04 reads, the cheapest design measured — but only at a cap of two kicks. At a cap of 32 it leaves 6.6% of its keys in overflow where random kicks leave none, and the explanation offered was a loop: an old key kicked to its other bucket is old there too, and the next chain moves it back. Sparing every key the chain has already moved changes nothing at caps of two and eight and makes cap 32 slightly worse, 7.1%; sparing the last sixteen insertions' moves gets it to 5.0%. There was no loop. A kicked resident's other bucket has room 22% of the time when the resident is chosen at random and 7% when it is the oldest: in a table that always moves the oldest, a key grows old because both of its buckets stay full. Kicking the older of four drawn at random keeps much of the gain at a long cap, 1.055 reads by recency and 0.5% overflow, and still costs more than the oldest kick at a cap of two.

5 figures Two parameters

A margin the count sets itself

A landmark watch switched to the corners when a count of the traffic's stretch ends read fast saved 3.5 cells a query at a moderate pace once given a second, lower threshold for switching off — but only on a count of three, and at a cost at the fast pace. A fixed gap is the same at every count, so the gap was set by the count instead: switch off only when the reading plus Z of its own standard errors is under 1,600. At one standard error on three stretch ends it makes exactly the fixed gap's choices, 117.8 cells a query at one jump in 2,500 and 144.5 at one in 1,000 — losing 1.9 to the override at the fast pace where under one was predicted, because fast spacings are bunched, not similar. Averaged over six streams every switch on three or five stretch ends lies within about a cell and a half of the best, 113.8: the off threshold, however it is chosen, trades the moderate pace against the fast one, and the count's length decides more than its margin.

5 figures

Before that

Everything published earlier, newest first. Titles only — the cards are on the full listing.

26 October 2026

20 essays on when the algorithm is a table, one pass, and no room, the floors, counting, when it does not fit, the data that is not a number, when the algorithm flips a coin, the other axis, what a bound is, what the machine does, what the libraries do and two parameters

A list as long as the doubt — when the algorithm is a table
A check as slow as what it checks — one pass, and no room
A sort that infers the order — the floors
A filter that reads the word it saves — counting
The sizes a store passes through — when it does not fit
A floor under every level — when it does not fit
A price the levels share — the data that is not a number
A reserve sized for the spill — when the algorithm flips a coin
A run end kept in a register — counting
The blocks the searches ask for — the data that is not a number
The room the lines lend — when the algorithm flips a coin
A select that starts near its answer — the other axis
A sample that has to be found — the other axis
The lines a sort writes back — what a bound is
A look that spreads the room — what the machine does
The rotation that could be priced — what the libraries do
A switch that hears the traffic stop — two parameters
Overflow holds the old keys — what the machine does
The head each piece will meet — what the libraries do
A silence that overrules the count — two parameters

21 October 2026

20 essays on one pass, and no room, when the algorithm is a table, the floors, when it does not fit, two parameters, counting, the data that is not a number, when the algorithm flips a coin, the other axis, what a bound is, the index that replaces the text, what the machine does and what the libraries do

The covariance the registers already hold — one pass, and no room
A line with a prior toward the classes — when the algorithm is a table
The commonest word at the distance — when the algorithm is a table
A list that gives back its places — one pass, and no room
A merge that decides per run whether to gallop — the floors
The question asked at every split — the floors
A division chosen before the queries arrive — when it does not fit
A watch that switches itself off — two parameters
What it costs to consult two bits a pair — counting
A flag that weighs the work as well as the bits — the data that is not a number
A switch that counts the jumps — two parameters
An offset that only has to reach its neighbours — when the algorithm flips a coin
Sparse on average, dense where it gathers — the other axis
Cuts that follow the gathering — the other axis
A background that holds two bands — what a bound is
Refitting when the escape is wrong — the index that replaces the text
A test that is the top of the search — the index that replaces the text
The memory a product does not charge — what a bound is
A kick that looks before it moves — what the machine does
How many pieces the head can afford — what the libraries do

15 October 2026

11 essays on when the algorithm is a table, one pass, and no room, the floors, when it does not fit, counting, the data that is not a number, when the algorithm flips a coin, the index that replaces the text, what a bound is, what the libraries do and what the machine does

A line the corpus finds — when the algorithm is a table
A share of a list of equals — one pass, and no room
The runs a short list cannot have — the floors
One bit a key, divided — when it does not fit
The runs too short to drop — counting
The optimum the flag took away — the data that is not a number
The worst of more lines — when the algorithm flips a coin
One doubling late — the index that replaces the text
The two parts the law was not given — what a bound is
Pieces that fit the buffer — what the libraries do
Room the chains could not reach — what the machine does

6 October 2026

6 essays on when the algorithm is a table, the floors, when it does not fit, two parameters, the index that replaces the text and what the machine does

The counts only short words carry — when the algorithm is a table
The order the column cannot see — the floors
The filter rebuilt with every write — when it does not fit
A watch that looks less — two parameters
A count that names every point — the index that replaces the text
The block already open — what the machine does

3 October 2026

7 essays on one pass, and no room, counting, when the algorithm flips a coin, the data that is not a number, the index that replaces the text, what a bound is and what the libraries do

The rise the correction kept subtracting — one pass, and no room
A pass repaid by the scans after it — counting
A bit for whether it closed — when the algorithm flips a coin
A flag for the blocks that change once — the data that is not a number
The shape arrived early and the bytes late — the index that replaces the text
Every cut the law moves — what a bound is
The moves no stable sort can skip — what the libraries do

1 October 2026

9 essays on the floors, the data that is not a number, when it does not fit, two parameters, the index that replaces the text, what a bound is, what the machine does and what the libraries do

The deepening the sort was already doing — the floors
The part every saving left alone — the data that is not a number
Two lengths that do the work of eleven — when it does not fit
A horizon the stream can supply — two parameters
Six bits a class — the data that is not a number
The collections the saving was quoted for — the index that replaces the text
A recut the law decides — what a bound is
The lookups a filter turns away — what the machine does
The skip the split already made — what the libraries do

29 September 2026

10 essays on when the algorithm is a table, one pass, and no room, when it does not fit, counting, two parameters, when the algorithm flips a coin, what the libraries do and what the machine does

The triples a typo writes — when the algorithm is a table
The slope the slow counter already shows — one pass, and no room
One length for the gaps and the clusters — when it does not fit
Two swaps a pass, and the stretches hold — counting
A refit priced before it is made — two parameters
A run answers what nobody asked — counting
Two hashes that shared their low bits — when the algorithm flips a coin
A code that has to fit its worst line — when the algorithm flips a coin
The buffer a schedule cannot bend — what the libraries do
The keys a capped chain leaves behind — what the machine does

27 September 2026

14 essays on when the algorithm is a table, one pass, and no room, the floors, counting, when it does not fit, when the algorithm flips a coin, two parameters, what a bound is, what the libraries do and what the machine does

A checker that stops at two edits — when the algorithm is a table
A cost built from two properties — when the algorithm is a table
The clock a burst cannot outlast — one pass, and no room
The keys worth counting before sampling — one pass, and no room
The merge that can say equal — the floors
The repeats a context cannot see past — the floors
A record of stretches, not pairs — counting
The resolution a range filter can afford — when it does not fit
A threshold knows only its own block — when the algorithm flips a coin
Starting from the corners — two parameters
A product paid for in blocks — what a bound is
Parts cut where the questions are — what a bound is
A request that reads the input first — what the libraries do
Spare where a bucket can use it — what the machine does

25 September 2026

11 essays on when the algorithm is a table, one pass, and no room, the floors, counting, when it does not fit, when the algorithm flips a coin, two parameters, what a bound is, what the libraries do and what the machine does

A second try before any feature — when the algorithm is a table
The classes held-out pairs cannot rule out — when the algorithm is a table
A detector that learns its own quiet — one pass, and no room
Where a context stops naming the letter before — the floors
A record the size of a pass's minima — counting
The small levels' share of a range filter — when it does not fit
The bits a second threshold costs — when the algorithm flips a coin
The candidates near where the queries end — two parameters
A file written once for the queries after — what a bound is
The request no price of memory would make — what the libraries do
The slack an insertion can reach — what the machine does

24 September 2026

11 essays on one pass, and no room, what a bound is, when the algorithm is a table, counting, when it does not fit, when the algorithm flips a coin, two parameters and what the machine does

A budget split before the question arrives — one pass, and no room
What a pass costs when it is a file — what a bound is
A trie fitted to its queries — when the algorithm is a table
The record measured where it would run — counting
The runs a range query can skip — when it does not fit
A reach that follows the stream — when it does not fit
The day a filter cannot grow — when the algorithm flips a coin
The digit a pass chooses for itself — counting
A penalty set by the block — when the algorithm flips a coin
A refit that changes one landmark — two parameters
Entries found by the rank of their tag — what the machine does

23 September 2026

6 essays on what the libraries do, when the algorithm is a table, one pass, and no room, when it does not fit, counting and two parameters

A guarantee that depends on an allocation — what the libraries do
The grain a corpus chooses for itself — when the algorithm is a table
The moments past the second — one pass, and no room
A planner that knows how sure it is — when it does not fit
The spread a merge sort does not have — counting
A placement after the traffic moved — two parameters

20 September 2026

6 essays on one pass, and no room, the floors, counting, when the algorithm flips a coin, what a bound is and what the machine does

What a heavier tail actually buys — one pass, and no room
A result the size of its own noise — the floors
The record that forgets on purpose — counting
A block the lookup can work out — when the algorithm flips a coin
A floor under a product — what a bound is
A tag that answers more than yes — what the machine does

17 September 2026

9 essays on one pass, and no room, the floors, counting, when it does not fit, when the algorithm flips a coin and two parameters

A decay measured from where it started — one pass, and no room
Every pair must be asked — the floors
The floor a merge cannot reach — the floors
The order inside a tie — the floors
The price of remembering an answer — counting
A key passed along the row — when it does not fit
The comparisons that name the answer — counting
Two blocks and the chances they add — when the algorithm flips a coin
A potential mended where it broke — two parameters

16 September 2026

6 essays on one pass, and no room, the floors, when the algorithm is a table and counting

The error of a difference — one pass, and no room
What a reordering costs to undo — the floors
The columns the candidates share — when the algorithm is a table
The lattice that decides the ties — when the algorithm is a table
Two floors that can be added — counting
The questions a sort asks twice — counting

15 September 2026

14 essays on when the algorithm is a table, counting, when it does not fit, when the algorithm flips a coin, two parameters and what the machine does

The bound a block can and cannot have — when the algorithm is a table
The order equal keys keep — counting
The sort that makes none of them — counting
What a planner pays to find out what to pay — when it does not fit
The sibling a full leaf asks first — when it does not fit
A summary's silence is a bound, not a count — when it does not fit
The bits given to the wrong keys — when the algorithm flips a coin
The read a filter has no key for — when it does not fit
What the queries know that the map does not — two parameters
A stop that is correct and never sooner — two parameters
Positions confined to one line — when the algorithm flips a coin
A lookup that stops caring how wide an entry is — what the machine does
How long a reweighting stays true — two parameters
Eight cells at once — what the machine does

12 September 2026

19 essays on when the algorithm is a table, counting, when it does not fit, when the algorithm flips a coin, two parameters and what the machine does

The split scan cut into blocks — when the algorithm is a table
The bound the search finds for itself — when the algorithm is a table
The worst case found by climbing — counting
A worst case ten positions wide — counting
The skew a few counters cannot repair — when it does not fit
The ties a rounded matrix makes — when the algorithm is a table
The sort whose count has no distribution — counting
What insurance against an estimate costs — when it does not fit
A filter that grows by moving a bit — when the algorithm flips a coin
Runs twice as long as memory — when it does not fit
The count of the part that was read — counting
A bound right for the wrong reason — two parameters
The keys that arrive late — when it does not fit
Two hash values and the keys they copy — when the algorithm flips a coin
Two estimates that must agree — two parameters
One Bellman–Ford buys every Dijkstra — two parameters
Where the landmarks stand — two parameters
The bucket that fits a line — what the machine does
The table stored the way it is filled — what the machine does

11 September 2026

20 essays on two parameters, when the algorithm is a table, counting, when it does not fit, when the algorithm flips a coin and what the machine does

A graph is as hard as its largest cycle — two parameters
The matrix a corpus wrote — when the algorithm is a table
An estimate borrowed from an easier problem — two parameters
The parameter plane has few answers — when the algorithm is a table
A distribution computed rather than sampled — counting
A triangle stored in a square — when the algorithm is a table
An estimate is a reweighting — two parameters
The estimate a plan rests on — when it does not fit
The intersection two filters cannot report — when the algorithm flips a coin
A count over every input — counting
More hashes or wider buckets — when the algorithm flips a coin
The permutation that moves almost nothing — when it does not fit
Where two searches should stop — two parameters
The join order is a guess — when it does not fit
The tie that breaks left — when the algorithm flips a coin
A filter past its design size — when the algorithm flips a coin
The filter each run carries — when it does not fit
Choices that are not independent — when the algorithm flips a coin
The order with the best depth — what the machine does
Two probes are two misses — what the machine does

10 September 2026

20 essays on when the algorithm is a table, two parameters, when the algorithm flips a coin, when it does not fit and counting

The cells are not the cost — when the algorithm is a table
The precondition on a function the caller writes — two parameters
The precondition that removes the queue — two parameters
The zero that moves the answer out of the corner — when the algorithm is a table
Two passes or one, and what the second one costs — two parameters
A distance divided by a length is not a rate — when the algorithm is a table
An insertion that can fail — when the algorithm flips a coin
The argmin that cannot go backwards — when the algorithm is a table
The edit that reaches back two rows — when the algorithm is a table
The order that has a depth — when the algorithm is a table
The second choice — when the algorithm flips a coin
Two parameters are not enough either — two parameters
One dial between two structures — when it does not fit
The cells that were never worth having — when the algorithm is a table
The evidence a filter cannot remove — when the algorithm flips a coin
Permuting is the harder problem here — when it does not fit
The exchange rate nobody wrote down — counting
The count that came from somewhere else — counting
The index that is not worth reading — when it does not fit
Two ways to join, and the ratio that decides — when it does not fit

5 September 2026

50 essays on the floors, the data that is not a number, what the machine does, what a bound is, the index that replaces the text, what is taught wrongly, structures, the other axis and what the libraries do

Work that falls as the answer grows — the floors
Proportional to the answer, not the alphabet — the floors
From the right, two of sixteen — the floors
The cell nobody filled — the data that is not a number
What repetition is worth once the logarithm is gone — the data that is not a number
The array is the length distribution — the data that is not a number
A node costs two ranks — what the machine does
Twenty bits apart — what the machine does
A code word is at least one bit — what a bound is
Two at binary, five at twenty-six — what a bound is
What a character costs on four machines — what the machine does
The index that does not notice — the index that replaces the text
The flat bottom of a shallow curve — what a bound is
Flat in the budget, and not — what a bound is
A boundary that costs nothing — what is taught wrongly
The price of a boundary is what precedes it — structures
The tree answers the question — the index that replaces the text
The exponential is in the expression — what a bound is
One copy per document is one occurrence per document — what is taught wrongly
The last array in the apparatus — structures
Two currencies for one separator — the other axis
Asking about symbols that are not there — the index that replaces the text
The array that says where is twice the samples — the other axis
A collection is a construction — what the libraries do
A saving quoted without its collection — what is taught wrongly
The apparatus, three times smaller again — the other axis
The branches that find nothing — structures
The smaller tree hands it back unsorted — what the libraries do
What the locating apparatus becomes — the index that replaces the text
Three savings on one structure — the index that replaces the text
A looser budget wastes a larger share — what the libraries do
A walk that does not prune — what is taught wrongly
One set, three orders — what is taught wrongly
A position split in two — structures
The ladder, and the rung that spends — the other axis
Every copy points right — structures
The same occurrences, less bookkeeping — the index that replaces the text
A price with no structure under it — what is taught wrongly
Where the sparse representation loses — what is taught wrongly
The floor was the marks — what the libraries do
Bits and steps on one frame — structures
The saving that is a loss — what the libraries do
Two factors that do not multiply — what is taught wrongly
Half an index is three permutations — the other axis
Two states per operator — structures
A constant factor, not a term — what is taught wrongly
The scan the order does not touch — what the libraries do
A cache below the reachable set — what is taught wrongly
Where the table starts paying — what the libraries do
The folklore is about a matcher — what is taught wrongly

1 September 2026

20 essays on the data that is not a number, what is taught wrongly, the index that replaces the text, what the libraries do, structures, the other axis, what the machine does and what a bound is

A million characters of the same thing — the data that is not a number
The half of a fall that is the logarithm — what is taught wrongly
Two thousand documents of two hundred characters — the index that replaces the text
The crossing that never arrives — what the libraries do
The shape of a real history's depth — the data that is not a number
One revision, one level — structures
The deepest text is punctuation — what is taught wrongly
The cap that would ship — what the libraries do
The half that is never asked where — the index that replaces the text
An index that cannot locate — the other axis
A sixth of what, exactly — what is taught wrongly
The saving, spent — what the libraries do
Every child at once — the index that replaces the text
The count that was already there — what the machine does
The tree the operation insists on — structures
A factor of fourteen, for four per cent — what a bound is
The array the walk never reads — the index that replaces the text
A document already in the answer — structures
What the chain cost — the other axis
The apparatus that is smaller than its index — what the libraries do

31 August 2026

20 essays on what the machine does, what the libraries do, what a bound is, the index that replaces the text, the data that is not a number, the other axis, structures and what is taught wrongly

The table that fits inside a block — what the machine does
The number that would choose a cap — what the libraries do
What the generated collection was right about — what the libraries do
Where a crossing moved to — what a bound is
An interval that grows at both ends — the index that replaces the text
The cap an automaton cannot see — what a bound is
The search that starts in the middle — the data that is not a number
A block, a class and an offset — the index that replaces the text
The parse in one pass of the text — the data that is not a number
A corpus that was not generated — the data that is not a number
Documents that are not the same length — the index that replaces the text
Two bits a value, and what undoes them — the other axis
The structure that was supposed to halve — the other axis
A bit for every bit — the other axis
The shape a range question is about — structures
The runs a permutation does not leave — structures
A schedule nobody writes down — what is taught wrongly
The level where compression stops paying — what is taught wrongly
What a quadratic construction was setting — what is taught wrongly
The dial that has no setting — what is taught wrongly

30 August 2026

20 essays on what a bound is, what the libraries do, the data that is not a number, the index that replaces the text, the other axis, structures and what is taught wrongly

The branch that cannot reach an answer — what a bound is
Where the exact rules pay now — what the libraries do
A parse that will not follow a long chain — the data that is not a number
The candidates a filter cannot avoid — the index that replaces the text
The case a failure link does not cover — what a bound is
The cost that is the size of the answer — what a bound is
The errors the rest of the pattern needs — the data that is not a number
What a ceiling costs in phrases — the index that replaces the text
A list of documents is not a list of occurrences — the index that replaces the text
The structure paid for before the first query — the other axis
The table the links already knew — the data that is not a number
The term that came back — the other axis
A bound that has to be paid for — the other axis
One separator, or one for each — the other axis
A rectangle over a permutation — structures
The operations a candidate count leaves out — what is taught wrongly
The cap that binds on one text and not another — what is taught wrongly
The pruning that loses an occurrence — what is taught wrongly
The ratio that was an implementation — what is taught wrongly
The occurrences a join invents — what is taught wrongly

28 August 2026

20 essays on the index that replaces the text, what the machine does, the data that is not a number, what a bound is, what the libraries do, the other axis and what is taught wrongly

The sampling that follows the runs — the index that replaces the text
A function with r pieces — what the machine does
The occurrence carried through the search — the index that replaces the text
The phrases a text copies from itself — the data that is not a number
An index with z in its size — the index that replaces the text
The branches an error opens — what a bound is
The occurrences that cross a boundary — the data that is not a number
The q-grams an error cannot destroy — the data that is not a number
The rule that pays on a long enough text — what the libraries do
The search that spends a budget — the index that replaces the text
The table that walks every pair — what a bound is
The collection decides which index is small — the index that replaces the text
The shift somebody published — the data that is not a number
Every occurrence at the same price — the other axis
The character that costs a chain — the other axis
A sampling that costs more than the array — what is taught wrongly
The measure that cannot see the alphabet — what is taught wrongly
The threshold that reaches zero — what is taught wrongly
Three savings in three currencies — what is taught wrongly
What the approximation gives up — what is taught wrongly

27 August 2026

10 essays on the floors, the other axis, one pass, and no room, structures and what is taught wrongly

The floor charged at every level — the floors
The tuples a summary does not report — the other axis
A floor with two variables in it — the floors
The period that is not a promise — one pass, and no room
The fold that minimises the wrong thing — structures
The sampler that cannot alias — what is taught wrongly
The shape one structure will not fold — structures
A parameter that waits for another — what is taught wrongly
The floor a merge does not settle at — what is taught wrongly
The warning that is silent for the right reason — what is taught wrongly

26 August 2026

10 essays on what a bound is, what the libraries do, the other axis, one pass, and no room, structures and what is taught wrongly

What a fold charges per level — what a bound is
Sized for a rate that does not hold still — what the libraries do
The cheap tail and the expensive merge — the other axis
The floor a histogram already knows — one pass, and no room
The tuples a merge does not give back — one pass, and no room
The window that is even in the wrong currency — one pass, and no room
The bill a partition only divides — structures
The histogram that cannot see the order — what is taught wrongly
The shape that moves the bill — structures
The boundary that hides the burst — what is taught wrongly

24 August 2026

10 essays on one pass, and no room, structures, what is taught wrongly, the other axis, what the libraries do and the floors

The state a merge is standing in for — one pass, and no room
The partition the analysis did not mention — one pass, and no room
The order nobody fixed — structures
The promise that does not survive the tree — what is taught wrongly
A window that is a duration — one pass, and no room
The window that is not full — what is taught wrongly
The clock that cannot see the burst — the other axis
The counter with no window in it — one pass, and no room
The fading nobody computes — what the libraries do
The pass that runs the other way — the floors

23 August 2026

10 essays on the data that is not a number, the floors, the index that replaces the text, what the machine does, the other axis and what is taught wrongly

The shift a set of patterns allows — the data that is not a number
A floor under a run count — the floors
The filter that feeds the table — the data that is not a number
The sampling that goes the other way — the index that replaces the text
The entropy that cannot see a copy — the data that is not a number
The index that stores the runs — the index that replaces the text
Select is not rank backwards — what the machine does
What is still proportional to n — the other axis
The ceiling the shortest pattern sets — what is taught wrongly
The filter that proposes everything — what is taught wrongly

21 August 2026

10 essays on what a bound is, one pass, and no room, the other axis, the floors, structures and what is taught wrongly

The pass that was never a parameter — what a bound is
The bits that say when — one pass, and no room
What a second pass buys — the other axis
A register that became a list — one pass, and no room
A floor one pass cannot get under — the floors
An error measured against the answer — one pass, and no room
The count that outlives its arrivals — structures
The counter that takes the smallest slot — structures
Two structures that are one — what is taught wrongly
The digest that promises nothing — what is taught wrongly

20 August 2026

10 essays on the index that replaces the text, when the algorithm is a table, what the machine does, the data that is not a number, the other axis, the floors and what is taught wrongly

An index larger than what it indexes — the index that replaces the text
A search that runs backwards — the index that replaces the text
The index that is smaller than the text — the index that replaces the text
A cost that is not one — when the algorithm is a table
A cell that has to know where it is — when the algorithm is a table
Rank is the only thing it does — what the machine does
The row that starts at zero — the data that is not a number
The text that does not have to be kept — the other axis
A floor that holds if something else does — the floors
A distance that is not a distance — what is taught wrongly

19 August 2026

10 essays on one pass, and no room, what a bound is, the other axis, when the algorithm flips a coin, the floors, what is taught wrongly and structures

The estimate that squares the stream — one pass, and no room
The error that is on the rank — one pass, and no room
The model a bound was quoted in — what a bound is
What a window costs in bits — the other axis
The independence an estimator spends — when the algorithm flips a coin
The summary that has to forget — one pass, and no room
The floor under a window — the floors
When the stream takes it back — what is taught wrongly
A promise about the rank is not a promise about the value — what is taught wrongly
A sketch that is allowed to be under — structures

18 August 2026

10 essays on when the algorithm is a table, the other axis, the data that is not a number, what the machine does, what is taught wrongly and structures

The cost is the number of subproblems — when the algorithm is a table
The same table, filled two ways — when the algorithm is a table
A band as wide as the answer — when the algorithm is a table
The table nobody has to keep — the other axis
A distance that is a path through a grid — the data that is not a number
The alignment that fits in one line — the other axis
A column computed in machine words — what the machine does
One pass for every pattern at once — the data that is not a number
A table wider than its input — what is taught wrongly
Every substring, in fewer states than substrings — structures

16 August 2026

10 essays on one pass, and no room, when the algorithm flips a coin, the floors, what is taught wrongly and structures

The answer that is allowed to be wrong — one pass, and no room
Counting past what the register holds — one pass, and no room
A count that is never under — one pass, and no room
A count read off the leading zeros — one pass, and no room
The correction that makes it work — one pass, and no room
The estimate that is a median of means — when the algorithm flips a coin
The floor under a summary — the floors
The guarantee that is one query wide — what is taught wrongly
The items that survive k counters — structures
The summaries that add — structures

15 August 2026

10 essays on the data that is not a number, when the algorithm flips a coin, what the libraries do, the floors, what is taught wrongly and structures

The comparison that is not one comparison — the data that is not a number
The shift the pattern already knows — the data that is not a number
The text that answers without reading it — the data that is not a number
The model is the compressor — the data that is not a number
The transform that emits nothing — the data that is not a number
A match decided by a number — when the algorithm flips a coin
The dictionary that builds itself — what the libraries do
The bits a coder emits — the floors
The optimal code that is beaten — what is taught wrongly
The index that is the text — structures

14 August 2026

8 essays on when it does not fit, what is taught wrongly, the floors, what the machine does and structures

One access, eight kilobytes — when it does not fit
Sorting what will not fit — when it does not fit
The layout that is told nothing — when it does not fit
The writes nobody counted — when it does not fit
The block that is not a block — what is taught wrongly
The floor under moving data — the floors
Two searches, one comparison count — what the machine does
A tree with nodes the size of a block — structures

11 August 2026

12 essays on what the libraries do, what the machine does, what a bound is, structures, counting and what is taught wrongly

The sort the library ships — what the libraries do
A run is a property of the input — what the libraries do
When galloping pays — what the libraries do
The pattern that defeats the pattern — what the libraries do
The branch the machine guesses — what the machine does
The threshold somebody chose — what the libraries do
A search with no branch to miss — what the machine does
The depth limit that almost never fires — what a bound is
The probe nobody waits for — structures
Two pivots and what they cost — counting
A bucket that becomes a tree — structures
The invariant that was wrong for seven years — what is taught wrongly

10 August 2026

12 essays on when the algorithm flips a coin, what a bound is, counting, what is taught wrongly, structures and the floors

A structure made of coin flips — when the algorithm flips a coin
The height is a distribution, and the coin is a parameter — when the algorithm flips a coin
One pass, k slots, and two randomness budgets — when the algorithm flips a coin
A filter that is allowed to be wrong — when the algorithm flips a coin
Expected is not average — what a bound is
A hash is a family, not a function — when the algorithm flips a coin
Counting the coin flips — counting
The formula everybody sizes filters with — what is taught wrongly
The priority nobody supplied — structures
What derandomising costs — what a bound is
A floor on the bits — the floors
The adversary who knows the seed — what is taught wrongly

5–8 August 2026

34 essays on counting, two parameters, the other axis, what is taught wrongly, what the machine does, the floors, structures and what a bound is

Counting instead of timing — counting
Counting on a graph — two parameters
Measuring what an algorithm keeps — the other axis
The words "on average" are not a number — what is taught wrongly
The count is not the time — what the machine does
The floor under every comparison sort — the floors
What amortised means — structures
What O-notation does not say — what a bound is
Choosing a growth factor — structures
Fitting a class to measurements — counting
How close anything gets to the floor — the floors
The cliff where the data stops fitting — what the machine does
The constant the notation drops — what a bound is
The stack nobody counts — the other axis
Two parameters, one bound, no order — two parameters
What randomising the pivot buys — what is taught wrongly
A limit is not a prediction — what a bound is
One run, four counts, four answers — counting
The floor moves when the question does — the floors
The frontier between time and space — the other axis
The probe formula nobody checks — what is taught wrongly
The tree that is a list — structures
Where an algorithm looks — what the machine does
The queue decides the class, and the pseudocode does not name it — two parameters
Building a heap from the bottom — structures
In place is a claim, and it is usually wrong about quicksort — what is taught wrongly
The adversary who hides the edge — the floors
The constant that is practically constant — two parameters
The count somebody chose — counting
The space the model does not see — the other axis
Where insertion sort actually wins — what the machine does
A list and a block of memory — two parameters
The floor when the values repeat — the floors
The bound with a precondition — two parameters

Every essay, by subject · by subject · by thread · search