Tip of the Iceberg

Category musings
Nathan has an excellent article today about code decay as a result of evolving context: no matter how sound the original design, over time the needs of the business, the capabilities of the underlying platform, and numerous other factors gradually increase the gap between what software is and what it could be. Most businesses don't want to hear this, but it doesn't make it any less true.

Another type of decay (which I think I may have pontificated about in one of our podcasts) is the "if I knew then what I know now" decay: a better approach or technique was already available at the time but I wasn't aware of it. Some might take this as criticism of the programmer's skills, but I regard it as realism about the natural evolution of skill. None of us ever knows absolutely everything about any platform (no matter what our certification might lead a headhunter or client to believe), and the more refined our knowledge and experience becomes, the more decayed our code becomes over time. Absent any other contextual changes, the software still meets the business need with the same degree of accuracy / reliability / ease of use it has since its most recent release, but the cold, hard fact is that there is nonetheless a gap now between what that software is and what it could be.

For example, when 8 first came out last year, if you were staying abreast of changes to the platform, you likely downloaded one or more of the betas, tested it out in your own environment, and experimented with some of the new development capabilities. If you're one of the lucky ones whose employer has since upgraded to 8, you're no doubt using some of those new capabilities to better serve your user base. But have you mastered those changes yet? I haven't. I know how to leverage some of them effectively, but to claim that I've plumbed the depths of everything we can do now that we couldn't before so deeply that I can't possibly continue to improve would be hubris on a staggering scale, not to mention disturbingly complacent. That's not to say that I shouldn't be vigilant about rapidly coming up to speed on new capabilities as they emerge, merely that I should never assume I've found everything there is to find. Nathan pinged me on Sametime a few weeks ago about some language feature (I think it was a method of one of the Domino Java classes) that neither of us had previously noticed. Because it was new in 8 and we hadn't fully explored that area yet? Nope... been around since version 5. Does that oversight imply that either of us is losing our touch? Possibly. But if I wanted to learn to speak German, and learned the German word for a concept I never encounter in conversation, I'd rapidly forget that word... years later I might find myself wanting to express that very concept, use a rough approximation based on what I now know of the language, only to find out that there's a better word for what I'm trying to say, and was told originally what that word was, but forgot it existed because I had never needed to use it before. No matter our expertise, there's always some aspect of the platform we can explore in greater depth to improve the way we develop within the platform.

For the same reasons Nathan mentioned, this phenomenon also requires that software be periodically maintained in order to minimize its decay. Thankfully, Domino provides us an excellent (and severely under-utilized) vehicle for this in the form of element-specific template inheritance. The more your code tends to live in subforms and script libraries that inherit from a central template, the less decay your users will experience over time. Regardless of whether the opportunity to implement comparatively superior code is a result of an upgrade to Domino or simply that you've since learned a better technique that would already have been possible to begin with, you can implement that improvement in a single location and know that software you haven't otherwise modified, perhaps in years, is now providing your users a better experience. If you're not taking advantage of this capability, you'll likely find your applications decaying almost as fast as leftover pizza.