Reads

A reading log that updates every Sunday (when I've read enough).

I save articles to my read-it-later app and write quick thoughts as I read. An automated task pulls everything I've read during the week, uses AI to review the content and expand my notes into something more coherent, then publishes them here.

July 13, 2026#

Ten years of ClickHouse in open source — The detail that stuck is the monthly drill where they deliberately shut down a datacenter to force the system to survive it. Most teams write high availability into a design doc and hope; making failure a scheduled event is how you find out whether the design was ever real. I also liked Milovidov’s admission that removing code is now his favorite thing to do, coming from the person who built the whole thing starting with a first query pipeline that just printed numbers to TSV. Ten years in, the reflex has flipped from adding to subtracting, which feels like the honest endpoint of maturing on a codebase.
How we scale PgBouncer in ClickHouse Managed Postgres — The core constraint is almost embarrassingly simple: PgBouncer is single threaded, so a 16 vCPU box runs one busy core and fifteen idle ones. Their fix, many processes sharing a port via so_reuseport, is the obvious move, but the part I hadn’t considered is what breaks once you do it. Postgres cancel requests arrive on a separate connection, and the kernel can route that cancel to a different process than the one holding your session, so they had to make the processes peer and forward cancellations to each other. That is the kind of second order detail that turns a clean idea into real infrastructure, and it took them from 87k to 336k TPS on identical hardware.
Good Tools Are Invisible — The line I keep coming back to is that you cannot have an honest conversation about a tool with someone who has decided the tool is part of their personality. It reframes a lot of editor arguments as identity defense rather than actual disagreement about productivity. His test is blunt and useful: measure wall clock time and how many mistakes you made, not how clever the workaround felt. I’ve caught myself enjoying a fiddly vim macro that Sublime’s multiple cursors would have done in a tenth of the time, so this one landed a little too close to home.
Finding a needle in a 4 GB haystack: from 0.75 GB/s to 49 GB/s in Go — The counterintuitive result is that parallel pread beat memory mapping, because copying data with the kernel’s tight loop turned out cheaper than eating a page fault per 4 KiB page. I would have bet on mmap and been wrong. The other lesson is that SIMD stopped mattering the moment the work went memory bound: making the CPU side 8x faster does nothing when the CPU is asleep half the time waiting on cache lines. Past a point you’re not optimizing code anymore, you’re optimizing against DRAM bandwidth, and the honest ceiling here was single channel DDR5 at around 48 GB/s.
Half-Baked Product — This is a parable about an oven startup and it was the most uncomfortable thing I read this week, because I recognized every scene. The one that cut deepest: the rotating base was always the second highest priority, and the second highest priority never gets done. Nobody decides to abandon the core product, it just erodes one ticket at a time while the algorithm that burns bread 10% of the time sits untouched under twelve new buttons. The ending, where an identical fresh engineer signs on for the same dream and laughs off the rotating base warning from the forum, is the darkest part, because it says the problem was never a single person.
Maybe you should learn something — The mechanism I hadn’t articulated before is that sleep is where the improvement actually happens, so the first session feels awful and the real progress only shows up the next day. That matches every instrument and language I’ve picked up and quit, usually right at the point where quitting felt most justified. I also liked the practical guardrail that sessions should stay in the 30 to 45 minute range, because practicing while tired just trains your mistakes in. The claim underneath all of it, that slowly learning a hard thing rebuilds your sense of agency, is really what the piece is about.
98% isn’t very much — The framing that stuck: 98% of the population is not 98% of your audience, and even that slice is real people staring at a broken screen. His concrete case is CSS nesting getting called widely supported in 2023 while actually working for only 70% of one client’s real visitors over a year. That gap between the caniuse number and your actual traffic is exactly where I stop trusting the green checkmark. It’s a good argument for graceful degradation over feature detection headlines, because the 2% stays invisible right up until it’s your customer.
If you’re a button, you have one job – Unsung — Wichary’s test is tapping rotate eight times fast and watching what the phone does with the taps it can’t animate yet. The iPhone buffers them and plays catch up; the Nothing Phone gives you a haptic buzz and drops the input on the floor. The rule, never make the user wait for the animation to finish, sounds obvious until you notice how many interfaces treat the animation as the source of truth instead of the state. His situational power user point is the good bit: someone rotating fifty scanned documents is briefly a power user of a feature its designer assumed was casual.

June 29, 2026#

Building race telemetry for a ’92 Honda Accord — The RPM measurement bug is the part I keep thinking about. Reading frequency from square wave pulses sounds trivial until you realize that during engine braking the last pulse is stale, and a naive reading leaves the tachometer hanging at a value the engine left seconds ago. Their fix is taking the minimum of two estimates, pulse-only and pulse-plus-gap-to-now, which is the kind of thing you only learn by watching it fail. The other detail I liked is choosing raw GPS over integrated wheel speed because GPS noise stays constant while integration accumulates error. A messier signal that does not drift beats a clean one that does.
Understanding my newly recognized operating system — The line that landed was “I don’t just like systems. I depend on them.” As engineers we build routines and predictable structure around ourselves and frame it as discipline or good taste, when for some people it is load-bearing. What got me was his split between the two diagnoses: ADHD explained the visible chaos, but autism explained why the structure underneath was never optional. The detail about medication flattening his drive to build is a hard tradeoff to read, because the thing being treated and the thing he values were tangled together.
The Coming Loop — Ronacher’s sharpest point is that models “add fallbacks instead of making bad states impossible,” and a harness loop running unattended amplifies that with every iteration. You end up with code that defends against situations that can no longer occur, and nobody left who can explain why. His framing of where loops actually work is useful: porting, perf exploration, security scanning, all cases where the output is disposable or transformed rather than something you live with for years. The part I am still sitting with is the shift from software as a machine you understand to an organism you diagnose. I am not sure I want to merge code I cannot explain, but his argument that opting out may not be a choice is hard to dismiss.
I’m not a cat — This is the strangest piece in the list and the one that lingered most. The claim that writing physically colonized our brains, repurposing the facial recognition system to read letters, reframes literacy as something that happened to us rather than something we invented. From there the question of whether intelligence lives in individuals or in the culture they swim in stops feeling like wordplay. The bit about our culture starting to talk back through AI is where it stopped being abstract for me. I do not buy all of it, but it left me less sure where the boundary of a single mind actually sits.
The New Internet — Pennarun’s argument is that most of our infrastructure complexity is a workaround for one accident, IPv4 scarcity, which gave us NAT and firewalls and the asymmetry where only servers get real addresses. Once you frame the cloud as rent extraction on connectivity, the way IBM rented mainframe time, a lot of architecture decisions look less like engineering and more like paying a gatekeeper. Taildrop as a single HTTP request between two devices is the concrete version of what he means: no upload, no bucket, no storage bill. The honest part is that he admits the chicken-and-egg problem, with roughly 1 in 30,000 people on Tailscale today, nobody builds for peer-to-peer until it is already everywhere.
The age of the solopreneur — The number that made me stop was the share of solopreneurs clearing seven figures doubling in just two years, because that is about quality, not just more people filing paperwork. It is the difference between “more small businesses exist” and “tiny businesses are reaching outcomes that used to require a team.” Their argument that AI fills the gaps founders previously hired for is the mechanism, and the cross-country corroboration, registrations up 40% in Australia and 80% in France, makes it harder to write off as a US fluke. I appreciated that they call their 20% AI-impact estimate a floor rather than a headline, since the indirect signals like LLM referrals are exactly the kind of thing that undercounts.
Every Frame Perfect — Tonsky’s test is one sentence that reorganizes how you look at UI: take a screenshot at any moment, and you should be able to explain everything on screen. Most janky animations fail it because they interpolate the wrong properties independently, like his Safari example where the placeholder text and the cursor animate in from different positions as if they were never the same element. The insight underneath is that motion gets treated as an afterthought bolted onto two static states, when the in-between frames are where the design either holds together or exposes that it was never coherent. It is a cheap heuristic with a high ceiling, and I will probably start screenshotting mid-transition now.
SQLite is All You Need for Durable Workflows — The reframe that did the work for me is that the durable thing is the workflow state, not the infrastructure, so compute can stay cheap and disposable. Once you accept that, reaching for Temporal or a cloud queue on day one looks like buying high availability you do not yet need. The fleet-of-tiny-servers model, each agent or tenant owning its own SQLite file backed up to S3, fits bursty AI workloads better than one shared always-on database, and the fault isolation is a nice bonus. The honest caveat is that Litestream replicates asynchronously, so a volume that dies before its newest writes ship to S3 loses them, which is the exact tradeoff you have to be deliberate about before betting on it.

June 25, 2026#

There Are No Instances in atproto — overreacted — The RSS analogy is what makes the whole thing click. Counting Bluesky instances misses the point the same way counting RSS readers would have missed the point of blogs. What matters is whether you can swap your hosting without losing your identity, and whether new applications can build on top independently. Dan literally moved his hosting to a different provider the same day he wrote this, which makes the argument more concrete than any architecture diagram could.
What the Fuck Happened to Nerds — The core claim is that tech leaders are liquidating 40 years of accumulated “boring nerd” credibility into celebrity, and the exchange rate will catch up with them. The Founders Fund Mafia video is the perfect exhibit: billionaires with weapons contracts and a line to the White House playing a deception game on camera, produced like reality TV. The author’s right that if any of them faces scandal, the footage of them being “good at hiding how good they are at deception” writes the headline itself.
Adaptive compression codec — A 96.9% storage reduction on sequential integers is striking, but the design philosophy matters more than the numbers. The system tests compression candidates on sample blocks and picks the winner per column, so users never choose between LZ4 and ZSTD. The idea that “the system should test, measure, and adapt where it has enough evidence” extends well beyond compression — if the database can figure out the right codec, why are we still manually picking primary keys?
How to Earn a Billion Dollars — The math is the easy part — 15% monthly growth for five years turns $10k/month into $526M/year. What makes Graham’s version of this argument interesting is the second half: the best startup ideas sound terrible initially, so deliberately searching for them filters out the winners before you even start. Airbnb got funded despite YC thinking the idea was bad. Not sure I fully buy “just build cool stuff with friends” as universal advice, but the filter problem is real — if an idea sounds obviously good, someone with more resources is already doing it.
Leaving Mozilla — The diner analogy carries the whole piece. Firefox users are people who walked past every McDonald’s to find the mom-and-pop place, and leadership keeps responding by trying to serve Big Macs. After 15+ years, JR Conlin’s frustration reads less like bitterness and more like watching something you helped build get managed by people who don’t understand why it worked. The question “Who am I doing this for?” hits hard when the answer he kept arriving at was “so that someone else can get a gold star on their resume for the next gig.”
Introducing RawTree — The “schema before data” problem is real — I’ve worked on enough projects where the schema was wrong by the time the first real data showed up. The dynamic type system handling mixed types in GROUP BY and aggregations is the technical detail that separates this from “just throw JSON in a column.” Whether automatic primary key generation and self-materializing projections hold up at scale is the open question, but the premise that the system should observe actual queries and optimize accordingly feels like the right direction.

June 14, 2026#

Software Is Made Between Commits — The claim that stuck with me: “the conversation that generates the code is becoming the true source of our software.” I’ve felt this shift myself. The PR description is always a lossy reconstruction of what actually happened. DeltaDB anchors references to deltas instead of line numbers, so they survive as code moves underneath. That’s the kind of detail that separates a real rethinking of version control from just adding chat to Git.
If Claude Fable stops helping you, you’ll never know — The real problem isn’t the restriction itself, it’s that it’s invisible. When a tool silently degrades instead of refusing, you can’t tell the difference between “this problem is hard” and “the model is deliberately underperforming.” The author makes a good point that fine-tuning CLIP models for a travel app would have been frontier research five years ago. The boundary between normal product work and “frontier AI development” keeps shifting, and Anthropic gets to draw the line.
Replace your CI with a merge queue — “The only thing worse than cleaning up after someone else is cleaning up after someone else’s robot.” That line captures what’s broken about agents and CI right now. By the time CI fails, the agent’s context window is gone, so nobody is left to fix the mess. Running tests before merge instead of after is such an obvious fix that it makes you wonder why we ever settled for the alternative, even for human workflows.
Changing How We Develop Ladybird — The key insight here is that effort is no longer a proxy for trust. A substantial patch used to signal that someone invested real time and understood the codebase. With AI, that signal is gone. For a browser running untrusted input from the entire internet, the stakes are too high to rely on code review alone. I’m curious how this plays out. Closing PRs is a clear answer, but it also means losing the serendipity of outside contributors who spot things maintainers don’t.
the mathematics of multi-tenancy — The “heat ratio” framing (peak divided by average workload) gave me a much sharper way to think about when multi-tenancy actually works. Two things kill it: correlated workloads and size skew. Just 25% correlation in workload patterns is enough to wipe out the cost advantage, even with hundreds of tenants. The detail about S3 splitting at the file fragment level, not even per object, explains a lot about why it works so well as everyone’s default storage layer.

May 24, 2026#

We’ve made the world too complicated — The piece names something I keep circling back to — most of us operate daily within systems we can’t meaningfully inspect. We write code on machines we don’t fully understand, live under laws we haven’t read, eat food from supply chains we can’t trace. The author doesn’t pretend to have a fix, and that honesty is the whole point. The temptation is always to either despair at the complexity or act like you’ve got a handle on it. The harder position is admitting you don’t, and still trying.
Our billing pipeline was suddenly slow. The culprit was a hidden bottleneck in ClickHouse — The detail that got me: more than half of query duration was spent waiting on a mutex that only protected a read operation. Nobody was writing — every thread just needed to look at the parts list, but they were all queuing up for an exclusive lock. The fix sequence is textbook — shared locking, deferred copying, binary search — but the diagnostic path is the interesting part. Flame graphs from trace_log pointed straight to the synchronization layer, not I/O or compute. A good reminder that the bottleneck is almost never where you assume it is, especially after a migration that “shouldn’t have changed anything.”
How to achieve truly serverless GPUs — The number that reframes everything: typical GPU utilization in inference sits at 10-20%. That’s not a technical problem, it’s an economic one — you over-provision because cold starts take minutes. Modal attacks the startup chain at every layer: pre-allocated buffers, lazy filesystem loading, CPU snapshots via gVisor, GPU memory checkpoints. The result is 40x faster scaling, from ~2,000 seconds down to ~50. What I find most interesting is the GPU snapshot trick — checkpointing CUDA graph compilation and Torch compiler state so you skip minutes of initialization on each new replica. If this holds at scale, the pricing model for inference changes fundamentally.
Why senior developers fail to communicate their expertise — The two-loops framing clicked for me. The business runs on reducing uncertainty fast — ship, test the market, learn. Senior developers run on managing complexity — keep the system stable so you can still ship next quarter. Both are right, and the failure isn’t disagreement, it’s that they’re solving different problems in the same conversation. The proposed escape hatch — “can we try something quicker?” — is deceptively simple. It acknowledges the speed need while redirecting toward a smaller experiment instead of bolting more onto the production system. I’ve been in that exact meeting, arguing for stability while everyone else wants velocity, and I wish I’d had that framing earlier.
Local AI Needs to be the Norm. — The argument that landed: modern devices ship with neural engines that sit mostly idle while apps stream data to servers in Virginia. For tasks like summarization, extraction, and classification, you don’t need frontier models — you need something fast and private that runs on hardware the user already owns. The Brutalist Report example is a good proof point: article summaries generated entirely on-device, no server, no API key, no billing. I’m not sure this generalizes to everything people want from AI, but for the 80% of features that are really data transformation rather than reasoning, the case for local-first is hard to argue against.
There was only mom — This one is hard to comment on without being reductive. José writes about caring for his mother during her last days with cancer, and the specificity is what gives it weight — asking for forgiveness and her writing “I forgive you” because she couldn’t speak, changing her diaper and recognizing it was the first thing she ever did for him. The piece moves between raw grief and philosophical reflection without the transitions feeling forced. What stayed with me is his reason for publishing: “many moms go forgotten.” There’s something defiant about using a blog post as an act of remembrance.
Staring at walls to improve focus and productivity — The practice sounds absurd — sit and stare at a blank wall for 5-10 minutes when you can’t focus. But the reasoning holds: 87 GB of daily information input, constant stimulation, a productivity cycle built on caffeine and scrolling that never actually recharges anything. It’s basically meditation without calling it meditation — unfocused peripheral vision to trigger the parasympathetic nervous system. What I recognize most is the description of the resistance. Your brain fights doing nothing the same way your body fights a cold pool. I’ve tried similar resets and the hardest part is always convincing yourself that doing nothing is doing something.
Ghostty Is Leaving GitHub — The detail that says it all: Hashimoto kept a journal of outages, and “almost every day has an X” for days when GitHub blocked his work. After 18 years of daily use since 2008, this isn’t someone looking for an excuse to leave — it’s someone who ran out of patience. The emotional framing is honest too: “I want to be there but it doesn’t want me to be there.” What makes this more than a rant is who’s saying it. A high-profile open source maintainer leaving is a real test of whether developer loyalty to GitHub is about the platform or just inertia.
How The Heck Does Shazam Work? — The clever bit isn’t the fingerprinting itself — it’s how they pair peaks. A single frequency peak is too common to identify anything. But pairing two nearby peaks with their time offset creates a hash specific enough to match against millions of songs. The constellation map approach — keeping only the loudest peaks, discarding everything else — is what makes it noise-resistant, because ambient sound almost never dominates a frequency region. Built on Avery Wang’s 2003 paper, and the core algorithm hasn’t fundamentally changed since. Sometimes the right abstraction just lasts.
I am building a cloud — David Crawshaw (Tailscale co-founder) makes the case that clouds got worse as they got bigger. The IOPS argument is the most concrete: remote block storage added 10% overhead with hard drives, but with SSDs offering 20-microsecond seeks, that overhead became 10x. We adapted our architectures to hide latency that shouldn’t exist. Same story with egress — 10x markup over bare metal, treated as normal because everyone charges it. The bet with exe.dev is that agents will need a different compute primitive: flexible CPU/memory without fixed VM shapes, local NVMe, built-in TLS. Whether it wins is anyone’s guess, but the diagnosis of what’s broken rings true to anyone who’s wrestled with instance sizing.

Page 1Next →