Search arXiv⌕ Search

arXiv · 2610.02995

BISCEPTER: Probability-Driven Bisection for Large-Scale System Software

Abstract

Identifying the bug-inducing commit (BIC) is a fundamental step in regression debugging and a key input to emerging BIC-aware fault-localization pipelines. In practice, BICs are commonly obtained with bisection. Standard bisection selects the median commit of the remaining good-bad interval, thereby balancing commit count. This strategy is optimal under the assumption that each commit is equally likely to be the BIC. This paper shows that this assumption does not match real-world BIC histories. We construct a dataset of 8,172 bug reports from GCC, the Linux kernel, and MariaDB. We find a strong temporal skew: across the studied systems, 50% of BICs lie within the most recent 0.69% of the report-time commit history. Motivated by this observation, we introduce BISCEPTER, a probability-driven bisection approach that uses historical BIC latency as a lightweight prior. Instead of selecting pivots that split the number of remaining commits, BISCEPTER selects weighted-median pivots that split estimated BIC probability mass, while preserving the same good-bad oracle and interface as standard bisection. We evaluate BISCEPTER on three large-scale systems. The evaluation results show that BISCEPTER reduces bisection iterations by 25.75% on average (up to 55.55%) compared with standard median bisection, while improving over the baseline in 91.26% of test cases. Robustness experiments further demonstrate that the benefit remains stable under noisy historical data. We expect that our research can effectively save effort in debugging software in practice and, more broadly, benefit future software engineering research by bringing insights about BIC distribution.

Explore related subjects

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Mingyan Gao, Celine Wüst, Zuming Jiang, Zhendong Su. 2026-10-02. BISCEPTER: Probability-Driven Bisection for Large-Scale System Software. https://arxiv.org/abs/2610.02995

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

CodePori: Large-Scale System for Autonomous Software Development Using Multi-Agent Technology

Existing Large Language Model (LLM)-based multi-agent systems are capable of executing tasks and providing data-driven recommendations, thereby enabling automation and decision support that assist practitioners in software development. However, existing studies have evaluated agents' performance on benchmark datasets, offering only binary pass-or-fail results, which provide limited insight into their practical applicability. There remains a lack of empirical research examining the potential and limitations of LLM-based agents in addressing challenging, real-world tasks, such as automated code generation for software systems. To this end, this study conducted a survey to empirically investigate the potential of LLM-based agents in software development, with participants evaluating the agents' performance in autonomous software development tasks. We employed a two-phase approach comprising (i) the development of a multi-agent system, CodePori, to automate code generation, and (ii) a survey-based evaluation to assess agent performance and explore its practical applicability to software development. Our results highlight that, while LLM-based multi-agent systems show potential for autonomous code generation, their successful integration requires addressing specific challenges (e.g., short-term memory limitations, hallucinations, and code smells) and incorporating a practitioner-centric perspective. The study also highlights the need to move beyond standard benchmarks for evaluating real-world applicability and identifies new opportunities for broader adoption in both industry and academia.

cs.SE↗

SCLA: Automated Smart Contract Summarization via LLMs and Control Flow Prompt

Smart contract code summarization is crucial for efficient maintenance and vulnerability mitigation. While many studies use Large Language Models (LLMs) for summarization, their performance still falls short compared to fine-tuned models like CodeT5+ and CodeBERT. Some approaches combine LLMs with data flow analysis but fail to fully capture the hierarchy and control structures of the code, leading to information loss and degraded summarization quality. We propose SCLA, an LLM-based method that enhances summarization by integrating a Control Flow Graph (CFG) and semantic facts from the code's control flow into a semantically enriched prompt. SCLA uses a control flow extraction algorithm to derive control flows from semantic nodes in the Abstract Syntax Tree (AST) and constructs the corresponding CFG. Code semantic facts refer to both explicit and implicit information within the AST that is relevant to smart contracts. This method enables LLMs to better capture the structural and contextual dependencies of the code. We validate the effectiveness of SCLA through comprehensive experiments on a dataset of 40,000 real-world smart contracts. The experiment shows that SCLA significantly improves summarization quality, outperforming the SOTA baselines with improvements of 26.7%, 23.2%, 16.7%, and 14.7% in BLEU-4, METEOR, ROUGE-L, and BLEURT scores, respectively.

cs.SE↗

Generalizing GUI Tests into Voice Assistant Capabilities through Behavioral Variation Discovery

Voice Assistants (VAs) and agentic assistants increasingly support app-specific tasks through natural-language interaction. However, these capabilities still require app-specific execution logic. Existing approaches either derive this logic dynamically from GUI context, require developers to define app functions, or reuse GUI tests that remain tied to a single concrete task instance. To address this limitation, we propose Test2VA, an approach that generalizes existing GUI tests into reusable app-specific VA capabilities. Test2VA adopts mutation as an exploration mechanism to discover plausible behavioral variations of test interactions, dynamically validates these variations on the running application with adapted assertions, and generalizes the validated task instances into capabilities that preserve the common task pattern while supporting broader user requests. We evaluate Test2VA on 100 Espresso GUI tests from ten real-world Android applications, covering 407 GUI events and 115 assertions. Across 396 reproduced events, Test2VA reduces 18,999 available mutation candidates to 1,272 predicted candidates before dynamic validation, identifies mutable events with 83.33% precision, 87.79% recall, and an 85.50% F1 score, and generates 65 VA capabilities. Among them, 64 execute successfully and 56 satisfy our capability quality requirements. We further analyze unsuccessful and low-quality cases to identify common causes of failure. Finally, we conduct a user study with 18 participants and 150 task observations to evaluate the generated capabilities in real app tasks. The VA successfully completes 123 observations, achieving an overall success rate of 82.0%, and 16 of 18 participants rate the VA as useful or very useful. These results show the feasibility of generalizing test-derived task logic into reusable app-specific VA capabilities.

cs.SE↗