Predicting Build Co-changes with Source Code Change and Commit Categories

2016 ◽  
Author(s):  
Christian Macho ◽  
Shane McIntosh ◽  
Martin Pinzger
Keyword(s):  
Source Code ◽  
Code Change

CODE-CHANGE IMPACT ANALYSIS USING COUNTERFACTUALS: THEORY AND IMPLEMENTATION

2013 ◽  
Vol 23 (10) ◽  
pp. 1459-1486
Author(s):  
MANUEL PERALTA ◽  
SUPRATIK MUKHOPADHYAY
Keyword(s):  
Static Analysis ◽  
Theorem Proving ◽  
Program Analysis ◽  
Impact Analysis ◽  
Source Code ◽  
Analysis Framework ◽  
Change Impact Analysis ◽  
Code Change ◽  
Change Impact ◽  
Automated Tool

This article shows a novel program analysis framework based on Lewis' theory of counterfactuals. Using this framework we are capable of performing change-impact static analysis on a program's source code. In other words, we are able to prove the properties induced by changes to a given program before applying these changes. Our contribution is two-fold; we show how to use Lewis' logic of counterfactuals to prove that proposed changes to a program preserve its correctness. We report the development of an automated tool based on resolution and theorem proving for performing code change-impact analysis.

scholarly journals A study of code change patterns for adaptive maintenance with AST analysis

2020 ◽  
Vol 10 (3) ◽  
pp. 2719
Author(s):  
Omar Meqdadi ◽  
Shadi Aljawarneh
Keyword(s):  
Open Source ◽  
Software Evolution ◽  
Source Code ◽  
Transformation Rule ◽  
Primary Concern ◽  
Adaptive Changes ◽  
Code Change ◽  
History Of ◽  
Code Changes ◽  
Open Source Systems

Example-based transformational approaches to automate adaptive maintenance changes plays an important role in software research. One primary concern of those approaches is that a set of good qualified real examples of adaptive changes previously made in the history must be identified, or otherwise the adoption of such approaches will be put in question. Unfortunately, there is rarely enough detail to clearly direct transformation rule developers to overcome the barrier of finding qualified examples for adaptive changes. This work explores the histories of several open source systems to study the repetitiveness of adaptive changes in software evolution, and hence recognizing the source code change patterns that are strongly related with the adaptive maintenance. We collected the adaptive commits from the history of numerous open source systems, then we obtained the repetitiveness frequencies of source code changes based on the analysis of Abstract Syntax Tree (AST) edit actions within an adaptive commit. Using the prevalence of the most common adaptive changes, we suggested a set of change patterns that seem correlated with adaptive maintenance. It is observed that 76.93% of the undertaken adaptive changes were represented by 12 AST code differences. Moreover, only 9 change patterns covered 64.69% to 76.58% of the total adaptive change hunks in the examined projects. The most common individual patterns are related to initializing objects and method calls changes. A correlation analysis on examined projects shows that they have very similar frequencies of the patterns correlated with adaptive changes. The observed repeated adaptive changes could be useful examples for the construction of transformation approaches

scholarly journals Applying Information Measure for Predicting Release Time of Open Source Software

2017 ◽  
Vol 15 (1) ◽  
pp. 29-39
Author(s):  
Talat PARVEEN ◽  
Hari Darshan ARORA
Keyword(s):  
Regression Model ◽  
Open Source ◽  
Open Source Software ◽  
Goodness Of Fit ◽  
Source Code ◽  
Release Time ◽  
Entropy Measure ◽  
Frequent Change ◽  
Code Change ◽  
Code Changes

Open Source Software (OSS) is updated regularly to meet the requirements posed by the customers. The source code of OSS undergoes frequent change to diffuse new features and update existing features in the system, providing a user friendly interface. The source code changes for fixing bugs and meeting user end requirements again affects the complexity of the code change and creates bugs in the software which are accountable to the next release of software. In this paper, the complexity of code changes in various Bugzilla open source software releases, from version 2.0 on 19th Sep, 1998, to 5.0.1 on 10th Sep, 2015, bugs in each software version release, and the time of release of each software version are considered, and the data used to predict the next release time. The Shannon entropy measure is used to quantify the code change process in terms of entropy for each software release. Observed code changes are utilized to quantify them into entropy units and are further used to predict the next release time. A neural network-based regression model is used to predict the next release time. The performance is compared with the R measure calculated using the multi linear regression model, and a goodness of fit curve is produced.

Identifying Implicit Architectural Dependencies Using Measures of Source Code Change Waves

2013 ◽  
Author(s):  
Miroslaw Staron ◽  
Wilhelm Meding ◽  
Christoffer Hoglund ◽  
Peter Eriksson ◽  
Jimmy Nilsson ◽  
...  
Keyword(s):  
Source Code ◽  
Code Change

A Source Code Change Impact Analysis Algorithm for Iterative Software Development

2012 ◽  
Vol 4 (4) ◽  
pp. 60-75
Author(s):  
Jerod W. Wilkerson
Keyword(s):  
Software Development ◽  
Impact Analysis ◽  
Source Code ◽  
Development Projects ◽  
Change Impact Analysis ◽  
Analysis Algorithm ◽  
Code Change ◽  
Change Impact ◽  
Program Entry ◽  
Iterative Software

CHA-AS is a source code change impact analysis algorithm for Java programs. CHA-AS differs from other algorithms in that it does not require the program versions it compares to be whole programs with a well-defined program entry point. The need for such an algorithm is evident in iterative software development projects and projects involving the development of code libraries and frameworks—all of which may not have a well-defined program entry point at the time when change impact analysis needs to be performed. The CHA-AS algorithm supports the development of Decision Support Systems for software development managers and programmers working on iterative software development projects, or projects to develop source code libraries and frameworks. This paper describes the CHA-AS algorithm and demonstrates it to be efficient and effective in calculating source code change impact.

Sign in / Sign up

Export Citation Format

Share Document