1 Chapter 9 Software Evolution
1 Chapter 9 Software Evolution
✧ Evolution processes
▪ Change processes for software systems
✧ Program evolution dynamics
▪ Understanding software evolution
✧ Software maintenance
▪ Making changes to operational software systems
✧ Legacy system management
▪ Making decisions about software change
✧ Evolution
▪ 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
▪ At 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
▪ The software may still be used but no further changes are made
to it.
✧ Team stability
▪ Maintenance costs are reduced if the same staff are involved
with them for some time.
✧ Contractual responsibility
▪ The developers of a system may have no contractual
responsibility for maintenance so there is no incentive to design
for future change.
✧ Staff skills
▪ Maintenance staff are often inexperienced and have limited
domain knowledge.
✧ Program age and structure
▪ As programs age, their structure is degraded and they become
harder to understand and change.
Chapter 9 Software evolution 15
Maintenance prediction
✧ Reduced risk
▪ There is a high risk in new software development. There may be
development problems, staffing problems and specification
problems.
✧ Reduced cost
▪ The cost of re-engineering is often significantly less than the
costs of developing new software.
✧ Duplicate code
▪ The same or very similar code may be included at different
places in a program. This can be removed and implemented as
a single method or function that is called as required.
✧ Long methods
▪ If a method is too long, it should be redesigned as a number of
shorter methods.
✧ Switch (case) statements
▪ These often involve duplication, where the switch depends on
the type of a value. The switch statements may be scattered
around a program. In object-oriented languages, you can often
use polymorphism to achieve the same thing.