Control Flow Graph Embedding Based on Multi-Instance Decomposition for Bug Localization

Huo, Xuan; Li, Ming

doi:10.1609/aaai.v34i04.5844

Cited by 41 publications

(16 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The task of program representation learning is to learn continuous vectors for representing code snippets, such that semantically-similar snippets are mapped to close vectors in the continuous space. The learnt representations, or the program embeddings, can be further used for downstream tasks in programming language processing and software engineering [10,13,24,26,58,63,67]. In the past few years, the availability of massive source code from public repositories has brought a boost to the use of deep learning techniques for program representation learning [1,5,12,40,47,73,74,76].…”

Section: Introductionmentioning

confidence: 99%

A Comparison of Code Embeddings and Beyond

Han,

Wang,

et al. 2021

Preprint

View full text Add to dashboard Cite

Program representation learning is a fundamental task in software engineering applications. With the availability of "big code" and the development of deep learning techniques, various program representation learning models have been proposed to understand the semantic properties of programs and applied on different software engineering tasks. However, no previous study has comprehensively assessed the generalizability of these deep models on different tasks, so that the pros and cons of the models are unclear. In this experience paper, we try to bridge this gap by systemically evaluating the performance of eight program representation learning models on three common tasks, where six models are based on abstract syntax trees and two models are based on plain text of source code. We kindly explain the criteria for selecting the models and tasks, as well as the method for enabling end-to-end learning in each task. The results of performance evaluation show that they perform diversely in each task and the performance of the AST-based models is generally unstable over different tasks. In order to further explain the results, we apply a prediction attribution technique to find what elements are captured by the models and responsible for the predictions in each task. Based on the findings, we discuss some general principles for better capturing the information in the source code, and hope to inspire researchers to improve program representation learning methods for software engineering tasks.

show abstract

Section: Introductionmentioning

confidence: 99%

A Comparison of Code Embeddings and Beyond

Han,

Wang,

et al. 2021

Preprint

View full text Add to dashboard Cite

show abstract

“…There are also approaches taking data flow and control flow extracted from code as structural information, e.g., [17] and [21]. However, these flows do not contain structural information as rich as ASTs [17].…”

Section: Structural Information Of Source Codementioning

confidence: 99%

SPT-Code: Sequence-to-Sequence Pre-Training for Learning Source Code Representations

Niu¹,

Li²,

Ng³

et al. 2022

Preprint

View full text Add to dashboard Cite

Recent years have seen the successful application of large pretrained models to code representation learning, resulting in substantial improvements on many code-related downstream tasks. But there are issues surrounding their application to SE tasks. First, the majority of the pre-trained models focus on pre-training only the encoder of the Transformer. For generation tasks that are addressed using models with the encoder-decoder architecture, however, there is no reason why the decoder should be left out during pre-training. Second, many existing pre-trained models, including state-of-the-art models such as T5-learning, simply reuse the pretraining tasks designed for natural languages. Moreover, to learn the natural language description of source code needed eventually for code-related tasks such as code summarization, existing pretraining tasks require a bilingual corpus composed of source code and the associated natural language description, which severely limits the amount of data for pre-training. To this end, we propose SPT-Code, a sequence-to-sequence pre-trained model for source code. In order to pre-train SPT-Code in a sequence-to-sequence manner and address the aforementioned weaknesses associated with existing pre-training tasks, we introduce three pre-training tasks that are specifically designed to enable SPT-Code to learn knowledge of source code, the corresponding code structure, as well as a natural language description of the code without relying on any bilingual corpus, and eventually exploit these three sources of information when it is applied to downstream tasks. Experimental

show abstract

“…However, manual fault localization is challenging, tedious, and time-consuming [33], especially for inexperienced developers in debugging complex programs developed by others. To this end, a few automated fault localization techniques (called AFL for short) have been proposed [11,29,45]. Such novel approaches have significantly reduced the cost of fault localization, thus also reduced the cost of software debugging that often takes up to 80% of the total software cost [33].…”

Section: Introductionmentioning

confidence: 99%

A Hybrid Approach to Fine-grained Automated Fault Localization

Li,

Liu

2021

Preprint

View full text Add to dashboard Cite

Fault localization is to identify faulty source code. It could be done on various granularities, e.g., classes, methods, and statements. Most of the automated fault localization (AFL) approaches are coarsegrained because it is challenging to accurately locate fine-grained faulty software elements, e.g., statements. However, some automated approaches, e.g., automated program repair (APR), require fine-grained fault localization. As a result, such APR approaches often leverage the traditional spectrum-based fault localization (SBFL) techniques although more advanced coarse-grained AFL approaches have been proposed recently. SBFL, based on dynamic execution of test cases only, is simple, intuitive, and generic (working on various granularities). However, its accuracy deserves significant improvement. To this end, in this paper, we propose a hybrid fine-grained AFL approach based on both dynamic spectrums and static statement types. The rationale of the approach is that some types of statements are significantly more/less error-prone than others, and thus statement types could be exploited for fault localization. On a crop of faulty programs, we compute the error-proneness for each type of statements, and assign priorities to special statement types that are steadily more/less error-prone than others. For a given faulty program under test, we first leverage traditional spectrum-based fault localization algorithm to identify all suspicious statements and to compute their suspicious scores. For each of the resulting suspicious statements, we retrieve its statement type as well as the special priority associated with the type. The final suspicious score is the product of the SBFL suspicious score and the priority assigned to the statement type. A significant advantage of the approach is that it is simple and intuitive, making it efficient and easy to interpret/implement. We evaluate the proposed approach on widely used benchmark Defects4J. The evaluation results suggest that the proposed approach outperforms widely used SBFL, reducing the absolute waste effort (AWE) by 9.3% on average.

show abstract

Control Flow Graph Embedding Based on Multi-Instance Decomposition for Bug Localization

Cited by 41 publications

References 21 publications

A Comparison of Code Embeddings and Beyond

A Comparison of Code Embeddings and Beyond

SPT-Code: Sequence-to-Sequence Pre-Training for Learning Source Code Representations

A Hybrid Approach to Fine-grained Automated Fault Localization

Contact Info

Product

Resources

About