When I was in grade school I started a small car washing business with little more than some soap, sponges, and a bucket borrowed from my father. While I was starting this business as a means to buy some new toys (it began with an R/C car, escalated to planes, and eventually guitars) my father saw entrepreneurship as a means to teach two things: work ethic, and the value of a dollar. What sticks in my mind still to this day however, was his constant insistence on quality. He knew that our neighbors could either hire me, or simply drive a mile down the road to the industrial car wash, and if I didn’t have a differentiator, I wouldn’t have any business. Quality would be that differentiator.
Had I let my quality drop, my customers could simply go down the road and get better service for a similar price. In today’s software development market, we’re confronted with similar competition, but loss of customer satisfaction/business is not the only cost associated with poorly written code.
When an organization allows poor developmental habits increase their architectural complexity, and technical debt we see numerous problems cascade across the organization. For starters, architectural complexity has a direct negative effect on the productivity of the engineers working in that code base. If (hypothetically) you were to move a set of engineers from the least complex region of the codebase to the most complex region of the codebase, their productivity would decline (conservatively) by 50%.(Sturdevant)
This decline in productivity is tantamount to doubling the cost of the engineers working on this region of code! This is of course before you look at the increased levels of defects resulting from dealing with increased code complexity. Again looking at Dan Sturdevant’s MIT Dissertation, we’ll see that high scores of cyclomatic complexity result in a 2.1x increase in the defects found within the code base. (Sturdevant) Recalling that defects increase exponentially in cost depending on the environment (what is $100 to fix in development will be $10,000 or more to fix by the time it makes it to production) the costs can really begin to add up.
As if this wasn’t enough reason to seriously consider the real costs of technical debt, it actually continues to escalate. Software Engineers working in the most complex regions of code can be expected to have a turnover rate of ten times greater than engineers working on less complex code. (Sturdevant) Employee turnover costs differ per organization, but recruiting costs, relocation fees, vacation pay-outs etc. While those costs are easier to quantify at a given organization, what’s often not being considered is the decrease in productivity between new hires and experiences engineers. You have to weigh in potential training costs, as well as an uptick in bugs, and decrease in overall productivity when comparing an engineer with more experience in the organization to new hires.
While often we think of technical debt as the cost associated with refactoring code, that doesn’t take into consideration the full cost of code complexity. We can see time and time again the negative effects of allowing your software development to become a feature factory, in fact we’ve even written about it here. Much like my carwash business, it’s easy to see the impact of poor quality on your top-line revenue, but you’d be remiss if you didn’t consider the hidden costs poor quality has within your organization.
We’ll be talking more about software quality and agile software development in our upcoming webinar Beginning your Agile Transformation: A Rountable Discussion on Common Pitfalls and Challenges.
Note, this article references the following: Sturdevant, Daniel J. “System Design and the Cost of Architectural Complexity” PhD Diss., Massachusetts Institute of Technology 2013. Retrieved from https://dspace.mit.edu/handle/1721.1/79551