A Software Impact Analysis Tool based on Change History Learning and its Evaluation

Software change impact analysis (CIA) methods enable developers to understand potential impacts of a code change so that the change can be executed confidently without affecting reliability of the software. However, existing CIA approaches do not support CIA for all source code granularities. Additionally, they lack support for inter-granular change impact queries and hidden dependencies. This paper introduces Augur, an automated static code analysis-based CIA approach that addresses these shortcomings. Augur infers and maintains semantic and environment dependencies along with data and control dependencies between source code entities across granularities. Additionally, Augur uses Change Impact Query Language, a novel query language for impact analysis proposed in this paper, to support inter-granular CIA queries with batch querying feature. Augur has been realized as a Visual Studio extension called Augur-Tool. We have conducted quantitative evaluation on two open-source and two industrial projects to assess the accuracy of the tool. Results from the evaluation indicate that Augur provides CIA with high accuracy (average precision 55% and average recall 85%).

"Change Impact Analysis" is the process of determining the consequences of a modification to software. In theory, change impact analysis should be done during software maintenance, to make sure changes do not introduce new bugs. Many approaches and techniques are proposed to help programmers do change impact analysis automatically. However, it is still an open question whether and how programmers do change impact analysis. In this paper, we conducted two studies, one in-depth study and one breadth study. For the in-depth study, we recorded videos of nine professional programmers repairing two bugs for two hours. For the breadth study, we surveyed 35 professional programmers using an online system. We found that the programmers in our studies did static change impact analysis before they made changes by using IDE navigational functionalities, and they did dynamic change impact analysis after they made changes by running the programs. We also found that they did not use any change impact analysis tools.

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.

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.

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.

In change impact analysis, obtaining guidance from automatic tools would be highly desirable since this activity is generally seen as a very difficult program comprehension problem. However, since the notion of an 'impact set' (or dependency set) of a specific change is usually very inexact and context dependent, the approaches and algorithms for computing these sets are also very diverse producing quite different results. The question 'which algorithm finds program dependencies in the most efficient way?' has been preoccupying researchers for a long time, but there are still very few results published on the comparison of the different algorithms to what programmers think are real dependencies. In this work, we report on our experiment conducted with this goal in mind using a compact, easily comprehensible Java experimental software system, simulated program changes, and a group of programmers who were asked to perform impact analysis with the help of different tools and on the basis of their programming experience. We show which algorithms turned out to be the closest to the programmers' opinion in this case study. However, the results also certified that most existing algorithms need to be further enhanced and an effective methodology to use automated tools to support impact analysis still needs to be found.

FCA–CIA: An approach of using FCA to support cross-level change impact analysis for object oriented Java programs

 The paper presents the results of a regional analysis of climate change impacts on Norway spruce growth in the north-western part of Slovakia(Orava region). Radial increment was determined from nine X-tree sample plots established in the forests of natural character in the region. The analysis of PTT radial increment was done on tree disks cut from a height of 1.3 m by measurements of four perpendicular directions corresponding to the cardinal points. It was derived from the tree-ring width measured at breast height (1.3 m) while all the basic principles of tree-ring analyses were observed (transport and borehole treatment, measurements with digital positiometer to the nearest 0.01 mm, synchronisation of the tree-ring diagrams). A dendroclimatic model belongs to the category of empirical models based on the statistical evaluation of empirically derived dependences between the time series of tree-ring parameters and the monthly climatic characteristics. This statistical evaluation is based on a multiple linear regression model. Climatic models were used as basic tools for climatic change prediction. There is a scenario coming from the GCM category, which is derived from the models of Canadian Centre for Climate Modelling and Analysis in Victoria (British Columbia, Canada), used for a solution of this task. It is the latest connected model from the second generation designated CCCM 2000. For the purpose of this study the area averages were modified for the meteorological station Oravská Polhora with the 1951–1980 reference period. The modification includes two climatic characteristics, total monthly precipitation and monthly temperature means. The frequency analysis indicates that 24.4% of trees would react to the assumed climatic change negatively, i.e. by decreasing the increment, and 75.6% of trees would react positively. Most of the reactions are moderately positive. It is to conclude that 14.6% of trees will react to a climatic change significantly in a negative way, the reactions of 34.1% trees are considered to be unchanged and 51.3% of trees should react to the assumed climatic change positively (P = 0.95). It results from the analysis of the climatic change impact that the highest effect on stands situated on the upper forest limit can be expected.

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.

Small changes can have major and nonlocal effects in object oriented languages, due to the extensive use of subtyping and dynamic dispatch. This makes it difficult to understand value flow through a program and complicates life for maintenance programmers. Change impact analysis provides feedback on the semantic impact of a set of program changes.The change impact analysis method presented in this thesis presumes the existence of a suite of regression tests associated with a Java program and access to the original and edited versions of the code. The primary goal of our research is to provide programmers with tool support that can help them understand why a test is suddenly failing after a long editing session by isolating the changes responsible for the failure. The tool analyzes two versions of an application and decomposes their difference into a set of atomic changes. Change impact is then reported in terms of affected tests whose execution behavior may have been modified by the applied changes. For each affected test, it also determines a set of affecting changes that were responsible for the test's modified behavior.The first contribution of this thesis is the demonstration of the utility of the basic change impact analysis framework of [51], by implementing a proof-of-concept prototype, Chianti, and applying it to Daikon, for an experimental validation.The second contribution is the definition and implementation of the dependences between atomic changes. Extensive experiments show that our dependences can help build the intermediate programs automatically in most cases.Another contribution is the heuristics for ranking the atomic changes for fault localization. This thesis proposes a heuristic that ranks method changes that might have affected a failed test, indicating the likelihood that they may have contributed to a test failure. Our results indicate that when a failure is caused by a single method change, our heuristic ranked the failure-inducing change as number 1 or number 2 of all the method changes in 67% of the delegate tests (i.e., representatives of all failing tests).

The documentation of software architecture relations as a kind of traceability information is considered important to help people understand the consequences or ripple-effects of architecture evolution. Traceability information provides a basis for analysing and evaluating software evolution, and consequently, it can be used for tasks like reuse evaluation and improvement throughout the evolution of software. To date, however, none of the published empirical studies on software architecture traceability have examined the validity of these propositions. In this paper, we hypothesize that impact analysis of changes in software architecture can be more efficient when supported by traceability links. To test this hypothesis, we designed two controlled experiments that were conducted to investigate the influence of traceability links on the quantity and quality of retrieved assets during architecture evolution analysis. The results provide statistical evidence that a focus on architecture traceability significantly reduces the quantity of missing and incorrect assets, and increases the overall quality of architecture impact analysis for evolution.

Regulatory authorities of e.g. the automotive, avionic, or railway domain pose high requirements concerning safety assurance activities. One activity known from requirements engineering (RE) is requirements traceability. We propose a model-based methodology to facilitate trace link visualization over several levels of abstraction and different viewpoints. This intuitive visualization concept allows to see (i) the artifact importance using the degree and betweenness centrality measure, and (ii) the impact of an artifact change to other artifacts. Based on this, a novel impact analysis algorithm is proposed.

As the complexity of a software system grows, it becomes increasingly difficult for developers to be aware of all the dependencies that exist between artifacts (e.g., files or methods) of the system. Change impact analysis helps to overcome this problem, as it recommends to a developer relevant source-code artifacts related to her current changes. Association rule mining has shown promise in determining change impact by uncovering relevant patterns in the system's change history. State-of-the-art change impact mining algorithms typically make use of a change history of tens of thousands of transactions. For efficiency, targeted association rule mining focuses on only those transactions potentially relevant to answering a particular query. However, even targeted algorithms must consider the complete set of relevant transactions in the history. This paper presents ATARI, a new adaptive approach to association rule mining that considers a dynamic selection of the relevant transactions. It can be viewed as a further constrained version of targeted association rule mining, in which as few as a single transaction might be considered when determining change impact. Our investigation of adaptive change impact mining empirically studies seven algorithm variants. We show that adaptive algorithms are viable, can be just as applicable as the start-of-the-art complete-history algorithms, and even outperform them for certain queries. However, more important than the direct comparison, our investigation lays necessary groundwork for the future study of adaptive techniques and their application to challenges such as the on-the-fly style of impact analysis that is needed at the GitHub-scale.

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.

User requirements have been changed during development progresses, since they are impossible to define all of software requirements. These requirements change leads to mistakes because the developers cannot completely understand the software structure and behavior, or they cannot discover all parts affected by a change. Therefore, requirement changes have to be managed and assessed to ensure that they are feasible, make economic sense, and contribute to the business needs of the customer organization. We propose requirements change management process on feature-oriented requirements tracing. It is based on value analysis and feature-oriented requirement traceability links. Our approach offers two contributions to the study of requirements change: (1)We define a requirements change tree model to make user requirements change request generalize by feature level. (2)We provide overall process such as change request normalization, change impact analysis, change request alternative design, change request implementation, and change request evaluation. In addition, we especially summarize the results of a case study which is carried out in asset management portal system.