Blog

Inheritance gets a bad reputation. Much of that reputation is deserved. But there is one pattern where it genuinely shines: the template method.

There’s a well-known quote about the two hard problems in computer science: cache invalidation and naming things. The naming problem is usually discussed in terms of choosing good names. But there’s a subtler version of the problem that causes more damage.

Make is older than most programmers. It was written in 1976. It has quirks that would be considered bugs in any modern tool — tab sensitivity, implicit rules, recursive evaluation. And yet it persists.

Every system I’ve worked on has logs. Most of them are unread until something breaks.

Operating systems measure context switches in microseconds. Humans measure them in minutes. Both undercount the real cost.

Most people debug forward. They start where they think the bug is and trace execution until something looks wrong. This works when your intuition is correct. When it isn’t, you end up wandering.

There’s a better approach.

Everyone loves adding to the backlog. Few people enjoy removing from it.

Pair programming has a reputation problem. People think it means two people at one keyboard, one typing while the other watches. The reality is more subtle and more useful than that.

The part nobody talks about is the contract.

There’s a chart making the rounds right now showing coding benchmark scores for the latest open-weight models alongside the proprietary heavyweights. The gap between them is almost invisible.

Six months ago, if you wanted frontier-level code generation, you had one option: pay for API access to a proprietary model. Today, multiple open-weight models — some trained entirely on non-NVIDIA hardware — are posting competitive numbers on the same benchmarks.

This matters for builders, not just researchers.