The accounting department classifies software development work as a capital expense. That means, at least according to accounting, new software represents new capital investment that should increase productivity. This highlights a big divergence in the way accounting views software versus the way we should look at it.
We used to have a saying, “KLOCs kill.” The more lines of code, the more risk you have. As your system gets bigger it gets more complicated and difficult to work with. Code has a carry cost... you have to keep maintaining it. It has obsolescence risk. Undeployed code is exactly like unfinished automobiles: nobody pays you for it. Maintaining it is a liability not an asset. Excess code is a boat anchor that will weigh you down until you drown.
Code is Inventory and Inertia
Let’s say you have a 10-million-line Java program that took you 10 years to write. First, I’m willing to bet you didn’t write one million lines each year. You probably wrote two million lines in the first year and only 50,000 by the last year—as programs get bigger velocity slows down. With 10 years of investment, it’s pretty tempting to view this program as an extremely valuable asset. But let's look at the financial dynamics. When it is time to update the architecture, you’ll need to set up a multiyear initiative. I have experienced this with a company that took five years to rehabilitate their Java system. I know of another company whose implementation was planned to take five years but they decided to sell the company instead of slogging through it.
With 10 million lines of code, the issue is not just about maintaining the software, but about making it adapt to the way the world changes over the course of a decade. For example, if your website was first built 10 years ago, there were no smartphones. Today, people can’t live without them. Now, your website needs a native mobile app, and social connections like Facebook and Pinterest that didn’t exist when the site was first written.
How much of an asset is that 10 million lines now? Instead, think of those lines of code as inventory and inertia: resistant to any change in speed or direction. What if you had a much smaller component, say 1,000 lines of Clojure code (which is actually a lot). If that tiny piece ever starts to feel unmaintainable, you might just say, “Let’s throw it away and start over!” Those lines of code become a small asset—inventory that can be easily replaced. Disposable.
Now, I like Clojure a lot, but nobody is claiming that 1,000 lines of Clojure provide all the features that 10,000,000 lines of Java will. Instead, we want to divide the features into 100 or so small components. Justin Gehtland wrote about this as early as 2008, in "Small Things, Loosely Joined, Written Fast". Today, I would add, "Discarded Readily."
The Unicorn and the Brontosaurus
Thanks to Aileen Lee, tech venture capitalist and the founder of Cowboy Ventures, the investment industry has adopted the term unicorn to refer to a start-up that is valued at one billion dollars before going public. The mythical unicorn is a magical creature, swift, nimble and highly prized. Lee chose this depiction because she thought it captured the essence of many of these companies, stating, “A lot of the entrepreneurs and founders have big dreams and are on a mission to build things that the world has never seen before.”
So we have the Unicorn Club on one end of the spectrum. What’s at the other end? Let’s call it the Brontosaurus Club. Weighing in at 30+ tons and measuring up to 90 feet long, these Jurassic-era creatures lumbered themselves into extinction. Today’s Brontosaurus Club members are the companies weighed down by the 10 million lines of code. They drag their anchors around everywhere.
There are a couple of ways companies find themselves members of the Brontosaurus Club. One way is by outsourcing all software development. GE is one of those companies, which was at the forefront of this trend. GE outsourced everything that wasn’t core. Here’s the problem. Your outsourcing vendor only gets paid when they build something for you, so of course they will continue to build—whether you need it or not. All these lines of code are the boat anchors that your IT consultants have gold plated so they look valuable. Instead of calculating the boat anchor as a capital asset worth $150 million, it is really $150 million worth of technical debt that is holding you down. A number of large companies, like GE, are pulling those outsourcing contracts and bringing activity back in house, reversing their strategy in order to survive.
Another way to take on all this excess inventory is by using languages and tools that encourage monolithic architectures. The Java application server market, platforms like Oracle’s Web Logic, IBM's WebSphere and Red Hat's JBoss are all examples that encourage these architectures.
Beyond the Brontosaurus
While heavy anchors weigh down members of the Brontosaurus Club, the unicorns are zipping around, going new and interesting places. The brontos can't pretend to be unicorns by adapting their practices any more than they can duct-tape a horn to their foreheads. What they can do is understand the principles that the unicorns exploit, then adapt them to the context of a large, existing company.
What we want is to be able to move out of the dinosaur age and move towards adaptive systems, where small inventory and disposable code allow us to change direction swiftly. When you have good tools that let you get a lot done in a short period of time, you don’t have to treat your code like a precious jewel or invaluable asset—you can treat it like the risky inventory it actually is.
Read all of Michael Nygard's The New Normal series here.