Cognitive complexity as a quantifier of version to version Java-based source code change: An empirical probe

2019 ◽  
Vol 106 ◽  
pp. 31-48 ◽  
Author(s):  
Loveleen Kaur ◽  
Ashutosh Mishra
Keyword(s):  
Cognitive Complexity ◽  
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

scholarly journals How Combinatory Logic Can Limit Computing Complexity

2020 ◽  
Vol 244 ◽  
pp. 01009
Author(s):  
Hugolin Bergier
Keyword(s):  
Cognitive Complexity ◽  
Source Code ◽  
Combinatory Logic ◽  
Model Of Computation ◽  
Reverse Engineer ◽  
Computing Complexity ◽  
Abstract Operator

As computing capabilities are extending, the amount of source code to manage is inevitably becoming larger and more complex. No matter how hard we try, the bewildering complexity of the source code always ends up overwhelming its own creator, to the point of giving the appearance of chaos. As a solution to the cognitive complexity of source code, we are proposing to use the framework of Combinatory Logic to construct complex computational concepts that will provide a model of description of the code that is easy and intuitive to grasp. Combinatory Logic is already known as a model of computation but what we are proposing here is to use a logic of combinators and operators to reverse engineer more and more complex computational concept up from the source code. Through the two key notions of computational concept and abstract operator, we will show that this model offers a new, meaningful and simple way of expressing what the intricate code is about.

Sign in / Sign up

Export Citation Format

Share Document