“How many piano tuners are there in Chicago?”
That’s where my mind went when Ike had the bright idea of tasking me with the formulation of an algorithm to calculate the total technical debt in existence: Piano tuners in Chicago.
Technical debt is essentially the product of poor development practices. It can come from almost anything and some level of technical debt is unavoidable. Maybe you rush to get something that works today, but are on the hook for making it continue to work in the future. Maybe you hit a pivot point and need to go back and rework old code to allow for previously unforeseen purposes. Technical debt happens.
Like financial debt, when you keep it in check, it isn’t the worst thing in the world. If fear of financial debt kept everyone from taking out a loan, then a ton of awesome things would never have came to fruition. But also like financial debt, playing fast and loose with technical debt and getting over your head is a recipe for disaster.
And so technical debt is something all businesses need to keep track of. No one wants to be MySpace circa 2006 and realize that they’re under a mountain of technical debt and completely unable to keep up with the demand it takes to maintain their site.
Oh, and technical debt -- while a useful concept -- isn’t exactly a clear cut dollar and cents number. But that’s exactly what I was asked for, and that dollar figure for the entire world. (Thanks again, Ike!)
“I can do it, it’s just not going to be right.”
It’s not exactly a phrase I want to have to utter at work very often, but it’s what got me thinking about Piano tuners in Chicago.
The piano tuners question was one Nobel Prize winning physicist Enrico Fermi would pose to the audience of his lectures. And like the technical debt question, there wasn’t really an answer for it. But the idea was to use a logical process of assumptions to get somewhere close.
Fermi started by taking the total population of Chicago at the time: 3 million people. From that he ventured that with an average of 4 people to a household, there were about 750,000 households in Chicago.
From there he estimated 1 in 5 households owned a piano, which meant there were 150,000 pianos in Chicago.
Working from the other end, Fermi figured the average piano tuner would tune 4 pianos a day, 5 days a week, 50 weeks a year. For a total of 1,000 pianos a year.
Assuming each piano is tuned about once a year, the workload for piano tuners in Chicago would support about 150 piano tuners.
It’s not the right answer, but it’s somewhere in the right area code.
The world’s technical debt
Unlike the amount of piano tuners, the global technical debt is growing all of the time. But to start with, I put that aside. I just wanted to figure out how much technical debt existed right then and there, at that very moment.
Many Google searches later, I stumbled upon a thread to pull at. This magical number: $3.61. After studying over 365 million lines of code from 160 companies, that is the average amount of technical debt CAST Software determined for every line of code.
And that was my jumping off point.
From there I just needed to determine the total lines of code that existed in all of the world. Which is about as ridiculous a question to ask as “who put the bomp in the bomp bah bomp bah bomp?” But based on some random message board discussions I turned up, a few articles from 2000 on the Y2K bug that posited there was a trillion lines of code at the time, some guesses at exponential growth, and just my intuition, I made a rough (really rough) estimate: 2.886 trillion lines.
Multiply that by our $3.61 cost per line and we reach a total technical debt figure of $10.426 trillion - or about a trillion more than China's GDP.
Now I was getting somewhere. I think.
But we needed the clock to be a real time reflection, constantly counting up. That’s the whole point, right? It needs to ominously march on - day and night, when you’re sleeping, when you’re eating, when you’re watching The West Wing on Netflix. Up and up the technical debt climbs.
Five days a week. Fifty weeks a year.
And then I went back into the fray, drudging through forums and Q&A site arguments to try an put an estimate on the amount of lines of code the average software engineer writes in a day. Obviously this depends on a multitude of factors like the language he or she is writing in, the complexity of the project, general work ethic, and the nearest burrito truck. Eventually I settled on 300 lines of code a day.
Multiply that by 5 days a week (stop laughing, guys) and 50 weeks a year, and you get 1.25 trillion lines of code, which means $4.5 trillion in technical debt this year. Which per second works out to be $23,277,368.90 or about what This is the End made at the box-office in its opening weekend.
Somewhere Mr. Rambo, my high school math teacher, is either really proud, or really disappointed. I’m not even sure anymore.
Layer0 to the rescue
But that’s still not it. After realizing he actually got me to go along with this ruse, Ike decided we also needed to know how much technical debt Layer0 had saved the world from.
It seemed like the best way to figure this out would be to see how many extra lines of code our customers did not have to bring into this world since they used Layer0 to leverage their existing desktop site to build a mobile experience. That kind of makes sense, right?
Controlling for the degrees Celsius in Sweden, and tossing a dart at a dartboard, I came up with a decent estimate of lines of code saved. Looking at the number of projects on the platform, eyeballing our rate of work, and then multiplying by that magical $3.61 figure, I reached the total amount of technical debt saved by Layer0: $480,357,048.12.
But really though
Okay, so my methodology isn’t exactly scientific, and I don’t have high hopes of getting this published in the Economist, but I think (read: hope) there’s a larger point here. And that is that even though it’s impossible to calculate, and even if the numbers might be fuzzy, there is a significant amount of technical debt in the world.
And the faster technology innovation occurs, the more devices and new and different outputs and applications for those lines of code that we write, the more technical debt piles up.
It’s happening right now, and we all can see it growing. And that’s why Layer0 is so keen on re-using and leveraging existing web assets. If we’re all going to keep pace, if we’re going to avoid getting over our head in technical debt, then we need to get the most out of code. And that means using our code in ways that we might not have thought about when it was being written.
That will save us from all that technical debt, whatever the actual number is.