Jonathan Blow on Refactoring

Summary

Jonathan Blow argues that refactoring can be worthwhile even when code currently works and is not expected to change. Unclear or unnecessary constraints in one part of a system can make other parts harder to modify and contribute to system bloat.

He describes a data-structure migration as a sequence of small, deliberate changes, such as renaming and replacing uses of a concatenator with relocations. The goal is to remove obsolete backend code. For large refactors, he recommends setting concrete milestones, checking whether each step is making progress, and reconsidering or reverting the plan if it is not working.

A Technique for Finding Missed References

Blow demonstrates how static typing can help identify overlooked uses of an old variable:

1. Add a local variable with the same name as the old one, but give it an incompatible type.
2. Compile the code. Any remaining use of the old name should produce an error, including uses that search-and-replace might miss.
3. Once the compiler confirms that the relevant code no longer refers to it, remove the temporary variable.

He contrasts this workflow with dynamic languages such as Lua, Python, and JavaScript, where refactors may provide less compiler feedback and therefore feel riskier. Strong static typing can make large changes more incremental and reliable, though performing them efficiently takes practice.

Refactoring with a Clear Direction

Blow compares refactoring to solving equations: substitutions count as progress only when they reduce uncertainty and move toward a defined result. Without a clear direction, code can be rearranged repeatedly without improving it.

Context

Reviews, guides, or tutorials: No product review is discussed. The segment offers practical guidance on safe refactoring, including the temporary wrong-type variable technique.

Main speaker/source: Jonathan Blow, speaking during a programming stream; audience questions prompt some of his explanations.