Recently I’ve spent a lot of time investigating a system that’s been around for about ten years. Like many systems the developers are long gone and the system, ticking over reliably, has been ignored. Well its time to replace the system and also like many other similar systems no one actually knows what the thing does! As usual the documentation shows little sign of maintenance and inspires even less confidence. There’s only one thing for it, you have to go and read the code.
This proved to be more difficult than you can imagine. Besides there being no comments in the code, remember that old habit? At every turn every possible function had been abstracted sometimes three or four times. Component after component turned out to be little more than a container for the next level of function.
Don’t get me wrong I’m as keen on the separation of concerns as the next architect. But, in this case the result was a ridiculous ratio of functional code to packaging that simply made comprehension more difficult. Well I got to thinking about how this came about. The developers had plainly written the code for maximum reuse and extensibility, the problem was that ten years later none of it had been used and the resulting complexity and a lack of documentation made the system almost incomprehensible.
So the question must be asked when is it quality and when is it over engineering?