The studies suggest that bug localization can be improved significantly by leveraging program semantics to bridge gaps between bug report and source code, and capturing Intelligent Relevance Feedback through contextual reasoning, and replicating developers' cognitive debugging practices.
Abstract
Software bugs cost billions annually and consume nearly 50% of developers' time. Despite decades of research, automated bug localization remains challenging according to software practitioners. Traditional approaches (e.g., Information Retrieval) rely on surface-level textual matching, while deep learning methods require extensive training data, limiting their effectiveness and applicability. Recent Large Language Models (LLMs) offer unprecedented capabilities in understanding both natural language and source code, yet their potential for bug localization remains underexplored. In this dissertation work, we hypothesize that through program semantics understanding, contextual reasoning, and developer-inspired debugging practices, bug localization systems can better overcome the limitations of existing approaches. We ask three research questions targeting the hypothesis, conduct three studies leveraging different forms of intelligence, and use them to test our hypothesis. Our studies suggest that bug localization can be improved significantly by (1) leveraging program semantics to bridge gaps between bug report and source code, (2) capturing Intelligent Relevance Feedback through contextual reasoning, and (3) replicating developers' cognitive debugging practices.
Bug localization is the task of automatically identifying the source files responsible for a reported defect. It is a critical step in software maintenance that accelerates defect resolution. Information retrieval (IR) methods are simple and effective at exploiting historical signals such as bug-fixing recency and frequency, but they struggle to bridge the lexical gap between natural-language bug reports and programming-language identifiers. Recent work increasingly leverages pre-trained language models (PLMs) for code to close this gap. However, current PLM-based approaches still rely on a single code encoder that ignores program structure and aggregates function-level signals into file-level representations via uniform pooling. We propose a dual-encoder bug localization (DuaLoc) framework that jointly addresses these limitations. DuaLoc combines two pre-trained language models: UniXcoder for the semantic understanding of source code and GraphCodeBERT for awareness of data-flow structure. Both encoders are fine-tuned with a contrastive objective that shapes the embedding space around the localization task. A bug-report-conditioned attention mechanism then aggregates function embeddings into query-dependent file representations. The resulting neural similarity scores are then fused with classical IR features in a learning-to-rank model. DuaLoc outperforms representative classical and PLM-based baselines across most evaluation settings on a widely used benchmark of six open-source Java projects.
Answering developer questions about a software repository is a critical yet under-explored problem in software engineering. While existing repository understanding methods have advanced the field, they predominantly rely on surface-level code retrieval and lack the ability for deep reasoning over multiple files, complex software architectures, and grounding answers in long-range code dependencies. To address these limitations, we propose DeepRepoQA, a novel question answering (QA) framework for repository-level code understanding. DeepRepoQA builds on an agentic framework where LLM agents find answers through a systematic tree search over the repository structure. A Monte-Carlo Tree Search (MCTS) mechanism is employed to empower agents to dynamically search, navigate, and inspect code, enabling effective multi-hop reasoning over long-range code dependencies. Comprehensive experiments on the SWE-QA benchmark demonstrate substantial performance gains over strong baselines, validating the effectiveness of systematic MCTS-guided exploration for multi-hop repository reasoning.
Wei Peng, Yuling Shi, Yingwei Ma et al.· 0 citations
This analysis covers 2,857 report-test-patch triplets from Defects4J and SWT-Bench using two widely adopted instruction-tuned LLMs from distinct model families and finds that both models exhibit systematic optimism relative to humans and only modest rank agreement, motivating bias-aware evaluation.
Wendkûuni C. Ouédraogo, Yinghua Li, Xueqi Dang et al.· arXiv.org· 0 citations
Two novel contributions are introduced: CodeEval and CodeQual, an open-source execution framework that provides researchers with a ready-to-use evaluation pipeline for evaluating and improving LLMs in software engineering contexts, encompassing both functional correctness assessment and subjective code quality evaluation.
Code translation, as a challenging and fundamental task, is increasingly relying on large language models (LLMs). However, LLMs often give seemingly plausible but fallacious translations, misleading and even deceptive to debugging developers. We propose tHinter, an automated approach that frames translation error localization as a differential testing task. By fuzzing and a novel Bayesian-inspired algorithm that integrates developer heuristics into SBFL, tHinter thoroughly exposes translation errors and effectively pinpoints functionality-twisting errors. We evaluate tHinter in a Python to C++ scenario, a representative and challenging task for migrating high-level logic to performance-critical systems. Experiments show that tHinter achieves the highest F1 in localizing translation errors, outperforming all baselines. When debugging LLM-translated code with human efforts, it averagely reduces 71% lines developers need to review. Furthermore, we provide a comprehensive evaluation reference beyond traditional fault localization metrics. We integrate mixed-factorial user studies, expert validation, and SWOT-based strategic analysis to assess the perceived helpfulness and resilience within the rapidly evolving LLM landscape, offering a methodologically rigorous example for researchers in the context of AI-augmented software engineering.
Shengnan Wu, Xin-Yu Sun, Xin Wang et al.· ACM Transactions on Software...· 0 citations
Localizing concurrent bugs from bug reports alone is challenging due to incomplete information, misleading program-entity mentions, and complex cross-thread interactions, causing existing LLM-based approaches to suffer from unstable reasoning and limited explainability. We propose ConFL, an explainable concurrent fault localization framework that augments LLM reasoning with structured concurrency knowledge. ConFL constructs a Concurrent Knowledge Base (CKB) from source code and performs LLM-guided hierarchical retrieval to progressively narrow the search space from components to interaction-level concurrency contexts. An interaction-level DSL explicitly encodes cross-thread interactions over shared resources, enabling focused reasoning without traversing deep call chains. Experiments on real-world concurrent bugs from eight large-scale Java projects show that ConFL significantly outperforms state-of-the-art IR-based and LLM-based baselines, achieving an MRR of 0.503 and a MAP of 0.486, while remaining robust to noisy bug reports, unseen bugs, and different LLM backbones.
Shuai Shao, Dingbang Wang, Yiming Zeng et al.· 0 citations
We use cookies to run the site and, with your consent, for analytics and to show ads.
See our Cookie Policy.
