A Philosophy of Software Design — Episode 1

The first episode introduces John Ousterhout's book, developed from his Stanford course. Its problem is complexity management. Design is not one large upfront phase: decisions evolve incrementally, but Agile does not remove the need to spend time on structure and repair.

Complexity is anything that makes a system harder to understand or change. It appears as change amplification, cognitive load, and unknown unknowns. Its main causes are dependencies and obscurity: a relationship either forces edits across locations or stays hidden. Small compromises accumulate gradually, like the boiling-frog story.

The author contrasts tactical and strategic programming. A tactical approach ships today's feature faster but leaves a costlier system for the next change. Strategic programming invests continually in design, interfaces, and tests. Working code is necessary, yet insufficient when every release reduces the team's future speed.

The practical section introduces deep modules: a simple interface should conceal substantial implementation. Information hiding reduces the knowledge required outside, while leakage and temporal decomposition create implicit coupling. A somewhat general-purpose module is often deeper than narrow operations when its common path stays simple.