The Z80 at 50, Caches, and the Argument for Working Within Constraints

The Zilog Z80 turned 50 this year, and the milestone attracted the kind of HN discussion that goes well beyond nostalgia. Introduced in 1976 by Federico Faggin and Masatoshi Shima — who had previously worked on the Intel 8080 — the Z80 powered the TRS-80, the ZX Spectrum, the Amstrad CPC, and thousands of embedded systems across industrial, medical, and consumer applications. Fifty years later, the Z80 instruction set architecture remains in production in various forms. At 2.5 MHz the Z80 executed roughly one to two million instructions per second, a figure that invites an obvious comparison to modern cores executing billions. What the HN anniversary discussion returned to was not that gap but its implication: the Z80 was architecturally comprehensible — a skilled engineer could hold the entire design in their head and reason about every clock cycle. That transparency is essentially impossible with modern out-of-order superscalar processors.

The static search trees paper — technically a 2024 post resurfacing on HN — makes a related argument through a very different lens. Binary search on a sorted array is optimal in comparisons, requiring at most log-base-2 of N to find any element, but comparisons are not the bottleneck on modern hardware: cache behavior is. Binary search jumps around an array in patterns that hardware prefetchers cannot anticipate, generating cache misses that dominate total cost on large datasets. Static search trees rearrange sorted data in a B-tree-like memory layout aligned to cache lines, so that each lookup accesses memory in patterns the prefetcher can handle. The reported benchmark result is 40 times faster than naive binary search — but the honest qualification is that this advantage materializes only for datasets too large to fit in L3 cache, roughly tens of millions of elements or more. For datasets with temporal locality or non-random access patterns, the gap narrows considerably. Static search trees are also immutable by design; any insertion or deletion requires rebuilding the structure, making them best suited to read-heavy, write-rare workloads. Much of the underlying optimization, it was noted, is already implemented heuristically in production database B-tree indexes including PostgreSQL's.

Julia Evans's SQLite production piece added practical texture to the systems theme. Her analysis covers what happens in high-concurrency scenarios, how write-ahead logging mode changes the behavior of simultaneous readers and writers, and where SQLite's single-writer limitation creates real bottlenecks versus where it doesn't — the latter being more common than assumed. The Open Book Touch, an open-source e-reader on a custom board with an e-ink display currently seeking funding on Crowd Supply, and the Stenchill 3D-printable solder paste stencil generator rounded out a segment whose implicit argument was consistent: raw resources rarely substitute for clear understanding of the system you're working within.