All Code Is Disposable, Just As It Should Be

Sponsored by #native_company#
#native_desc# #native_cta#

My recent post I Am a 9 to 5 Developer (And So Can You!) is getting WAY more traffic than I expected, and I am both humbled and excited that so many people in our profession seem to feel the same way that I do: namely, that you CAN leave work at work and still be a good developer. So, for everyone that read that post and stuck around to read this one, thank you so much for-a reading my blog!

(Imagining that last part in Mario's voice makes it better. Why yes, I am playing Super Mario Odyssey, how did you know?)

As the Internet in its best form is prone to doing, sometimes someone will mosey along and bring up an obvious point that never occurred to me. That previous post was submitted to Reddit's /r/webdev community, and despite the common wisdom to not read comments about your own work I found myself perusing these conversations. This point that stuck with me has to do with the nature of software itself, and why it's never a good idea to spend all your time writing it. Here's the comment:

That last line in particular stuck in my craw. "Ultimately disposable" is EXACTLY what software is, much as we might wish it weren't. There is a terrible truth that many developers haven't quite accepted yet: software is disposable.

Time and the Tracker

A long time ago I wrote a post called The Solo Programmer and the Insidious Promise of the Ivory Tower which told the story of my first job out of college. During that time I was a lonely web developer on a team of non-programmers, and I built an ASP.NET WebForms web site that was used to help plan and estimate effort required for this team's projects. We called it the Tracker. The Tracker is still the longest-living project I have ever worked on and AFAIK it remains in use at that company to this day.

But the Tracker is the not the norm. Other than the projects I am currently working on, all of my software projects have either been replaced, made obsolete, or set on fire with a blowtorch made unmaintainable by time and change.

The truth, the ugly truth, is that nothing we ever write will be permanent.

To be sure, the good, quality code that us developers write will feel like it is permanent. It will feel like "I solved this problem with this code and therefore this problem will forever remain solved" until inevitably the next variable is introduced and the whole house of cards comes tumbling down. No solution stands the test of time, for time is constantly introducing new problems. Even the Tracker will eventually succumb to the unending flow of the river of time. Time always wins.

We developers spend a lot of time writing code (duh). Like most people who enjoy their job, we take pride in doing ours correctly, efficiently (also duh). Part of that pride in our profession is ensuring that our code and programs are the best they can be, given all the other constraints (e.g. time, money, availability, etc.). We want to make our work be worthwhile. If something is worthwhile, then it should last a while, right? That's how tangible real-world products work; the longer they last in their intended function, the more worthwhile they are.

But they never last forever.

Destined to be Discarded

Despite what we may want, software is like any other tangible good. It is incepted, designed, tested, sold, used, and eventually thrown away. It is disposable, constructed with a limited shelf life whether or not that was done intentionally. It will not last forever, and it is hubris to expect that it should do so.

That's scary! This idea that what we do is impermanent, disposable, is downright terrifying to some people, including me. The thing that I do, that I love to do, that I designed so carefully and tested so thoroughly, it isn't going to be around in 10 or 5 or even 2 years? Why the hell not? Did I do it wrong? Did I not solve the problem?

No, we didn't do it wrong. Yes we solved that problem. The problem merely changed.

Code doesn't change. Once it is written, it stays written in the exact same manner unless we change it. But the problems do change, time keeps changing them, and so we must keep coming up with new software to solve new problems. If our software was permanent, then truly static code would be just fine; there'd be no new problems to solve, nothing that we need to learn to solve them. Which begs the question: do we want to live in a world where there's nothing to learn? I sure don't.

Precious few things I have ever worked on still exist today. The Tracker is one of the few, and it too will eventually fade away like all my other code. All my software, my "life's work", is destined to be thrown away like the trash it will become. This is not scary; this is merely a fact of programming life. Everything we write is destined to be discarded. What we need to do is be mindful of that fact, because then we can plan for it, work toward it, bring it about. The end of our software should be planned for, expected, even desired, at the least so it doesn't catch us by surprise.

A pile of trash, overflowing from a big trash container

Just Another Good

Three years ago I published a pretentiously-titled post called The Ultimate Fate of All Software. In it I wrote the following:

"Sure, the code I write will eventually become old, creaky, just plain bad, and will be replaced. And that's OK, because ultimately it's just code. Nothing more."

Now I am willing to go one step further: software is just another good. Much like a tangible product, our software will be used, and then used up. And that's exactly the way it should be.

Your software will end. Make sure to plan for it.

Happy Coding!

Matthew Jones

Matthew Jones

I'm a parent, a husband, a geek, a web developer, and a speaker, in roughly that order.

Read More
All Code Is Disposable, Just As It Should Be
Share this