Chapter 5 - Change-Effects Analysis for Evolving Software

Most modern software systems can be adjusted to satisfy sets of conflicting requirements issued by different groups of users, based on their intended usage or execution context. For systems where configurations are a core concern, specific implementation mechanisms are put in place to allow the instantiation of sets of tailored components. Among those, we find selection processes for code artefacts, variability-related annotation in the code, variability models representing the available features and their allowed combina- tions. <br/><br/>In such systems, features, or units of variability, are scattered across the aforementioned types of artefacts. Maintenance and enhancement of existing systems remain a challenge today, for all types of software systems. But in the case of variant-rich systems, engineers face an additional challenge due to the complexity of the product instantiation mechanisms: the maintenance of the variability model of the system, the complex build mechanisms, and fine-grained variability in the source code. The evolution of the system should be performed such that the information contained within the various artefacts remains consistent. In practice, this means that as the implementation of the system evolves, so should the mechanisms put in place to generate tailored products. <br/><br/>Little information is available regarding changes occurring in such systems. To efficiently support such developers tasks and ease maintenance and enhancements activities, we need a deep understanding of the changes that take place in such systems. The state of the art provides trends over long period of times, highlighting systems growth - such as number of added or removed features in each release, or the evolution of cross- tree constraints in a variability model. While important to describe the core dynamics behind the evolution of a system, this does not provide information on the changes per- formed by developers leading to such trends. Similarly, this global information cannot be leveraged to facilitate developers’ activities. <br/><br/>The focus of this thesis is the acquisition and usage of change information regard- ing variant-rich system evolution. We show how the information lacking from today’s state-of-the-art can be obtained from variant-rich system change history. We propose a set of tool-supported approaches designed to gather such information and show how we leverage change information for change impact analysis, or to derive knowledge on developer practices and the challenges they face during such operations. With this work, we shed new light on change scenarios involving heterogeneous artefacts regarding their nature as well as their prevalence in the evolution of such complex systems, and change impact analysis in variant-rich systems. <br/><br/>We designed a model-based approach to extract feature related changes in heterogeneous artefacts. With such an approach, we can gather detailed information of feature evolution in all relevant artefacts. We created an approach for multi-product line modelling for impact computation. We leverage variability information to produce a collection of inter-related variability models, and show how to use it for targeted feature- <br/><br/>change impact analysis on available capabilities of the product family. By applying our change extraction approaches on the Linux kernel, we were able to empirically characterise the evolution of the variability model of this system. We showed that the variability model of that system evolves mostly through modification of existing features, rather than through additions and removals. Similarly, we studied co-evolution of artefacts dur- ing feature evolution in the Linux kernel. Our study revealed that, in this system, most features evolve mostly through their implementation, and complex changes, involving heterogeneous artefacts are not the most frequent. <br/>Through this work, we provide detailed information on the evolution of a system, namely the Linux kernel, and the means used to obtain this information. We show that the gathered data allow us to reflect on the evolution of such a system, and we argue that gathering such information on any system is a source of valuable information regarding a system architecture. To this end, all tools developed in the context of this study were made available to the public. <br/>In this work, we provide key information on the evolution of the Linux kernel, as well as the means to obtain the same information from other variant-rich systems. The knowledge gained on common evolution scenarios is critical for tool developers focus- ing on the support of development of variant-rich systems. A better understanding of common evolution scenario also allows engineers to design systems that will be better equipped to elegantly evolve through such scenarios. While a number of challenges will still have to be addressed in this domain, this work constitutes a step toward a better understanding of variant-rich system evolution and therefore toward better variant-rich system designs. <br/>

Database applications are becoming increasingly popular, mainly due to the advanced data management facilities that the underlying database management system offers compared against traditional legacy software applications. The interaction, however, of such applications with the database system introduces a number of issues, among which, this paper addresses the impact analysis of the changes performed at the database schema level. Our motivation is to provide the software engineers of database applications with automated methods that facilitate major maintenance tasks, such as source code corrections and regression testing, which should be triggered by the occurrence of such changes. The presented impact analysis is thus two-folded: the impact is analysed in terms of both the affected source code statements and the affected test suites concerning the testing of these applications. To achieve the former objective, a program slicing technique is employed, which is based on an extended version of the program dependency graph. The latter objective requires the analysis of test suites generated for database applications, which is accomplished by employing testing techniques tailored for this type of applications. Utilising both the slicing and the testing techniques enhances program comprehension of database applications, while also supporting the development of a number of practical metrics regarding their maintainability against schema changes. To evaluate the feasibility and effectiveness of the presented techniques and metrics, a software tool, called DATA, has been implemented. The experimental results from its usage on the TPC-C case study are reported and analysed.

Safety standards prescribe change impact analysis (CIA) during evolution of safety-critical software systems. Although CIA is a fundamental activity, there is a lack of empirical studies about how it is performed in practice. We present a case study on CIA in the context of an evolving automation system, based on 14 interviews in Sweden and India. Our analysis suggests that engineers on average spend 50–100 h on CIA per year, but the effort varies considerably with the phases of projects. Also, the respondents presented different connotations to CIA and perceived the importance of CIA differently. We report the most pressing CIA challenges, and several ideas on how to support future CIA. However, we show that measuring the effect of such improvement solutions is non-trivial, as CIA is intertwined with other development activities. While this paper only reports preliminary results, our work contributes empirical insights into practical CIA.

B a c k g r o u n d . Adaptive behavior in modern software systems is becoming a key factor in their successful operation under external and internal destabilizing influences. Programs that work with critical data or perform essential operations must ensure continuity of service, despite failures, attacks, or errors. Various approaches are proposed to achieve this goal, one of which is the application of design patterns that ensure system reliability and adaptability. This paper presents the “Manager-Dispatcher” pattern, which combines the features of the “Publish- Subscribe” and “Strategy” patterns to enable adaptive behavior in software systems through event processing. M e t h o d s . The development of the “Manager-Dispatcher” pattern was based on modular design and dynamic event processing methods. The pattern provides an automatic strategy selection for module operation based on events occurring within the system. A theoretical analysis of existing approaches to adaptive behavior in systems was conducted, leading to the creation of a new pattern that enables dynamic strategy changes in modules in response to environmental changes determined by system events. Several hypothetical application scenarios were considered to illustrate the pattern’s functionality, and an example software system utilizing the pattern was developed and described. R e s u l t s . The developed “Manager-Dispatcher” pattern allows software modules to automatically adapt their operational strategies based on system events. Key advantages of the pattern include modularity, extensibility, and adaptive behavior. The pattern may be particularly useful in embedded systems, real-time systems, and interactive interfaces, where fast and flexible responses to events are essential. C o n c l u s i o n s . The “Manager-Dispatcher” pattern offers a promising approach to the design of event-driven adaptive software systems. With its ability to dynamically change operational strategies, the pattern ensures a high degree of flexibility in dynamic environments. Future research will focus on improving the pattern and developing tools to facilitate its implementation and testing. This proposed approach supports the development of modular and adaptive systems capable of maintaining stable operation even under complex conditions.

Change impact analysis is a useful technique for software evolution. It determines the effects of a source editing session and provides valuable feedbacks to the programmers for making correct decisions. Recently, many techniques have been proposed to support change impact analysis of procedural or object-oriented software, but seldom effort has been made for aspect-oriented software. In this paper we propose a new change impact analysis technique for AspectJ programs. At the core of our approach is the atomic change representation which captures the semantic differences between two versions of an AspectJ program. We also present an impact analysis model, based on AspectJ call graph construction, to determine the affected program fragments, affected tests and their responsible changes. The proposed techniques have been implemented in Celadon, a change impact analysis framework for AspectJ programs. We performed an empirical evaluation on 24 versions of eight AspectJ benchmarks. The result shows that our proposed technique can effectively perform change impact analysis and provide valuable information in AspectJ software evolution.

One of the major challenges faced by software companies is to produce high-quality software. Quality is not a state but a continuous process, it is critical to produce quality artefact at every stage of software development. Making modifications to software during and after development is a common occurrence. Executing the recommended modifications in software might have negative consequences such as lowering its quality or introducing new problems, which would raise the cost of software maintenance. As a result, a methodical approach to change management is necessary. Change Impact Analysis (CIA) is a method for controlling software modification that has already been implemented. CIA is becoming increasingly essential in various sectors, particularly software development. The objective of this paper is to do an analysis on CIA’s emerging elements, which evaluates the nature of every change request and seeks to integrate such changes into a program in a step-by-step manner. The paper aims to uncover the difficulties and challenges in CIA, current advancements, methodologies and tools in the field as well as the emerging scope of research in this field.

Regression testing is essential to ensure software quality during software evolution. Two widely-used regression testing techniques, test case selection and prioritization, are used to maximize the value of the continuously enlarging test suite. However, few works consider both these two techniques together, which decreases the usefulness of the independently studied techniques in practice. In the presence of changes during program evolution, regression testing is usually conducted by selecting the test cases that cover the impact results of the changes. It seldom considers the false-positives in the information covered. Hence, the effectiveness of such regression testing techniques is decreased. In this paper, we propose an approach, ComboRT, which combines test case selection and prioritization together to directly generate a ranked list of test cases. It is based on the impact results predicted by the change impact analysis (CIA) technique, FCA–CIA, which generates a ranked list of impacted methods. Test cases which cover these impacted methods are included in the new test suite. As each method predicted by FCA–CIA is assigned with an impact factor value corresponding to the probability of this method to be impacted, test cases are then ordered according to the impact factor values of the impacted methods. Empirical studies on four Java based software systems demonstrate that ComboRT can be effectively used for regression testing in object-oriented Java-based software systems during their evolution.

At the present day, software systems get more and more complex. The requirements of software systems change continuously and new requirements emerge frequently. New and/or modified requirements are integrated with the existing ones, and adaptations to the architecture and source code of the system are made. The process of integration of the new/modified requirements and adaptations to the software system is called change management. The size and complexity of software systems make change management costly and time consuming. To reduce the cost of changes, it is important to apply change management as early as possible in the software development cycle. Requirements traceability is considered crucial in change management for establishing and maintaining consistency between software development artifacts. It is the ability to link requirements back to stakeholders’ rationales and forward to corresponding design artifacts, code, and test cases. When changes for the requirements of the software system are proposed, the impact of these changes on other requirements, design elements and source code should be traced in order to determine parts of the software system to be changed. Determining the impact of changes on the parts of development artifacts is called change impact analysis. Change impact analysis is applicable to many development artifacts like requirements documents, detailed design, source code and test cases. Our focus is change impact analysis in requirements and software architecture. The need for change impact analysis is observed in both requirements and software architecture. When a change is introduced to a requirement, the requirements engineer needs to find out if any other requirement related to the changed requirement is impacted. After determining the impacted requirements, the software architect needs to identify the impacted architectural elements by tracing the changed requirements to software architecture. It is hard, expensive and error prone to manually trace impacted requirements and architectural elements from the changed requirements. In this thesis, we introduce methods and tools for application of change impact analysis in requirements and software architecture.

Softwares are naturally evolved to cope with various changing system requirements. Software evolution includes a series of activities to analyze, assess, and validate the changes. This paper proposes an integrated software evolution model, namely SE-FCA, to support four core software evolution activities: program comprehension, change impact analysis, regression testing, and fault localization. These four activities are integrated and supported under the formal concept analysis technique, which is efficient to deal with the relation between entities and entity properties to provide a remarkable insight into the structure of the original relation. These activities are evaluated in a unified empirical environment. The empirical study shows the effectiveness of these activities under the SEFCA model.

It is widely believed that refactoring improves software quality and developer's productivity by making it easier to maintain and understand software systems. On the other hand, some believe that refactoring has the risk of functionality regression and increased testing cost. This paper investigates the impact of refactoring edits on regression tests using the version history of Java open source projects: (1) Are there adequate regression tests for refactoring in practice? (2) How many of existing regression tests are relevant to refactoring edits and thus need to be re-run for the new version? (3) What proportion of failure-inducing changes are relevant to refactorings? By using a refactoring reconstruction analysis and a change impact analysis in tandem, we investigate the relationship between the types and locations of refactoring edits identified by RefFinder and the affecting changes and affected tests identified by the FaultTracer change impact analysis. The results on three open source projects, JMeter, XMLSecurity, and ANT, show that only 22% of refactored methods and fields are tested by existing regression tests. While refactorings only constitutes 8% of atomic changes, 38% of affected tests are relevant to refactorings. Furthermore, refactorings are involved in almost half of the failed test cases. These results call for new automated regression test augmentation and selection techniques for validating refactoring edits.

Change impact analysis in microservice systems: A systematic literature review

In large-scale software development projects, change impact analysis (CIA) plays an important role in controlling software design evolution. Identifying and accessing the effects of software changes using traceability links between various software artifacts is a common practice during the software development cycle. Recently, research in automated traceability-link recovery has received broad attention in the software maintenance community to reduce the manual maintenance cost of trace links by developers. In this study, we conducted a systematic literature review related to automatic traceability link recovery approaches with a focus on CIA. We identified 33 relevant studies and investigated the following aspects of CIA: traceability approaches, CIA sets, degrees of evaluation, trace direction and methods for recovering traceability link between artifacts of different types. Our review indicated that few traceability studies focused on designing and testing impact analysis sets, presumably due to the scarcity of datasets. Based on the findings, we urge further industrial case studies. Finally, we suggest developing traceability tools to support fully automatic traceability approaches, such as machine learning and deep learning.

Traceability is the ability to relate di erent artifacts during the development and operation of a system to each other. It enables program comprehension, change impact analysis, and facilitates the cooperation of engineers from di erent disciplines. The 10th International Workshop on Software and Systems Traceability (former International Workshop on Traceability in Emerging Forms of Software Engineering, TEFSE), explored the role and impact of traceability in modern software and systems development. The event brought together researchers and practitioners to examine the challenges of recovering, maintaining, and utilizing traceability for the myriad forms of software and systems engineering artifacts. SST'19 was a highly interactive working event focused on discussing the main problems related to software traceability in particular in the context of opportunities and challenges posed by the recent progress in Arti cial Intelligence techniques and proposing possible solutions for such problems.

Software maintenance is the most demanding and effort-consuming phase in software development. It has been recognized as being a tedious step in software development process. Two basic activities in software maintenance are the understanding of the system and the assessment of the potential effects of a change. A change to a system, however small, can lead to several accidental effects, which are often not obvious and easy to identify. The main purpose of impact analysis is not only to find the impact set in terms of coding elements but also in terms of effort and resources required for implementing the change so that analysts could analyze the impact of the requested change in terms of budget. The objective of this paper is to find the impact set of the change requested by user or client. By using the impact set we estimate the regression test effort. We illustrate our results with a case study. As the results of this work, we get the impact set having impact element as class names with respect to the requested change, the test suite and the effort required for regression testing after the implementation of the requested change.

Change impact analysis: A systematic mapping study