Software Evolution: Striving for a Better Being

Introduction

What exactly is evolution and how do we address it in the context of software? In the dynamic world we live in evolution is needed in order to survive. It is a part of the natural selection where the strongest most adaptable organisms survive the ever-changing environments. So the process of evolution is simply a changing towards the conditions that surround you in the long term.  So how do we address it in terms of software? Well if you think about it software is not that different than the real world since humans have made it in a way mimicking real world examples. Such examples are general architectural patterns, abstract classes based on real world etc.

The difference between software and real-world is that software in the past decade has evolved at a tremendous speed. Compared to the non-virtual world where change and evolution happens in terms of thousands of years and adaptation happens at a much slower rate in software we are the ones that determine the growth and evolution of the software. Since the virtual environments change fast software needs to evolve and be made in an adaptable manner otherwise it would not survive the changes. This article discusses software evolution, maintenance explains some rules and models and challenges in the context of its survival in this computer age.

What is Software Evolution?

Software Evolution is a discipline in software engineering that is based on the facts that change is inevitable and software needs to evolve continuously in order to “survive” and to remain functional. It is basically an innovative process of developing and improving the software in accordance to the standards “now”. Since the “now” is always changing the idea is that the software needs to change with the “now” thus resulting in an evolutionary manner of software development.

Software evolution’s main idea therefore to keep the software up-to-date and avoid software ageing, code decay and other unwanted problems that come with software. It may involve re-development from scratch and migrating or adapting software, whereas software maintenance addresses smaller issues such as bug fixes, minor enhancements. Software maintenance is the process of preserving and improving an existing system without making big changes to it and Software Evolution is the process of making big changes to the system’s central design in order to make it work in the new conditions that have come to be within the environment.

The Eight Rules of Software Evolution:

 

Manny Lehman, the “Father of Software Evolution”, identified eight rules about software’s evolution and describes things that either slow down or makes change within software faster.

The first rule: “Continuous change”. System must be continuously adapted else it becomes progressively less satisfactory in use. Can be easily understood since we know that the software environments are changing constantly and if the system does not adapt towards changes it becomes less and less functional in such environments (eventually becoming a Legacy system).

The second rule: “Increasing Complexity”. Because the system has evolved its complexity has increased and unless additional work is done to reduce this complexity eventually it will become a highly complex system which would become hard to maintain and adapt.

The third rule “Self-regulation”: Since the system is constantly evolving then this evolution can provide a self-regulating system.

The fourth rule “Conservation of Organizational stability”: The work rate of an evolving system tends to be constant over its operational lifetime or phases of its life-time.

The fifth rule “Conservation and familiarity”: That means that in such evolving and growing systems familiarity of the system needs to be maintained. In general the bigger the system the less people understand about its inner workings. So the developers and even the customers need to keep that in mind for such systems.

The sixth rule “Continuous growth”: That means that more functionality needs to be implemented within such systems in order to keep the customer satisfied. That in itself provides an overhead since the more functionality is implemented the more resources would be needed to maintain this. But nevertheless in order for a system to be evolving it needs to add functionality or change its previous towards new conditions.

The seventh rule “Declining quality”: The quality of software is degrading with time if not changed. In itself this software may be the same but the environments, hardware and so many things are constantly changing so previously working software may not work in the new conditions. Therefore its quality may be said to be declining with time.

The eight rule “Feedback system”: Evolution type systems are multi-level, multi-loop, multi-agent feedback systems. So in order to achieve a significant improvement they need to be treated as such.

Challenge Accepted?

Since Software Evolution has many factors to be considered when implementing it then it is logical that many challenges would arise. The most common ones are preserving and improving software quality, management issues, little theoretical background, lack of evolution tools, study experience of software developers and other external factors.

Improving and preserving software’s quality when upgrading it is one of the most common issues that arise in Software Evolution. In order to maintain its quality then its functionality needs to either improve or remain similar. This is hard to do when changing the system. One solution to dealing with such problems is testing before and after the changes and comparing the functionality of the two. But in such case the issue of whether the tests were correct arises.

Management issues that might arise when evolving a system involve allocating proper resources to a task that is hard to evaluate. Determining the need of such a system and explaining it to the upper management. Another issue is whether to evolve a legacy system or develop similar system from scratch etc.

The other challenge is that in school or university when we are given different assignments they are mainly single release and hence most of software developers don’t have experience in maintaining code or implementing an Evolution type system. Whereas in our careers we would mainly be working multi-release software and systems that are much more software evolution oriented than in our assignments and practical.

Software Evolution Models

Some examples of SE models would be the waterfall model that is a 5 step model that has maintenance in the fifth step. The spiral model, that consists of small prototype releases and a linear model of software evolution. It is based on communication with the customers thus achieving the satisfaction of the customer; risk analysis; and customer evaluation of releases. Its biggest advantage is that this model is very applicable in real-world scenarios.

Another method is the staged method is a descriptive method that involves implementing software evolution in the long run. It consists of four stages. First is the initial development where the first version of the system is produced. Second is the active evolution step and this is the step where the system is still in the early stage of development so small and simple changes can be easily implemented and also major re-engineering of the system would not provide such an overhead. Third is the servicing stage, which consists mainly of maintaining an already operational system and this is where knowledge of inner workings of the system may deteriorate. Fourth is the Phase out step which is when the system is no longer operation in the current environmental conditions and is to be replaced by new solutions and making small changes would be too costly to implement.  

Conclusion

Software is one of humanity’s most complex inventions and because of this many issues in maintaining and improving software arise. The need for improvement is obvious though. We as humans always strive for comfort and innovations. We are curious by nature, we strive for improvement and in the long run have always tried to invent things that would make our everyday life easier. It is the same with software evolution. It is the discipline of improving and redesigning in order to achieve better results or similar results but in the current situation.

 

REFERENCES:

[1] Refactoring: Improving the Design of Existing Code , Fowler 1999, ISBN 020148567X, Chapter 2 plus list of soundbites, p. 417.

[2] Software’s Future: Managing Evolution. M. M. Lehman. IEEE Software 15(1):40-44, 1998.

[3] Manifesto for Agile Software Development. Various authors, IEEE Software, November/December 2001.

[4] www.refactoring.com.

[5] Demeyer et al. 2003, preface and Chapter 1.