Maintaining software is like changing tires on a car running at 100 miles an hour. Anyone who has changed tires on a speeding car knows that it is neither easy nor fun nor cheap, yet there are well over 500,000 programmers spending their lives doing just this for commercial products each year in the U.S. alone (Brooks 1995). Why? There are several reasons:
- Make the program work in a new environment or with a new version of some other program. This is especially common when a program must be converted from an old machine, operating system, relational database management package, compiler, etc., to a “modern” one.
- Keep a program up to date with changes in external specifications and requirements. For example, suppose you have a system that monitors the status of people waiting in a long line at a supermarket check-out stand.
- Fix a program that has been found to contain certain kinds of errors (e.g., bugs) by adding code in certain carefully-defined places under close supervision. This is especially true when the program is large and complex enough that proving the absence of bugs is too expensive for this stage in the product’s life cycle.
- Fix a program that has been found to contain errors but which cannot be modified because the code is lost or unavailable for some other reason (e.g., it was written in assembler language on an obsolete machine). Here we must again resort to black-box testing and hope we don’t find too many problems this way before we release it.
- Fix an undocumented program by patching it to work around new requirements or problems until a suitable replacement can be built. Often this just means adding lots of “if-then” statements everywhere in the code to check for various things which might have changed since development began (e.g., “if keyboard flag set then assume shifted key”).
- Fix a program that has been found to contain certain kinds of errors (e.g., bugs) and modify it so that these same errors will not be repeated in future revisions of the product (this is also known as debugging).
- Course corrections are also known as maintenance work which means modifying a program to make it behave differently under certain new conditions or different environments (e.g., adding support for foreign character sets, etc.).
- Enhance a program by adding new capabilities to it which go beyond those defined in the original specifications (increasing functionality). Here we are talking about major changes in both scope and purpose, often requiring extensive rewrites or even complete recapitulations of what was originally intended for your program.
License (contract) maintenance is the practice of using legal agreements to control the use of the software over time. The most common type of license maintenance is for operating system software, although there are other types (e.g., utility programs). A typical arrangement would be that you can continue running your program on new machines or even with new versions of the host operating system until some expiration date (typically three years from the purchase date). You must pay a periodic fee for this privilege in addition to the initial fee you paid, which granted you unlimited use for one year.