- Software Evolution is the process of developing software using software engineering principles and methods.
- This involves the initial development of software, its maintenance, and timely updates until and unless desired software is developed, which fulfills the expected requirements from the software.
Importance of Software Evolution:
- Organizations have big investments in their software systems. They are like their critical business assets.
- To maintain the standard value of these assets to the business, they must be changed and updated in a timely manner and according to changing requirements of the business.
- The majority of the software budget in large organizations is more focused on changing and evolving existing software rather than developing new software.
- Because this will save the cost and time required to develop new software.
The Reasons why software Evolution or Changes are Inevitable:
Many factors changes during the software system’s life cycle therefore software evolution or changes are inevitable. Some of these factors are as follows:
- Requirement changes - New requirements arrive when the software is in use.
- Environment changes - If the business strategies changed then the environment also changes;
- Errors or security breaches - Errors or bugs must be repaired in a timely manner.
- New equipment added or removed - To increase the performance and fast data processing and other functionalities after new features.
- Improvements to the system - The performance or reliability of the system must be improved.
Evolution and Servicing:
- Evolution - Evolution is the stage in a software system’s life cycle where it is in operational use and is evolving as new requirements are proposed and implemented in the system.
- Servicing - In this stage, the software remains useful but the only changes made are those required to keep it operational i.e. bug fixes and changes to reflect changes in the software’s environment. No new functionality is added.
- Phase-out - In this stage, the software may still be used but no further changes are made to it.
A Spiral Model of Development and Evolution:
A spiral model of development and evolution represents how a software system evolves through a sequence of multiple releases.
- Software evolution processes depend on
- The type of software being maintained
- The development processes used
- The skills and experience of the people involved
- Proposals for change are the driver of system evolution.
- These should be linked with components that are affected by the change, thus allowing the cost and impact of the change to be estimated.
- Change identification and evolution continues throughout the system's lifetime.
The software Evolution Process:
Change Implementation -
- Iteration of the development process where the revisions to the system are designed implemented and tested.
- A critical difference is that the first stage of change implementation may involve program understanding, especially if the original system developers are not responsible for the change implementation.
- During the program understanding phase, you have to understand how the program is structured, how it delivers functionality, and how the proposed change might affect the program.
Urgent Change Requests -
- Urgent changes may have to be implemented without going through all stages of the software evolution process
- If a serious system fault has to be repaired to allow normal operation to continue;
- If changes to the system’s environment (e.g. an OS upgrade) have unexpected effects;
- If there are business changes that require very rapid response (e.g. the release of a competing product).
Agile Methods and Evolution -
- Agile methods are based on incremental development so the transition from development to evolution is a seamless one.
- Evolution is simply a continuation of the development process based on frequent system releases.
- Automated regression testing is particularly valuable when changes are made to a system.
- Changes may be expressed as additional user stories.
Software Evolution Laws:
Lehman has given laws for software evolution. These laws divided the software into three different categories are as follows:
- S-Type (Static-type) - This is software, which works strictly according to defined specifications and solutions. The s-type software is least subjected to changes hence this is the simplest of all. For example, Calculator [rogram for Mathematical Computation.
- P-Type (Practical-type) - This is software with a collection of procedures. This is defined by exactly what procedures can do. For example, Gaming Software.
- E-Type (Embedded-type) - This software works closely as the requirement of the real-world environment. This software has a high degree of evolution as there are various changes in laws, taxes, etc. in real-world situations. For example, Online Trading Software.
E-Type Software Evolution:
Lehman has given Eight laws for E-Type software evolution -
- Continuing change
- Increasing complexity
- Conservation of familiarity
- Continuing growth
- Reducing quality
- Feedback systems
- Organizational stability