25 July 2023 by Phillip Johnston
You must keep in mind that all software ages. Another factor to consider is that when change is slow, software will appear aged (or will actually be aged). Dr. Parnas describes this as “Lack of Movement.”
The modern business environment seems to operate on an expectation of continuous change. Responding to changes in the environment quickly shows that a project is healthy and being actively maintained and cared for. In contrast, a product that is slow to change appears to be unsupported and neglected.
The impact can be one of pure perception – for example, software written in the 1960s or 1980s certainly appears aged due to “lack of movement,” even if it would still work perfectly well today. More often, however, lack of movement is a true symptom of aged software. It reflects a failure to keep up with changing environments and users’ needs.
References
- Software Aging Paper by David Parnas
Unless software is frequently updated, its users will become dissatisfied and they will change to a new product as soon as the benefits outweigh the costs of retraining and converting. They will refer to that software as old and outdated.
- Software Aging Slides by David Parnas
- Software Aging – Why it happens and how to reduce it talk by David Parnas
A product that was considered great a few years ago, may not be considered useful although it hasn’t changed. Some products appear (paradoxically) to improve without change. The users learn to avoid the problems.
6 December 2021 by Phillip JohnstonDocumentation can help you slow down software aging. Although we note that it must be good documentation! Unfortunately, even when software is well-designed, it is poorly documented. You can reverse this course with retroactive documentation: investing in and upgrading the quality of the documentation post hoc. This will help you slow aging and possibly even rejuvenate the project. Correcting documentation is a major project, but it is worth the effort. Other benefits of upgrading documentation: Redoing the documentation often leads to improvements in the software. Errors are exposed, and then they can be fixed. Writing …
Continue reading “Good Documentation Can Slow Down Software Aging”
6 December 2021 by Phillip Johnston • Last updated 27 October 2023Shortcuts are always tempting, but it is rarely the right decision to take the shortcut in product development. Certainly, a shortcut may reduce the time required to get a piece of desirable behavior into the system, to make it to the first release, or to resume operations. But you must keep in mind that shortcuts are likely to fail quickly and/or hasten aging. Pile one shortcut on top of another, and suddenly you’re facing a house of cards that requires significant work to fix. There’s no real cure for …
Continue reading “Shortcuts Trade Short-Term Gain for Long-Term Difficulty”
6 December 2021 by Phillip JohnstonCancerous growth in a code base is one of the causes of software aging. This typically happens when a company comes to maintain many versions of a product that are almost alike. These versions may be tweaked for a specific customer, may provide different features, etc. The problem is that almost-alike products lead to confusion and a maintenance explosion. Changes must be made to many versions instead of one, and it’s easy for a version to get missed. People try to take ideas from one version and use them in another, but it might not …
Continue reading “Cancerous Growth Leads to Software Aging”
6 December 2021 by Phillip JohnstonAll software will age, and inevitably it will reach a point when it will be retired. It’s better to plan to replace your product up front, which ensures you can have the smoothest migration possible. One consideration is that people want to get their data out of the old system. This might be internal, such that you can migrate or interoperate with a newer system, or it might be external, enabling users to migrate their data elsewhere. You can prepare for these eventualities by designing ways to export data: Prepare an interface for passing data …
Continue reading “Always Create an API to Export Data”
6 December 2021 by Phillip JohnstonAll software will age, and your next system is no exception. You can’t start your project by expecting it will last forever. You need to make sure up front that you’re planning for the inevitable need to change it and eventually replace it. This means: Put limited time warranties in place Declare an intended product lifetime or support lifetime up front DOCUMENT, including a detailed list of decisions that you regret in this product and rationale for the decisions that you made in the current project Set aside money for the eventual transition and retirement …
Continue reading “Plan to Replace Your Product”
6 December 2021 by Phillip JohnstonYou can easily slip into the habit of creating variations of a program to support different customers or configurations. However, this rapidly increases the complexity in your company and increases the rate of software aging. It’s better to ship the same code to everyone if it is at all possible, because you can do a significantly better job maintaining one program instead of 10, even if they are quite similar. You can make consistent changes to your entire product line quickly, because you only have to do it in a single place. You can also …
Continue reading “Ship the Same Code to Everyone”
6 December 2021 by Phillip JohnstonOne of the causes of software aging is overly complex software, often caused by complex product lines that comprise different product variations. If this is the case, perform “major surgery” by restructuring your product lines to replace many versions with one version. Ultimately, the goal is to ship the same code to everyone, although you might have to settle for a reduced number of programs rather than just one. The process: Examine the variants and determine why they differ Choose between parameterization and hiding Hide differences when possible (when using program doesn’t need to know). …
Continue reading “Restructure Product Lines to Reduce the Support Burden”
6 December 2021 by Phillip JohnstonA symptom of software aging is decreasing reliability. This often happens because the improvements make things worse. Each error that is corrected may introduce more than one additional error. Some products that we use on a daily basis have thousands of known bugs (many of which are never fixed), yet that number is not decreasing. Often, the choice is to either abandon the product or stop fixing the bugs. As Dr. Parnas says, “At a certain point, the wise company throws it away because they can’t fix it.” References Software Aging Slides by David Parnas …
Continue reading “Decreasing Reliability is a Symptom of Software Aging”
6 December 2021 by Phillip Johnston • Last updated 3 October 2024
You have to accept the inevitability of software aging and not promise anyone product immortality. You have to start by looking far beyond the first release to the time when the system has aged. You must take careful action to ensure we minimize aging and give your company the longest useful life possible. Fundamentally, however, you can only slow down aging. Your product will eventually be retired, and you need to plan for that day.
You can slow down this aging effect with the following actions:
Are you tired of every hardware or requirements change turning into a large rewrite? Our course teaches you how to design your software to support change. This course explores design principles, strategies, design patterns, and real-world software projects that use the techniques.
Learn More on the Course Page
References
