Change Impact Analysis Techniques Research Articles

Improving the Accuracy of Static Source Code Based Software Change Impact Analysis Through Hybrid Techniques: A Review

Change is an inevitable phenomenon of life. This inevitability of change in the real world has made a software change an indispensable characteristic of software systems and a fundamental task of software maintenance and evolution. The continuous evolution process of software systems can greatly affect the systems’ quality and reliability if proper mechanisms to manage them are not adequately provided. Therefore, there is a need for automated techniques to effectively make an assessment of proposed software changes that may arise due to bug fixes, technological advancements, changing user requirements etc., before their implementation. Software Change Impact Analysis (CIA) is an essential activity for comprehending and identifying potential change impacts of software changes that can help prevent the system from entering into an erroneous state. Despite the emergence of different CIA techniques, they are yet to reach an optimal level of accuracy desired by software engineers. Consequently, researchers in recent years have come up with hybrid CIA techniques which are a blend of multiple CIA approaches, as a way of improving the accuracy of change impacts analysis techniques. This study presents these hybrid CIA techniques and how they improve accuracy. They are also compared and areas for further research are identified.

A NOVEL EFFORT ESTIMATION MODEL FOR SOFTWARE REQUIREMENT CHANGES DURING SOFTWARE DEVELOPMENT PHASE

Software Requirements Changes is a typical phenomenon in any software development project. Restricting incoming changes might cause user dissatisfaction and allowing too many changes might cause delay in project delivery. Moreover, the acceptance or rejection of the change requests become challenging for software project managers when these changes are occurred in Software Development Phase. Where in Software Development Phase software artifacts are not in consistent state such as: some of the class artifacts are Fully Developed, some are Half Developed, some are Major Developed, some are Minor Developed and some are Not Developed yet. However, software effort estimation and change impact analysis are the two most common techniques which might help software project managers in accepting or rejecting change requests during Software Development Phase. The aim of this research is to develop a new software change effort estimation model which helps software project manager in estimating the effort for software Requirement Changes during Software Development Phase. Thus, this research has analyzed the existing effort estimation models and change impact analysis techniques for Softwrae Development Phase from the literature and proposed a new software change effort estimation model by combining change impact analysis technique with effort estimation model. Later, the new proposed model has been evaluated by selecting four small size software projects as case selections in applying experimental approch. The experiment results show that the overall Mean Magnitude Relative Error value produced by the new proposed model is under 25%. Hence it is concluded that the new proposed model is applicable in estimating the amount of effort for requirement changes during SDP.

Software Change Management: a Quantified Perspective

A systematic Change Impact Analysis (CIA) is being used for better change management of software. Also, CIA process is evolved continuously to make it more effective. Software metrics play an important role to evaluate CIA process. Two types of metrics are used to evaluate CIA. First types of metrics are the standard metrics used to evaluate the performance of CIA techniques for example Precision, Recall, F-measure etc. These are most commonly used by researchers. Second types of metrics are those which are used to quantify the change impact which is based on the code/design features. This paper is aimed at identification of these second types of metrics available in literature.

Mining Variable-Method Correlation for Change Impact Analysis

Software change impact analysis (CIA) is a key technique to identify the potential ripple effects of the changes to software. Coarse-grained CIA techniques such as file, class and method level techniques often gain less precise change impacts, which are difficult for practical use. Fine-grained CIA techniques, such as slicing, can be used to gain more precise change impacts, but need more time and space cost. In this paper, by combining the features of the coarse-grained technique and the fine-grained technique, a variable-method (VM) correlation-based CIA technique called VM-CIA is proposed to improve the precision of static CIA. First, the VM-CIA technique uses the abstract syntax tree (AST) of program to construct a novel intermediate representation called variable and method triple (VMT), which is used to analyze the correlation between the variables and methods. Second, the VM-CIA technique proposes the single-change impact analysis algorithm and multi-change impact analysis algorithm to compute the impact set based on the VMT representation. In addition, the VM-CIA technique can get a sorted impact set which is more accurate than the existing CIA techniques. The empirical results show that the VM-CIA technique can greatly improve the precision (19%) over traditional the CIA techniques, while at the cost of a little recall (5%). Moreover, the empirical studies also show that the VM-CIA technique predicts a ranked list of potential impact results according to the distance measure, which can greatly facilitate the practical use.

FACIA: A Fully Automatic Change Impact Analysis Method for Large Scale Requirements

The blooming change of requirements poses a challenge for change impact analysis (CIA), especially in large scale software development. Existing CIA techniques exploiting manual analysis and automatic methods suffer from high cost, low accuracy and expert dependence in current industrial practice. Therefore, this paper proposes a fully automatic change impact analysis (FACIA) method to overcome the aforementioned shortcomings. We consider the requirement changes generally happen as the form of phrases. The impact units for the changed phrases may contain the changed phrases (CP1), the co-occurrence phrases of CP1(CP2), the tokens of CP1 in the changed requirement, the similar phrases of CP1 and the similar phrases of CP2 in the whole requirements. Then five algorithms are designed based on the combinations of those impact units, so as to get a more precise change propagation and generate the lists of change impact automatically. We conduct extensive evaluations for the proposed approach with two different industrial data sets. The results show that compared with the method of expert depended, our approach can get a reliable sorted list for CIA more quickly with lower cost.

Static change impact analysis techniques: A comparative study

Software Change Impact Analysis (CIA) is an essential technique to identify the potential effects caused by software changes during software maintenance and evolution. A rich body of CIA techniques, especially static CIA techniques, have continuously emerged in recent years such as structural static analysis, textual analysis, and historical analysis. However, there were only a few works focusing on comparison of static CIA techniques. This article attempts to bridge this gap by presenting a comparative study of three class-level static CIA techniques, i.e., Columbus, ROSE, and IRC2M. We compare them based on a CIA comparative framework and conduct an empirical study to evaluate these three CIA techniques and their combinations based on five real-world programs. The empirical results show that: (1) IRC2M and ROSE achieve relatively better precision, recall and F-measure compared to Columbus; (2) combination of any two CIA techniques can improve the precision and recall over their individual one; moreover, combining ROSE with IRC2M produces the best impact results; and (3) combining all three CIA techniques obtain a similar precision and recall as combining ROSE with IRC2M.

A Framework for Effective Object-Oriented Software Change Impact Analysis

Object-oriented (OO) software have complex dependencies and different change types which frequently affect their maintenance in terms of ripple-effects identification or may likely introduce some faults which are hard to detect. As change is both important and risky, change impact analysis (CIA) is a technique used to preserve the quality of the software system. Several CIA techniques exist but they provide little or no clear information on OO software system representation for effective change impact prediction. Additionally, OO classes are not faults or failures-free and their fault-proneness is not considered during CIA. There is no known CIA approach that incorporates both change impact and fault prediction. Consequently, making changes to software components while neglecting their dependencies and fault-proneness may have some unexpected effects on their quality or may increase their failure risks. Therefore, this paper proposes a novel framework for OO software CIA that allows for impact and fault predictions. Moreover, an intermediate OO program representation that explicitly represents the software and allows its structural complexity to be quantified using complex networks is proposed. The objective is to enhance static CIA and facilitate program comprehension. To assess its effectiveness, a controlled experiment was conducted using students’ project with respect to maintenance duration and correctness. The results obtained were promising, indicating its importance for impact analysis.

Precepts and Evolvability of Complex Systems

Abstract In complex enterprise systems that undergo continual evolutions, the change impact tends to get cumulative and adverse and have high probability of degradation of software quality. Functional evolutions are the most frequent and the most impacting evolutions. The functional components in a software architecture that are aligned with them are the activities. Activity is a business process that fulfils an operation contract of an application. An application is a set of activities that get invoked by different users. In the software evolution process, the change impact analysis techniques generate the model(s) of the data-flows and/or control-flows within the source code for the activity to be evolved. They capture the propagation of changes and derive the change impact sets which are then used for the planning, estimation, development and verification phases of the evolution process. The taxonomical surveys of evolutions indicate that the control structures embedded within the source code undergo changes much more rapidly than the other elements and are the major culprits in the evolvability degradation. We define an architectural approach of modeling the control structures within the activities of an application as precepts, the control-flow rule-sets, that mitigates the adverse impact of evolution. Precepts also facilitate the definition of Evolvability Metrics that measure the evolvability index of an application. The existing metrics that indicate evolvability, measure the complexity as well as modularity at a low level and cannot be aggregated trivially. To validate these metrics, we define Efforts Deviation Index that captures the difficulty level of the change implementation process.

Using water wave propagation phenomenon to study software change impact analysis

Software change impact analysis (CIA) is a key technique to identify the potential effects caused by software changes. Given the proposed changes, most commonly used CIA techniques apply reachability analysis on the graphical representation of the software to identify their effects. They often compute a large set of potentially impacted elements with many false-positives, which will waste resource in later analysis. In addition, these techniques do not consider the interference among the proposed changes, which does exist in practice. Faced with these problems, this paper proposed a new call graph-based CIA technique, which takes the interference among multiple proposed changes into account to improve the precision of the impact results. Our proposed CIA is inspired by a natural phenomenon ''water wave propagation''. The CIA process is similar to the process of water wave propagation. First we identify the ''core'' (a special set of methods) generated by the proposed changes. Then we compute the ripple effects through propagation analysis on this core. Empirical evaluations on two real-world software projects demonstrate the effectiveness of our CIA approach. The results show that our CIA technique can predict better impact results when more changes are known, and provide an eclectic way for practical use. Moreover, it can effectively remove the false-positives at the cost of missing a few false-negatives when compared to traditional (call graph based) CIA techniques.

Computing and visualizing the impact of change with Java PathFinder extensions

Change impact analysis techniques estimate the potential effects of changes made to software. Directed Incremental Symbolic Execution (DiSE) is a Java PathFinder extension that computes the impact of changes on program execution behaviors. The results of DiSE are a set of impacted path conditions that can be efficiently processed by a subsequent client analysis. Path conditions, however, may not be intuitive for software developers without the context of the source code. In this paper we present a framework for visualizing the results of DiSE. The visualization includes annotated source code and control ow graphs indicating program statements that are changed and statements that may be impacted by the changes. A simulation mode enables users to also observe the impact of changes on symbolic execution of the program, by showing the changes to the path conditions as the user steps through the sequences of statements executed.

Combining concept lattice with call graph for impact analysis

Software change impact analysis (CIA) is a key technique to identify unexpected and potential effects caused by software changes. Given a changed entity, most of current CIA techniques compute the change effect composed of some potentially impacted entities. The generated results are often of no help to the maintainers in starting the analysis of impacted entities. In this article, we combine concept lattice with call graph together to obtain a ranked list of potentially impacted methods from the proposed changed methods and/or classes. These impacted methods are ranked based on the hierarchical feature of concept lattice, represented by an impact factor, which can then be used to prioritize these methods to be inspected. Case studies based on four real-world programs show that our approach can improve the precision of the impact result without severely decreasing its recall, when compared with results from either concept lattice or call graph used independently. In addition, the predicted impacted methods with higher impact factor values are also shown to have higher probability to be affected by the changes. Our study also shows that our approach is better than the JRipples CIA approach in removing the false-positives, but at the cost of losing more false-negatives and much more time overhead.

A survey of code‐based change impact analysis techniques

SUMMARYSoftware change impact analysis (CIA) is a technique for identifying the effects of a change, or estimating what needs to be modified to accomplish a change. Since the 1980s, there have been many investigations on CIA, especially for code‐based CIA techniques. However, there have been very few surveys on this topic. This article tries to fill this gap. And 30 papers that provide empirical evaluation on 23 code‐based CIA techniques are identified. Then, data was synthesized against four research questions. The study presents a comparative framework including seven properties, which characterize the CIA techniques, and identifies key applications of CIA techniques in software maintenance. In addition, the need for further research is also presented in the following areas: evaluating existing CIA techniques and proposing new CIA techniques under the proposed framework, developing more mature tools to support CIA, comparing current CIA techniques empirically with unified metrics and common benchmarks, and applying the CIA more extensively and effectively in the software maintenance phase. Copyright © 2012 John Wiley & Sons, Ltd.