A Taxonomy for a Constructive Approach to Software Evolution

In many software design and evaluation techniques, either the software evolution problem is not systematically elaborated, or only the impact of evolution is considered. Thus, most of the time software is changed by editing the components of the software system, i.e. breaking down the software system. The software engineering discipline provides many mechanisms that allow evolution without breaking down the system; however, the contexts where these mechanisms are applicable are not taken into account. Furthermore, the software design and evaluation techniques do not support identifying these contexts. In this paper, we provide a taxonomy of software evolution that can be used to identify the context of the evolution problem. The identified contexts are used to retrieve, from the software engineering discipline, the mechanisms, which can evolve the software software without breaking it down. To build such a taxonomy, we build a model for software evolution and use this model to identify the factors that effect the selection of software evolution\ud mechanisms. Our approach is based on solution sets, however; the contents of these sets may vary at different stages of the software life-cycle. To address this problem, we introduce perspectives; that are filters to select relevant elements from a solution set. We apply our taxonomy to a parser tool to show how it coped with problematic evolution problems

A Model of E-Banking Applications Evolution Issues

As a specific case of E-Commerce, E-Banking is a typical service combining a communication and a distribution channel. E-Banking applications have continuously evolved over the time, from their appearance in a context of innovation in the banking sector to the relative standardisation and convergence of current state. Several players in the banking sector were studied in order to learn specifics of client segments and implementation of requirements. This paper presents a simple model for the core issues of the evolution in E-Commerce applications. The research target is to extrapolate a framework from E-Banking case studies to understand the main business drivers over web-based applications evolution and change management

Managing software evolution through midleware and policy-based software adaptation framework

Software evolution is a process that is needed in order for software to remain useful. Thus, software evolution should be properly planned and controlled to prevent its negative impact from affecting any organization. Software adaptation concept is one of the promising ways to control software evolution. In this approach, software is made adaptable to minimize the impact of change. A lot of researches on software adaptation focus on adaptability of mobile based and network application due to its context sensitivity and quality-of-service requirements. However, there is still lack of work in enterprise system domain with multiple delivery channels, which focus on adaptability of its context environment such as the changes introduced to its devices. Hence, the purpose of this research is to develop a middleware and policy-based, adaptation framework to manage negative effects of software evolution in an enterprise system. The main research focus is on the changes introduced at the device layer. The concept of policy is used to specify adaptations requirements. This research provides a framework called Middleware and Policy-Based Framework to Manage Software Evolution (MiPAF), which can be used to develop adaptive software, allowing parameterized and compositional adaptation. Furthermore, the framework can be used by client-server and web-based application. A policy language called MiPAF Policy Language (MPL) is created to be used with the framework. MiPAF is formally specified using Z Notation and the policy language is described using pseudo code. A tool is provided to assist developers in creating the policy. For evaluation of the framework, a set of runtime components were developed and implemented for Unit Trust System (UTS) Front-end and web-based UTS, two industrial-based case studies. The evaluation result shows that MiPAF excellently fulfil all the evaluation criteria described in this thesis

Graph Based Verification of Software Evolution Requirements

Due to market demands and changes in the environment, software systems have to evolve. However, the size and complexity of the current software systems make it time consuming to incorporate changes. During our collaboration with the industry, we observed that the developers spend much time on the following evolution problems: designing runtime reconfigurable software, obeying software design constraints while coping with evolution, reusing old software solutions for new evolution problems. This thesis presents 3 processes and tool suits that aid the developers/designers when tackling these problems.\ud The first process and tool set allow early verification of runtime reconfiguration requirements. In this process the UML models are converted into a graph-based model. The execution semantics of UML are modeled by graph transformation rules. Using these graph transformation rules, the execution of the UML models is simulated. The simulation generates a state-space showing all possible reconfigurations. The runtime reconfiguration requirements are expressed by computational tree logic or with a visual state-based language, which are verified over the generated state-space. When the verification fails a feedback on the problem is provided.\ud The second process and tool set are developed for computer aided detection of static program constraint violations. We developed a modeling language called Source Code Modeling Language (SCML) in which program elements from the source code can be represented. In the proposed process for constraint violation detection, the source code is converted into SCML models. The constraint detection is realized by graph transformation rules. The rules detect the violation and extract information from the SCML model to provide feedback on the location of the problem.\ud The third process and tool set provide computer aided verification of whether a design idiom can be used to implement a change request. The developers tend to implement evolution requests using software structures that are familiar to them; called design idioms. Graph transformations are used for detecting whether the constraints of the design idiom are satisfied or not. For a given design idiom and given source files in SCML, the implementation of the idiom is simulated. If the simulation succeeds, then the models are converted to source code.\u