Thompson Rivers University Software Evolution Report - COMP 3520

This report provides a comprehensive analysis of software evolution, focusing on the types of software maintenance (adaptive, corrective, and perfective) and their implications. It explores the challenges of software evolution, including complexity, project management issues, and the need for continuous adaptation to changing requirements. The report examines the impact of changes in data usage and calling structures on software complexity. Furthermore, it delves into how the time spent on different maintenance types influences team configuration and development methodologies, offering insights into setting up a development organization. The paper also discusses the implications of aging software and the software crisis, offering a detailed exploration of the subject matter.

Running head: SOFTWARE ENGINEERING
SOFTWARE ENGINEERING
Name of the Student:
Name of the University:
Author Note:

1SOFTWARE ENGINEERING
Table of Contents
Introduction......................................................................................................................................2
Software Evolution..........................................................................................................................2
Laws of Software Evolution............................................................................................................3
Types of Software Maintenance......................................................................................................4
Implications of Aging Software.......................................................................................................4
Software Crisis.............................................................................................................................4
Changes in Data Usage and Calling Structures...............................................................................6
Conclusion.......................................................................................................................................6
References........................................................................................................................................8

2SOFTWARE ENGINEERING
Introduction
Software Evolution is process to develop software initially, and then update the software
timely for numerous reasons like adding new features to it or removing obsolete functionalities.
Evolution process consists of fundamental activities of release planning, change analysis,
releasing system for customers and implementation of system Cost of such changes could be
accessed for seeing the change within the system and the cost for implementing this change [1].
If there is acceptance of proposed changes, software system’s new release is planned. In time of
planning of release, every proposed change such as adaptation, new functionalities and fault
repair are considered. Design is made then, based in which the changes would be implemented in
system’s next version. Change implementation’s process is iteration of development process in
where system’s revisions are designed, tested and implemented.
Software Evolution
Software evolution could be referred as the process to develop, maintain and update
software for several reasons. Changes in software could be inevitable as several factors are there
which change life cycle of software. Few of the factors consist of requirement change, security
breaches or errors, environment changes, improvements to system and new equipment removed
or added.
Managing huge software systems is huge task for several software engineers, as due to
regular evolution of systems and software. They should ensure they are up to the changes and
make sure that system meets requirements of changes within software with small cost and
downtime [2]. Several challenges are faced by software engineers while attempt in maintaining

3SOFTWARE ENGINEERING
huge software systems. Few of the such challenges include availability of documentation of
system and other documentation that are related to the changes done since original
implementation, managing software system’s growing complexity, making sure enough storage
is there on system for implementing changes and to store data and making sure that any changes
could be scaled and in scope of current system [3]. In order for ensuring that changes and
updates to system are tracked and documented properly, the engineers must follow process
model of maintenance phase. Seven phases are there in the model: change request, impact
analysis, design, regression testing, acceptance testing, system implementation and system
release.
Laws of Software Evolution
Law for increasing complexity: As there is change in evolving program, the structure of it
becomes much more complicated unless there are effective efforts made for avoiding the
phenomenon.
Law for continuing change: The law states that software system which represent few reality of
real world undergoes continuous change and becomes less useful progressively in such
environment [4].
Law for familiarity’s conversation: The law states during program’s active lifetime, changes
made within successive release are constant almost.
Law for organization stability’s conservation: Over lifetime of program, development rate of
the program is constant approximately and independent of resources that are devoted to the
development of the system.

4SOFTWARE ENGINEERING
Types of Software Maintenance
Three categories for maintenance of software are identified such as perfective, adaptive
and corrective. However, software’s four categories were catalogued.
Adaptive Maintenance: It is modification to software product that is performed after the
delivery for keeping the product usable within changing or changed environment [5].
Corrective Maintenance: This is software products’ reactive modification that is performed
after the delivery to right discovered problems.
Preventive Maintenance: This is modification of the software after the delivery for detecting
and correcting the latent faults within software before they turn into effective faults.
Perfective Maintenance: This is software’s modification after delivery in improving the
maintainability or performance.
Implications of Aging Software
Software Crisis
Software is now key element for electronic processing of data. Hardware technology’s
progress gave computers in taking over more complicated tasks. Software evolved to essential
industry itself. In spite of technology’s progress, specific problem is faced by software engineers
such as complexity to evolve the software systems. Project managers risk testing the new
methods as they like to depend on the procedures that are established already [6]. Developers
who are experienced developed own techniques for dealing with the complexity by practice.
Many inherent facts for development of software complicate solving issues such as complexity

5SOFTWARE ENGINEERING
of the system handling complicated tasks, problems for development of software within project
management, difficulty for finding out what is expected from the customer and need of software
system’s continuous adaption [7].
Complexity: Structure of software system, environment used by it, components this works
together exceeds capabilities of single developer. Absurd order would not be accomplished by
human being, however computer would. Institution might tell that there is misunderstanding,
however computer executes always the commands which feds. It would automatically never
correct infeasible commands logically.
Project Management: The managers who get behind the schedule and add programmers would
be astonished that by adding people don’t speed up the development. Bigger is the team, more
coordination among the members of the team is needed. Increased communication among
members consumes extra time as well as might compensate added productivity by added
programmers [8]. Developers should know first the process in handling new tools in reasonable
way, then utilize them. Programming skill’s level varies among different programmers. Every
programmer should be assigned proper task for deploying his potential. Project management’s
additional problem is programmers’ latest rapid turnover within the projects. Rapid turnover of
employee leads to knowledge’s permanent loss about domain and system.
Continuous Adaptation: Software system would not stop evolving. Adaptation to the new
requirements and conflicts’ elimination arising by change propagation force code’s continuous
adaptation. Environment in where there is development of software, changes quite dramatically.
Requirements: Not only future requirements, however it is tough to seize actual expectations ad
needs of customer. All the requirements won’t be formulated by the customer. Yet developer

6SOFTWARE ENGINEERING
who is not familiar with domain might not know of the implicit requirements. Customer’s
indications combined with conditions of domain should be translated to technical specifications
[9]. Those who implemented the software for the customer knows perfidies of such
transformation.
Changes in Data Usage and Calling Structures
Source code’s calling structure is analyzed. Calling structures are transformed into graph
by using dominance relations for indicating call dependencies among functions. There was
derivation of dominance tree from the graphs. Complexity of relationships among functions is
shown by dominance tree. Dominance relations are analyzed for many version of similar
software [10]. The changes within graph could be tracked. These changes give indication about
software’s changing complexity and about the change impacts. Dominance relations’ use is
excellent tool for analyzing change propagation in source code.
Conclusion
Determination of strategies of software evolution is management responsibility which
takes into consideration several factors related to business. Circumstances might arise where
technical or business considerations suggest release policy within interest of business as whole
that might have undesirable consequences for system whose evolution is planned. Software
evolution consists of software’s initial development and its updates and maintenance, until there
is development of desired software that satisfies expected requirements. Evolution begins form
process of requirement gathering. After that prototype of intended software is created by the
developers and shown to user for getting the feedback within early stage for development of

7SOFTWARE ENGINEERING
software. Changes are suggested by the users, based on which many consecutive maintenance
and updates keep changing. Such process changes into original software until desired software
could be accomplished. This paper discusses the evolution of software as well as laws of
software evolution. Types of software maintenance are also discussed in the paper. Changes in
data usage and calling structure are also discussed in the paper.

8SOFTWARE ENGINEERING
References
[1] J.B. de Vasconcelos, C. Kimble, P. Carreteiro and A. Rocha, “The application of
knowledge management to software evolution”, International Journal of Information
Management, 37(1), pp.1499-1506, 2017
[2] O. Legunsen, F. Hariri, A. Shi, Y. Lu, L. Zhang and D. Marinov, “An extensive study of
static regression test selection in modern software evolution”, In Proceedings of the 2016
24th ACM SIGSOFT International Symposium on Foundations of Software Engineering
(pp. 583-594), 2016
[3] G. Grano, A. Di Sorbo, F. Mercaldo, C.A. Visaggio, G. Canfora and S. Panichella,
“Android apps and user feedback: a dataset for software evolution and quality
improvement”, In Proceedings of the 2nd ACM SIGSOFT International Workshop on
App Market Analytics (pp. 8-11), 2017
[4] E. Guzman, M. Ibrahim and M. Glinz, “A little bird told me: Mining tweets for
requirements and software evolution”, In 2017 IEEE 25th International Requirements
Engineering Conference (RE) (pp. 11-20). IEEE, 2017
[5] Y. Lu, Y. Lou, S. Cheng, L. Zhang, D. Hao, Y. Zhou and L. Zhang, “ How does
regression test prioritization perform in real-world software evolution?”, In Proceedings
of the 38th International Conference on Software Engineering (pp. 535-546), 2016
[6] A. Hora, D. Silva, M.T. Valente and R. Robbes,”Assessing the threat of untracked
changes in software evolution”, In Proceedings of the 40th International Conference on
Software Engineering (pp. 1102-1113), 2018

9SOFTWARE ENGINEERING
[7] E. Guzman, M. Ibrahim and M. Glinz, “Mining twitter messages for software evolution”,
In 2017 IEEE/ACM 39th International Conference on Software Engineering Companion
(ICSE-C) (pp. 283-284), IEEE, 2017
[8] S.M. Ali, M. Doolan, P. Wernick and E. Wakelam, ”Developing an agent-based
simulation model of software evolution”, Information and Software Technology, 96,
pp.126-140, 2018
[9] X. Franch, J. Ralyté, A. Perini, A. Abelló, D. Ameller, J. Gorroñogoitia, S. Nadal, M.
Oriol, N. Seyff, A. Siena and A. Susi, “A situational approach for the definition and
tailoring of a data-driven software evolution method”, In International Conference on
Advanced Information Systems Engineering (pp. 603-618). Springer, Cham, 2018
[10] D. Dzvonyar, S. Krusche, R. Alkadhi and B. Bruegge, ”Context-aware user feedback in
continuous software evolution”, In 2016 IEEE/ACM International Workshop on Continuous
Software Evolution and Delivery (CSED) (pp. 12-18). IEEE, 2016