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.

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

When the algorithm is a table

A line the corpus finds

Substitution costs built as a transversion penalty plus the distance between the two letters' values on a graded property beat every partition of the pairs, when the model is told the property, and fall below the plainest matrix when told the wrong one. Fitting each letter's position on a line instead was predicted to find the property's order from about four times the told model's data and then behave like it. It finds the order on every corpus of 100 sequence pairs or more but one, and every miss starts with the two letters whose values differ by a fifth of a bit. But knowing the order is not knowing the costs. Its alignments are no better than six free classes' until 800 pairs, sixteen times the data the told model needed for the same score, and on a generator with no graded property at all it finds a line anyway, a quarter as long as a real one at 200 pairs, and pays for it against the plain partition.

6 figures One pass, and no room

A share of a list of equals

Estimating the third frequency moment by finding the heavy keys first and sampling the rest works best with one counted candidate on steep streams and sixteen at Zipf 0.5, and a system that does not know its stream's skew has to pick. Keeping a long list and counting a candidate only if it holds a stated share of the list's own moment was predicted to come within a few per cent of the best fixed list on every exponent. The share does choose: at 3% it keeps one candidate at Zipf 2, three at Zipf 1, five at Zipf 0.5. But a list the stream shortens is not a short list. Its sixty-four candidates cost 192 words on every stream, four times the whole of the best estimator on the steep ones. On a flat stream every candidate is a near-equal share of a list of equals, and no share can tell that none of them is heavy. No list length and share comes within 10% everywhere; at Zipf 0.5 alone, the chosen list beats every fixed one.

6 figures The floors

The runs a short list cannot have

A merge whose comparator can say 'equal' meets the counting floor on lists of repeated values, but it takes the gain only when one list's head happens to meet an equal head in the other. Comparing keys inside a list would find runs of equal keys on purpose, and was predicted to leave the worst case alone and help a great deal on average when the values are few. Solved exactly at four keys a list, it leaves the worst case alone and helps by under a hundredth of a comparison: a list of four has no run worth finding, and an equal answer already places two keys at once. On long lists the same idea, galloping over each run before comparing across again, does pay — a twenty-sixth of the textbook merge's comparisons with one value at 1,024 keys a list — and at every length it stops paying at the same place: when a value's run averages fewer than about thirty-two keys a list.

6 figures When it does not fit

One bit a key, divided

A levelled store of a million clustered keys, each level's range filter a pair of prefix lengths chosen when the level is written, captures 68% of a perfect filter's saving at two bits a key spread evenly when its keys arrive shuffled, and 94% when they arrive a cluster at a time. The proposal was to divide the memory by what each level's filter saves per bit, and it predicted the memory would leave the small levels, whose keys the arrival order had already sorted out. It goes the other way, as it did for single prefix lengths, and much further: the small levels take twelve to sixteen bits a key, the deepest level one, and the store captures 99% of a perfect filter's saving on both orders while leaving part of the budget unspent. Divided, one bit a key on average does what four bits spread evenly cannot.

6 figures Counting

The runs too short to drop

A pass between neighbours leaves the two-ended selection sort a record of 674 runs on 1,024 random keys, and the scans after it use them to repay three quarters of the pass. Keeping only runs of three keys or more was predicted to cut the record by two thirds and give back under a tenth of what it repaid. It cuts the record by 63%, and gives back 69%: runs of two keys answer half of everything the record answers, because three quarters of its answers are about two neighbouring positions — the question a scan asks about the key beside the extreme it has just found. The record's cost was never in its short runs. It was in writing each run as three words: every neighbouring pair at two bits a pair is 64 words, a thirty-second of the run list, and keeps all of them.

6 figures The data that is not a number

The optimum the flag took away

A bidirectional index's wavelet-tree levels were coded in blocks of 63 bits because a sweep found 63 the best length: shorter blocks pay for more classes, longer ones for offsets that approach the block's own length. Then the classes were coded as runs and each offset given a flag to choose a code of its value changes instead. Lengthening the blocks to 127 bits was predicted to save on English words and the repetitive collection and to change nothing on random letters. It saves on all four texts, and there is no best length short of 1,023 bits on three of them: English words fall from 1.431 bits a character at 63 to 1.304 at 1,023. Under the codings the optimum came from, the same levels cost 3.728 at 1,023. The flag turned a long block's offset into the cost of its change points, which no block length moves, and left the length to be set by the one thing still growing with it: the work of a rank.

7 figures When the algorithm flips a coin

The worst of more lines

A blocked Bloom filter's threshold table, stored as a bit for whether each block closed and a value for each block that did, packed a fixed number of blocks to a cache line, costs 3.64 bits a block at 64-bit blocks because every line must hold the most closed blocks any line draws. Sizing the line for the mean plus one standard deviation, and moving a line's excess values to a shared overflow, was predicted to cost about 3.25 bits and send under one closed lookup in a hundred to a third line. The lookups behave as predicted: 0.6% read the overflow, 2.003 lines a lookup. The bits land at 3.38, because every line must carry the offset where its moved values begin. What the measurement found instead is that the worst line is a property of how many lines there are: 3.38 bits at two thousand blocks and 3.62 at a hundred and twenty thousand, while the line sized for the usual line costs the same at every size.

6 figures The index that replaces the text

One doubling late

A document array coded by its documents' lengths and refitted each time a growing directory's files double needs an escape for the files added in between, and the escape's right weight is the share of the characters still to come. Weighting it by the share that arrived since the previous refit was predicted to cut the mean loss below a quarter of a bit a symbol. It cuts nothing: 0.518 bits a symbol, against 0.389 for an escape that always takes half the coding space. The growth seen is the growth to come one doubling late — 71%, 50% and 27% where the doublings that followed brought 50%, 27% and 8% — because this directory's growth slowed at every doubling, and before the first refit there is no growth to read at all. A Huffman code also rounds every weight to a whole number of bits, so being right within a factor of two buys nothing. Started from half, the growth seen averages 0.356, the best a store can know, and the weight nobody can know reaches 0.183.

6 figures What a bound is

The two parts the law was not given

The square-root law moves almost every cut of a seven-part file whenever its band of hot queries moves. A background cut once by keys, with only the part holding the band cut again, was proposed instead: a recut would rewrite a seventh of the file. It does, and it beats the law at every drift speed — 365 transfers a query against 417 at a moderate drift — but it wins with nine parts to the law's seven. Given nine, the law costs 322. Held to seven, the fixed background loses to the law at every speed. What survives the fair comparison is narrower and still useful: six parts by keys, with the band's part cut in four, ties the nine-part law on drift for a quarter of its rewriting. It loses on jumps, because a fixed background waits about three hundred queries to believe the band has left before it moves, and it pays double wherever a background cut runs through the band.

7 figures What the libraries do

Pieces that fit the buffer

A sorted file with a late tenth appended costs the buffer-limited stable merge sort 2.93 moves a key at a buffer of a 64th, fifteen times the least any sort could move, and two thirds of it is the tail sorting itself. Taking the tail a buffer at a time, inserting each key into a sorted piece in the buffer and merging the piece into the head, was predicted to bring that under two moves a key at small buffers. It never comes within twice the merge sort: insertion costs a quarter of a piece a key, and the smaller the pieces the more often each one's merge crosses the head's top fifth. The same pieces sorted in place by merging do pay, at 2.41 moves a key, and for a reason the proposal did not name: a piece that fits the buffer merges into the head without a single rotation. The gain lasts only while the tail belongs near the top of the file.

6 figures What the machine does

Room the chains could not reach

A cuckoo table that caps its kick chain at two, churned at 95% load, keeps 9.2% of its keys outside their buckets while 13.8% of its entries stand empty. Keeping a few entries in each region aside for the keys the cap stops, at the same memory, was predicted to remove most of the overflow for a tenth of a kick an insertion. It removes none of it: the share outside the buckets stays at 9.2% with up to eight entries kept back, because a key is stopped by the pair of buckets its chain visits, never by a region short of room. What the reserve changes is where the stopped keys sit, and that is worth having. Read with the region's header, four entries a region take the overflow blocks from 9.2% of keys to 6.1% when keys stay and from 4.9% to 2.3% when keys go home with an open block, for no kick anyone can measure — until the reserve takes room the chains were using, at sixteen entries when keys stay and at eight when they go home.

6 figures

Before that

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

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