If you think building a system is challenging, try maintaining one.
Tom Cagley‘s recent post “Plan to Throw One Away Re-Read Saturday: The Mythical Man-Month, Part 11”, was a good reminder that while “technical debt” may be something currently on the radar for many, it’s far from a new phenomenon. The concept of instant legacy applications was in place when forty years ago when Frederick Brooks wrote his masterpiece, even if they weren’t called that. As Tom observed in the post:
Rarely is the first attempt useful to the end consumer, and the usefulness of that first attempt is less in the code than in the feedback it generates. Software development is no different. The initial conceptual design and anticipated technical architecture of a large project rarely stands up to the rigors of the discovery process, and those designs should be learned from and then thrown away.
The faulty assumptions and design flaws accumulate not only from sprint to sprint leading up to the initial release, but also from release to release. In spite of the fact that a product can be so seriously flawed, throwing it away and starting over is easier said than done. While sunk costs cannot be recovered, too sanguine an attitude towards them may not enhance your credibility with the customer. Having to pay for the same thing over and over can make them grumpy.
This sets up a dilemma, one that frequently leads to living with technical debt and attempting to incrementally patch it up. There are limits, however, to the number of band-aids that can be applied. This might make it tempting to propose a rewrite, but as Erik Dietrich stated in “The Myth of the Software Rewrite”:
Sure, they know things now that they didn’t know when they started on this code 3 years ago. But won’t the same thing be true in 3 years? Won’t the developers then be looking at the code and saying, “this is a mess — if only we knew in 2015 what we now know in 2018!” And, beyond that, what makes you think that giving the same group of people the same marching orders won’t result in the same kind of code?
The “big rewrite from scratch because this is a mess” is a losing strategy.
Fortunately, there is an alternative. Quoting Tom Cagley again from the same post as above:
If change is both inevitable and good (within limits), then both systems and organizations (a type of system) need to be engineered to support and facilitate change. Architecturally, techniques such as modularization, object-oriented design and other processes that foster simplification and incremental change create an environment in which change isn’t avoided, but rather encouraged.
While we may laugh at the image of changing a tire while the vehicle is in motion, it is an accurate metaphor. Customers expect flexibility and change on the go; waiting equals lost business. The keys to evolving in place are having an intentionally designed, modular architecture and an understanding of where the weaknesses lie. Both of these are concerns that reside squarely on the architect’s plate.
Modularity not only makes an application more easily maintainable via separation of concerns, but it also embraces change by making components replaceable. This is one of the qualities that has made microservices such a hot topic, although it would be a mistake to think that microservices are the only way (or best way in all cases) to achieve modularity.
Modularity brings benefits beyond the purely technical as well. Rewrites of a fraction of an application are more easily sold than big-bang efforts. Demonstrating forethought (while you can’t predict what the change will be, predicting the need for change is more of a sure thing) demonstrates concern for the customer’s welfare, which should make for a better relationship.
Being able to throw a system away a little at a time allows us to keep the car on the road while it changes and adapts to changing conditions.
Form Follows Function 
” Architecturally, techniques such as modularization, object-oriented design and other processes that foster simplification and incremental change create an environment in which change isn’t avoided, but rather encouraged.”
Hayim Makabee has written extensively on this very subject, calling it Adaptive Design up Front, on his Effective Software Design blog. It’s harder than it looks, but very satisfying when you hear a developer say “I’m really glad this framework is so modular. It saved a ton of time on this sprint”
LikeLike
Indeed…Hayim is someone whose blog I follow very closely.
As you say, it’s not easy. It takes discipline to distinguish between what’s necessary to enable flexibility and what’s just bells and whistles. Learning how to do so, though, pays off in the long run. Teasing apart something that has no cohesion is not fun.
LikeLike
I can’t agree more. Solid design practices are key to building stable solutions that can be scaled for larger audiences to included additional functionality.
LikeLiked by 1 person
“It takes discipline to distinguish between what’s necessary to enable flexibility and what’s just bells and whistles.”
I have said to many an architect and developer- the hardest part of software architecture is deciding what changes are foreseeable, and therefore must be accounted for, and which changes are imaginary, and therefore must be ignored. But it’s still better than taking a pass on trying, like Emergent Design advocates.
LikeLike
Yep – it takes a combination of experience and ruthless self-awareness (fooling yourself can be incredibly easy), but I’ve never heard of entropy “just going away on its own”.
LikeLike
Pingback: Let’s Talk Value (Who Needs Architects?) | Form Follows Function
Pingback: Building a Legacy | Form Follows Function