Discovering common bug‐fix patterns: A large‐scale observational study

Campos, Eduardo Cunha; Maia, Marcelo de Almeida

doi:10.1002/smr.2173

Cited by 8 publications

(7 citation statements)

References 78 publications

(197 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Nguyen et al used Jsync to track cloned code in the software evolution process [28]. Moreover, many studies used GumTree to analyze code patterns of changes such as bug-fixing changes [5], [13], [18], [21], [23], [29], logging changes [22] and changes to online code examples [34]. Also, prior work trained models based on the edit actions of changes that are calculated using GumTree [7], [15], [24], [31], [32].…”

Section: B Use Of Ast Mapping Algorithmsmentioning

confidence: 99%

A Differential Testing Approach for Evaluating Abstract Syntax Tree Mapping Algorithms

Fan

Xia

et al. 2021

2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE)

View full text Add to dashboard Cite

syntax tree (AST) mapping algorithms are widely used to analyze changes in source code. Despite the foundational role of AST mapping algorithms, little effort has been made to evaluate the accuracy of AST mapping algorithms, i.e., the extent to which an algorithm captures the evolution of code. We observe that a program element often has only one best-mapped program element. Based on this observation, we propose a hierarchical approach to automatically compare the similarity of mapped statements and tokens by different algorithms. By performing the comparison, we determine if each of the compared algorithms generates inaccurate mappings for a statement or its tokens. We invite 12 external experts to determine if three commonly used AST mapping algorithms generate accurate mappings for a statement and its tokens for 200 statements. Based on the experts' feedback, we observe that our approach achieves a precision of 0.98-1.00 and a recall of 0.65-0.75. Furthermore, we conduct a large-scale study with a dataset of ten Java projects containing a total of 263,165 file revisions. Our approach determines that GumTree, MTDiff and IJM generate inaccurate mappings for 20%-29%, 25%-36% and 21%-30% of the file revisions, respectively. Our experimental results show that state-of-the-art AST mapping algorithms still need improvements.

show abstract

Section: B Use Of Ast Mapping Algorithmsmentioning

confidence: 99%

A Differential Testing Approach for Evaluating Abstract Syntax Tree Mapping Algorithms

Fan

Xia

et al. 2021

2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE)

View full text Add to dashboard Cite

show abstract

“…[ 1 ] proposed the definition and the corresponding fix patterns for Java language. However, automated inferring fix patterns from fix changes in developer code bases [ 4 ‐ 8 ] requires identification and collection of a large number of relevant bug fixes. Hence, patterns must be precise and diverse to actually guarantee the repair effect.…”

Section: Introductionmentioning

confidence: 99%

Are Similar Bugs Fixed with Similar Change Operations? An Empirical Study

Xuanrui

Sun

et al. 2021

Chinese J of Electronics

View full text Add to dashboard Cite

Fine‐grained change operations can help software developers fix software bugs more accurately and efficiently. However, the current fine‐grained change operations are only used in specific fixing process, such as fixing of If statement. In this paper, we conducted an empirical study to explore the fine‐grained change operations for bug fixing. Based on the Mozilla bug data, we examined whether similar bugs are fixed with similar change operations. The results show that: First, for bug reports with similar descriptions or bug‐fix commits with similar descriptions, their corresponding fine‐grained change operations are not related; Second, in the case where the descriptions of both bug reports and bug‐fix commits are similar, the fine‐grained change operations in patch code are not related; Third, by classifying bug reports, we find that the change operations in the same bug report category are similar; Finally, by analyzing the fine‐grained change operations for each bug, we present some combined patterns that are often used together.

show abstract

“…Other earlier studies, on the other hand, have examined code change patterns for non-adaptive software evolution at a high level of details. Campos et al [20] performed a large-scale study to explore the repetitiveness of several bug-fix patterns in history repositories of five Java projects. The study found the prevalence of five bug-fix patterns such as addition of if precondition check and method call with different number of parameters.…”

Section: Introductionmentioning

confidence: 99%

“…The study found the prevalence of five bug-fix patterns such as addition of if precondition check and method call with different number of parameters. Actually, the study that was undertaken in [20] focused on a set of patterns that were originally recognized by Pan et al [21]. Pan and other authors manually classified fixing changes into several patterns based on the syntax of the change.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

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

Meqdadi¹,

Aljawarneh²

2020

IJECE

View full text Add to dashboard Cite

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

show abstract

Discovering common bug‐fix patterns: A large‐scale observational study

Cited by 8 publications

References 78 publications

A Differential Testing Approach for Evaluating Abstract Syntax Tree Mapping Algorithms

A Differential Testing Approach for Evaluating Abstract Syntax Tree Mapping Algorithms

Are Similar Bugs Fixed with Similar Change Operations? An Empirical Study

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

Contact Info

Product

Resources

About