What follows from Gall's Law?
Here's Gall's Law:
A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.
Gall's Law has a funny epistemic position in software. If you cite it, people will nod knowingly, and nobody will say it's wrong. Yet almost nobody behaves as if it's true.
I do, in fact, suspect that Gall's Law is at least approximately and often true. How should that change my behavior? Some conjectures:
- My high-level design documents should be very concerned with the rough structure of a solution, and less concerned with the details of it.
- When implementing, I should try to get to a working solution as quickly as possible, even if it's a working solution to a slightly different problem.
- I should try to write "tracer bullet" tests (here is a good introduction), in part because they're a sort of functioning system.
- I should design systems that it is possible to grow from simpler systems. (I'm not sure all systems are like this!)
- I should obsess over encapsulation, because it enables both the development of simple systems and the growth of healthy complexity.
Some of these (especially (2)) are widely believed, or at least widely affirmed. And, whether Gall's Law is true or not, I often think that encapsulation is the most underrated (though highly rated!) idea in software. What am I missing on this list?
By the way, this isn't a claim that Gall's Law is true. It's tempting to put too much credence in a claim like this: plausible, non-obvious, never well refuted (to my knowledge), fun to think about, and with lots of implications. I should examine the truth of the claim more carefully, but I'll keep that for another post.