Pinderkent

As the title of Will McGugan's On Ego and Software Development article clearly states, it discusses the impact that developer ego has on software projects. One of the impacts he mentions is that of rewrites of inherited codebases. His suggestion is that the developers who inherit the code often think that the existing code is poorly written, and believe that they could do it far better. I'm not sure that this is typically the justification for a rewrite, especially in business settings.

Over the years I have been involved with many projects involving a transfer of a significant amount of code. As with much software, this code may not be poorly written, but typically isn't as clean as it could be. Depending on the setting, the code may have been written very quickly, it may be unnecessarily complex, it may have been added to haphazardly over the years, and it may have been developed by programmers who weren't overly talented. Even if there's no urge to rewrite the software initially, such ideas can arise once the new developers scope out how much work it will take to come up to speed with the existing code.

The amount of time and effort that it takes to become familiar with an existing codebase depends on a wide variety of factors. The languages, libraries, frameworks and other technologies used are likely the most significant factors, especially when considering the new developers' familiarity with them. There may be issues surrounding the deployment environment. The new developers may not be overly familiar with the business domain the software serves. The quality of the original code is a factor, as well. And those are just a few of the issues that need to be considered.

Sometimes the effort necessary to become adequately familiar with the existing code far exceeds the time it would take the developers to rewrite and test the code in question. This is where we often see rewrites taking place. It's not so much about the new developers caving to their egos and thinking they can do it better. It's actually more about the developers recognizing their own weakness in the situation, namely the scale of the difficulties they would face were they to work with the existing code rather than rewriting it anew. The decision to rewrite ends up being almost purely economically-driven, rather than ego-driven.