We’ve all done it, sat around a table dissing the previous generation of our product. The previous set of engineers had no idea, made some stupid fundamental mistakes that we obviously wouldn’t have made. They suck, we’re awesome. You know what, in 3 or 5 years time, the next generation of stewards of the system you are creating or replacing now will be saying the same thing – of you are your awesome system that you are slaving over now.
So what changes? Is the previous generation always wrong? Are they always buffoons who had no idea about how to write software. Unlikely. They were just like you at a different time, with a different set of contexts and a different set of immediate requirements and priorities.
The context that a system is created is the first critical ingredient for a system. Look to understand the priorities, the tradeoffs and the decisions that had to be made when the system was first created. Were there constraints that you no longer have in place, were they restricted by infrastructure, memory, performance? Were there other criteria that were driving success at that stage, was it ship the product, manage technical debt or were there gaps in the organization that were being made up for? What was the preferred type of system back then?
Understanding these items allow you to empathize with system creator and understand some of the shortcuts they may have made. Most engineers will attempt to do their best based on their understanding of the requirements, their competing priorities and their understanding of the best systems that can be implemented in the time given. Almost every one of these constraints forces some level of shortcut to be taken in the delivering of a system.
Seek first to understand the context before making the decision that the previous team made mistakes. When you hear yourself making comments about a previous team, a peer team or other group not doing things in the way that you would like to see it, look for the possible reasons. I’ve seen junior teams making rookie mistakes, teams focused on backend architectures making front-end mistakes, device teams making simple mistakes in back-end systems. In each of these contexts, it is fairly obvious why the mistakes would be made. Usually, it will be within your power to identify the shortcoming, determine a possible root cause by understanding the context and shore up the effort or the team to help smooth things over and result in a better outcome.
Constraining Your ng-Whatever
When faced with frustration on a previous system, consider carefully a full re-write into a ng-whatever system, or incremental changes with some fundamental breakpoints that evolve, refactor and replace parts of the system.
It is almost guaranteed that the moment a system gets a “ng-Whatever” moniker attached to it, it becomes a panacea for all things wrong with the old system and begins to accrete not only the glorious fixes for the old system, it will also pick up a persona of its own. This persona will appear as “When we get the ng-whatever done, we won’t have this problem..”.
These oversized expectations begin to add more and more implicit requirements to the system. Very few of these will be expectations will be actually fulfilled, leaving a perception of a less valuable ng-Whatever.
Common Defect Density
I’m going to come out and say that most engineering teams, no matter how much of a “Illusory Superiority” bias they may have are going to be at best incrementally better than the previous team. With that said, their likelihood to have defects in their requirements, design or implementation will be more or less even (depending on how the software is being written this time around).
The impact will typically be that the business will be trading a piece of potentially battle hardened software with known intractable deficiences, with a new piece of software that will both have bugs that will be only be ironed out in the face of production. Even worse, there will always be a set of intractable deficiencies that are now unknown – only to be discovered when the new software is in production.
When the original system was created, it is highly unlikely that the engineering team baked in a set of annoying deficiencies. Likewise, the new system will, to the best of your teams understanding, not baking any deficiencies into the system. You need to make a conscious decision to take the risk that the new issues will be less painful than the old issues are. If you can’t make that call, then sometimes refactoring and re-working parts of the system might be a better solution.
What have your experiences been with ng-Whatevers? Have you found that your team can reliably replace an older system with a new system, and see that in a few years time the new system is held with a higher level of esteem than the original system? Follow this blog for more posts, or post comments below on this topic.