Software Engineering Is the Scientific Method, Continued
Code that cannot be tested is not merely inconvenient, it is pre-scientific
Software engineering did not invent rigour. It inherited it because it needed it.
The journey of the scientific method, from Aristotle’s ordered observations to machine-assisted hypothesis testing, is not a historical curiosity. It is the spine of what serious software engineering has always been trying to become. When Dave Farley insists that software engineering is the application of a scientific approach to software development, he is not offering metaphor or motivation. He is making a precise, historically grounded claim. He’s also bravely stating a reminder.
To understand why that claim matters, we must remember where the method came from and what it was designed to protect us from.
From Authority to Evidence, Again and Again
For most of human history, knowledge was something you inherited rather than tested. Aristotle reasoned brilliantly, but rarely arranged the world so it could answer back. The scientific method emerged not because humans lacked intelligence, but because intelligence alone proved unreliable. Rational vacuum did not progress make.
Each major shift in the method was a response to failure:
Logic without experiment produced beautiful theories that were wrong.
Observation without structure produced anecdotes masquerading as truth.
Experiment without statistics and falsification produced confidence without certainty.
Results without peer scrutiny produced errors that spread faster than facts.
The method evolved as a defence against ourselves. And now it shows signs of being a key defence against our AI collaborators.
This is the first anchoring insight for software engineering: the method exists because smart people/AI are consistently wrong when unchecked.
The Scientific Revolution and the Birth of Intentional Feedback
Galileo’s real contribution was not the telescope, it was the insistence that claims about reality must survive contact with measurement. Newton’s gift was not calculus alone, but the union of prediction and verification.
This was the moment science refined feedback loops:
Hypotheses predicted computable consequences.
Observation and experiments generated data that could be refined to evidence.
Discrepancies forced theory to change.
Modern software engineering lives or dies on the same loop.
When we talk about fast feedback, testability, and incremental change, this is speaking Newton’s language in systems of valuable software flow. A test is a falsification attempt. A deployment pipeline is an experiment harness. Production metrics are observational data from the real world.
Code that cannot be tested is not merely inconvenient, it is pre-scientific.
Measurement, Statistics, and the End of Intuition Worship
The 18th and 19th centuries professionalised science. Measurement displaced intuition. Probability replaced certainty. Darwin waited decades because evidence mattered more than confidence.
Software engineering keeps relearning this lesson the hard way.
Intuition-driven development feels fast. Evidence-driven development is fast, but only once feedback loops exist. In software engineering the emphasis on empirical evidence, automated testing, and continuous delivery mirrors the historical pivot from “this seems right” to “the evidence disagrees”.
Velocity without measurement is astrology with deadlines.
Falsification and the Humility of Good Engineers
Karl Popper sharpened the scientific method by reframing its moral core: science advances not by proving theories correct, but by exposing them to failure.
This idea maps cleanly onto modern engineering practices:
Tests exist to break assumptions.
Experiments exist to disconfirm predictions.
Small batch sizes exist to limit blast radius so falsification doesn’t kill us all.
Insistence on evolutionary design is Popperian at heart. Design is not frozen because frozen ideas cannot be falsified cheaply. We do not refactor because change is fashionable. We refactor because learning demands comprehension and adaptability.
A system that cannot change cannot learn. A team that cannot falsify cannot move forward confidently.
A Modern Method: Automation as Epistemology
In contemporary science, no individual fully understands the whole system. Knowledge emerges from tooling, collaboration, automation, and replication.
This is precisely where software engineering now sits.
Continuous integration is a standing experiment.
Continuous delivery is hypothesis testing at scale.
Observability is system empiricism.
Chaos engineering is adversarial experimentation.
The list goes on. Modern software engineering insists that these are not optional practices, they are epistemic necessities. Without them, software development regresses into craft folklore, authority-driven decisions, and confidence untethered from reality.
“these are not optional practices, they are epistemic necessities”
The Anchor Itself
Software engineering is not the act of writing software.
It is the act of learning what works, quickly and reliably, through evidence. Feedback loops and enabling flow of high quality change are everything to the modern, empirical software engineer.
This is why there is such a hard line between programming and engineering. Programming can succeed through brilliance and luck. Engineering survives only through method.
The scientific method took centuries to evolve because reality is subtle, humans are biased, and feedback is expensive. Software engineering compresses that history into pipelines, tests, and telemetry, but the purpose is unchanged.
To replace the method with intuition, heroics, or speed theatre is not innovation. It is amnesia.
The Warning and the Necessity
Every failing software organisation reenacts an early mistake from the history of science:
Trusting authority over evidence.
Preferring narrative over measurement.
Optimising confidence instead of feedback.
Recalibrating and reminding ourselves of the empirical nature of software engineering matters because it reminds us that software engineering is not new. It is old wisdom, painfully learned, expressed in a modern medium.
It allows us to optimise flow of valuable, high quality outcomes into the world. Our method, the scientific method, is everything.
Some Further Reading
On Foundations of the Scientific Method
These works explain why the method exists at all:
Novum Organum – Francis Bacon
A manifesto for evidence over authority. Bacon’s insistence on structured experimentation reads today like an early argument for test-first thinking.
The Logic of Scientific Discovery – Karl Popper
Falsifiability as the moral centre of science. Essential for understanding why “trying to break your own ideas” is not pessimism but professionalism.
Against Method – Paul Feyerabend
A necessary counterweight. Feyerabend reminds us that method must serve discovery, not replace it with ritual. Useful medicine against cargo-cult engineering.
On Feedback, Learning, and Systems Thinking
Where science becomes operational:
The Fifth Discipline – Peter Senge
Learning organisations, feedback loops, and systems awareness. Reads like a missing bridge between scientific thinking and modern engineering teams.
How Complex Systems Fail – Richard I. Cook
A short but devastating essay on why confidence and complexity are a dangerous mix. Crucial context for evidence-driven engineering in production systems.
Thinking in Systems – Donella Meadows
A gentle but precise guide to understanding cause, effect, and delayed feedback. Indispensable for interpreting metrics without self-deception.
On Software Engineering as Applied Science
These make the empirical basis for Software Engineering explicit:
Modern Software Engineering – Dave Farley
The clearest articulation of software engineering as hypothesis testing, fast feedback, and evolutionary design.
Accelerate – Nicole Forsgren, Jez Humble, Gene Kim
Evidence that the method works at scale. Empirical research connecting engineering practices to measurable organisational outcomes.
On Bias, Judgment, and Human Limits
Because the method exists to protect us from ourselves:
Thinking, Fast and Slow – Daniel Kahneman
A field guide to the cognitive traps that make intuition unreliable. Essential context for why evidence must outrank confidence.
The Signal and the Noise – Nate Silver
On separating insight from coincidence in noisy systems. Particularly relevant for interpreting metrics and A/B experiments.
On Practice at the Sharp End
Where hypotheses meet reality:
Release It! – Michael T. Nygard
Production as a laboratory. A reminder that real systems are the final experiment, whether you instrument them or not.
Chaos Engineering – Casey Rosenthal et al.
Falsification in production, done deliberately. A direct descendant of Popper’s thinking, deployed at runtime.