Legacy software, sometimes referred to as legacy code, is a term used to refer to existing computing applications to distinguish them from newly-developed software. The term typically is synonymous with “out-of-date” but not necessarily indicative of poor functionality.
Legacy software can still serve valuable roles in meeting the needs of businesses through core operability. If an application is still meeting requirements with success—legacy or not—it doesn’t necessarily warrant a change. There are several reasons legacy software may be retained:
- The ability to interact with older data formats
- The cost of replacement is too high
- The system doesn’t allow for down-time
- A system’s underlying functionality isn’t well understood by current developers
- Newer systems may couple unwanted behaviors
This short list is by no means conclusive in describing the possible justifications for retaining legacy code. While the above reasons may help justify retaining legacy software, there are also well-supported reasons for abandoning and/or replacing such code:
- Required to run on outdated and/or currently unsupported software
- Difficulty in maintenance
- Security concerns and vulnerabilities to modern threats
- Inability to integrate with newer computing systems
- Current developers may not be fluent in legacy application languages
Considering the above reasons for keeping and replacing legacy software, it’s evident each case of legacy code should be considered independently. Another consideration is that legacy code may not need to be completely replaced to meet the basic requirements of modernization. For example, porting code from Python 2.7 to Python 3.x wouldn’t require complete redesign—though may still be a significant undertaking.