All Entries

Why Buildkite moved its primary keys to UUIDv7, which keeps the global uniqueness of a UUID while staying time-ordered enough to sit well in a B-tree index.

The case for un-abstracting: once a shared abstraction starts collecting special cases and flags, inlining it back into plain duplication is cheaper than bending it further.

Sizes a B-tree node to a disk page and walks the math from there, showing why the primary key you choose sets how many pages every query has to read.

Hash tables win the single-lookup benchmark, yet databases default to B-trees. The payoff is everything past that one lookup: range scans, sorted reads, and maintaining many indexes at once.

A point-by-point rebuttal of Uber's famous 'we left Postgres for MySQL' post, arguing the problems were specific to how they used it, not a verdict on the database.

matklad on where architectural taste really comes from: reading large codebases closely and noticing which decisions kept them soft enough to change.

If you feed the LLM your project's architecture and conventions before asking it to write code, the output gets dramatically better, and here's what to include and what to skip.

Torvalds said 'talk is cheap, show me the code,' but now that machines can generate code, the person who can clearly articulate the problem is the one who matters.

Feature flags are just if-statements with an expiration date, and the real problem is that most teams forget to clean them up.

If you start with background, people leave before they reach the interesting part, so find the one thing that makes your reader curious and open with that.

Being endlessly useful feels virtuous and carries a cost: saying yes to everyone else's priorities is how you keep dodging the harder work that's actually your own.

ASCII characters have shapes, not just brightness values, and once you match on geometry instead of treating them as pixels the rendering quality jumps dramatically.

AI coding assistants are basically a REPL that calls an LLM in a loop, and once you see the 200 lines that make it work, the magic disappears.

After 14 years at Google, the lessons that stuck aren't about code, they're about navigating ambiguity, building trust, and the difference between being productive and being impactful.

You can pretend the layer below doesn't exist right up until it breaks, and then you'd better understand it anyway.

You implement backprop, attention, and a GPT from scratch with no frameworks, and by the end you actually understand what the machine is doing instead of just calling library functions.

Kleppmann explains double-entry bookkeeping as a data model, letting a programmer read a balance sheet as a graph of money moving between accounts.

Angular's change detection gets a lot simpler once you understand that immutability lets the framework skip entire subtrees instead of diffing every object property.

Karpathy's dense, opinionated survey of everything that changed in language models over 2025, written by someone who has built these systems himself.

If the process is about to exit, the correct garbage collection strategy is to do nothing, because the OS will reclaim everything faster than you ever could.

The clearest visual explanation of how Transformers actually work, from self-attention to positional encodings, now referenced by courses at Stanford, Harvard, and MIT.

The CLAUDE.md is the highest-leverage file in an agent-assisted repo. Writing a good one is mostly subtraction: keep the few instructions that change behavior, cut the rest.

Rewrite React from scratch following the real architecture, and suddenly the rules about hooks and re-renders stop being arbitrary and start being obvious.

Most codebases aren't hard because the problem is hard, they're hard because someone made you hold too many things in your head at once.

Big-O taught through visual intuition first, with interactive animations that show how each complexity class scales before any notation appears.

Build a SQLite clone from scratch in C, and after that you'll never write a SELECT statement without knowing exactly what the machine is doing underneath.

Concurrency is how you organize the work, parallelism is whether you have enough workers to do it simultaneously, and most people mix the two up.

Practical system design advice from someone who builds systems, not someone selling interview prep, focused on knowing your actual bottleneck and when not to distribute.

Once you make one function async, every function that calls it has to be async too, and that's not a bug, it's a language design problem nobody solved cleanly.

Animating height forces the browser to recalculate layout every single frame, and here are the concrete alternatives that don't.

LLMs made writing code faster but the hard part was never typing, it was understanding the problem, and that part hasn't gotten any easier.

Google's paper on how they load-balance all their incoming traffic with consistent hashing, kernel bypass, and no shared state between balancer machines.

When you set a breakpoint, the debugger literally overwrites your instruction with a trap, and the rest of the trick is just ptrace and knowing when to put the original byte back.

Sometimes writing it yourself is the right call because the dependency you avoided understanding will eventually break, and then you'll have to understand it anyway under pressure.

Paul Graham's short, opinionated take on what makes writing good, worth re-reading every time you sit down to write a design doc or blog post.

When nobody in the organization is responsible for a bad outcome, that's not an accident, somebody designed it that way.

A decade of frontend reactivity told by one of its architects, tracing how framework after framework converged on signals for fine-grained updates.

A well-researched deep dive into how SAD lights work and what “lumens” really mean - great for cutting through marketing hype.

Every frame your browser paints goes through the same pipeline, and most performance bugs come from accidentally triggering expensive stages you didn't need to.

A free book that has you build a working browser in Python, from raw socket to render tree, until no part of the pipeline stays a black box.

If you're managing state with a pile of boolean flags, you've already built a state machine, just a buggy one without a diagram.

The most thorough single reference on everything that happens between typing a URL and seeing pixels, and it's held up since 2011.

Chrome's own team explains why your browser runs a separate process for each tab and what actually happens at the OS level when you click a link.

Why a promise callback runs before a setTimeout of zero. Archibald walks the event loop's two queues closely enough that async ordering stops surprising you.

The reference list of the exact DOM reads and writes that force a synchronous layout. Keep it nearby and you'll stop triggering reflows inside loops by accident.

Model ability is jagged rather than a single line you cross; the system that aces a hard task can fail a trivial one, which makes 'is it AGI yet' the wrong question.

Karpathy builds an autograd engine from nothing, one line at a time, until backprop is something you could re-derive yourself instead of a formula you take on faith.

Most prompt advice is vibes. This whitepaper is the opposite - it breaks down why few-shot examples work, when chain-of-thought actually helps, and where most people over-engineer their prompts.

The best side projects aren't the ones that become startups. They're the ones where nobody's waiting on a PR review and the only deadline is whenever you feel like it.

Scroll-to-anchor seems trivial until you account for sticky headers, the back button, smooth scrolling race conditions, and intersection observer timing.

What separates dev posts people finish from ones they abandon: earning the click in the first few lines, then cutting the throat-clearing that makes readers leave.

Anthropic's interpretability team looks inside the model and catches it planning several words ahead and reasoning in a concept space shared across languages.

Two complete interpreters for one small language, one written for clarity and one for speed, after which compilers stop reading as wizardry.

The framework you pick matters far less than knowing it deeply; chasing rewrites rarely reaches the promised land, it just resets the treadmill.

The negotiation guide most engineers are never taught: you hold more leverage than you feel, nearly everything is negotiable, and you never name the first number.

Willison's method for a link blog worth following: never post a bare URL, always quote the source and add the one sentence of context only you can write.

Tools change; the method of systematically cornering the cause of a fault does not. A case for treating troubleshooting as a discipline you practice on purpose.

Someone implemented DOOM entirely in TypeScript's type system - no runtime, just the compiler crunching frames. It's the most unhinged proof that TS types are Turing-complete you'll ever see.

'Nondeterministic' is doing the work of five different words, and Hillel Wayne pulls them apart so you can name which one is behind your flaky test.

We want AI agents that can discover like we can, not which contain what we have discovered. Building in our discoveries only makes it harder to see how the discovering process can be done.

LLMs for software development offers a refreshing roadmap. By brainstorming extensively upfront, then iterating in small steps with careful testing, you can make quick progress without sacrificing maintainability. It’s a practical look at how to harness AI tools effectively, especially for creating clean, well-structured projects from scratch.

Write from what's odd about you. Karlsson reframes a blog as a long-running search query that routes the people who share your obsessions to your inbox.

antirez argues reasoning models are nothing exotic, just the same next-token predictors trained to spend more tokens thinking before they commit to an answer.

O'Reilly takes the long view, noting that every generation declared programming dead when the abstraction had only risen a level, and AI is the next rise.

A decade of reversed opinions from someone still in the trenches, where most of the certainties you pick up as a junior prove to be context-dependent.

Do-this-not-that writing advice you can apply mid-draft, from breaking up walls of text to leading with the concrete example over the abstract claim.

When the outcomes that matter are outlier-driven, optimizing the average is the wrong game; take many cheap shots and filter hard for maybe-amazing over reliably-fine.

A field report on leaving the cloud for your own racks, where the job resembles construction far more than writing a Terraform file.