Programming as Theory Building
1. Programming builds a human theory, not just text
When an engineering team finishes a software system, the visible outputs are source files, tests, and architecture documents. Peter Naur argues in Sections 1 through 4 of Programming as Theory Building that treating those texts as the primary product of programming mistakes the artifact for the understanding that produced it. Under what he calls the Theory Building View, programming is the activity by which programmers form a specific kind of insight: a theory of how certain affairs of the world are mapped onto and supported by a computer program.
To make the word theory precise, Naur draws on Gilbert Ryle's analysis of intellectual activity in The Concept of Mind. In Ryle's account, having a theory of a subject is different from memorizing a textbook or reciting rules. A person who possesses a theory can apply it to unfamiliar situations, explain the reasoning behind current arrangements, and answer hypothetical questions about how the pieces interact. Applied to software, this knowledge lives in the minds of the programmers as a connected grasp of both the external domain and the program text.
Naur specifies three distinct capabilities that demonstrate when a programmer holds a program's theory. First, the programmer can explain how the solution relates to the affairs of the world it serves, including which aspects of reality were modeled and which were simplified or omitted. Second, the programmer can justify why each part of the program is written the way it is by connecting implementation choices to the overall design. Third, the programmer can respond constructively to new demands by recognizing where an extension fits naturally within the existing structure.
Suppose a logistics company operates an inventory routing service. The codebase and internal wiki record every API endpoint, queue consumer, and database table. Yet when a warehouse partner changes how damaged pallets are reported, the original engineers immediately recognize that a damaged pallet behaves like a scheduled quarantine hold in the existing state machine. That recognition relies on knowing how physical warehouse practices were mapped onto the software's abstractions when the service was first designed. An engineer reading only the syntax sees functions and schemas, whereas an engineer holding the theory sees the correspondence between physical handling rules and code paths.
None of this implies that clear code, strong type systems, or written documentation are useless. Written artifacts preserve exact execution rules, anchor shared vocabulary, and prevent human forgetfulness on routine operational details. The boundary of Naur's claim is that written descriptions cannot exhaustively specify the similarity judgments needed to map messy, shifting real-world affairs onto finite program structures. Every sentence of documentation relies on unstated background context that would require further documentation to explain.
Evaluating a software team's health therefore requires looking beyond repository metrics and ticket velocity. Ask whether the people currently responsible for a service can exercise Naur's three capabilities without guessing: mapping domain rules to code paths, explaining why key modules take their current shape, and designing new features that preserve structural coherence. Where those three answers are missing, the team possesses the text of the program without its theory.