Tootfinder

Massive Extremely High-Velocity Outflow in the Quasar J164653.72 243942.2
Paola Rodr\'iguez Hidalgo, Hyunseop Choi, Patrick B. Hall, Karen M. Leighly, Liliana Flores, Mikel M. Charles, Cora DeFrancesco, Julie Hlavacek-Larrondo, Laurence Perreault-Levasseur Laurence Perreault-Levasseur
https://arxiv.org/abs/2508.14221

Massive Extremely High-Velocity Outflow in the Quasar J164653.72+243942.2
We present the analysis of one of the most extreme quasar outflows found to date in our survey of extremely high velocity outflows (EHVO). J164653.72+243942.2 (z ~ 3.04) shows variable CIV1548,1551 absorption at speeds larger than 0.1c, accompanied by SiIV, NV and Lya, and disappearing absorption at lower speeds. We perform absorption measurements using the Apparent Optical Depth method and SimBAL. We find the absorption to be very broad (Δv ~35,100 km/s in the first epoch and ~13,000 km/s in …

Long-term simultaneous 2.25/8.60~GHz monitoring of the newly-discovered repeating FRB~20240114A
Xiao-Wei Wang, Zhen Yan, Zhi-Qiang Shen, Ke-Jia Lee, Ya-Jun Wu, Rong-Bing Zhao, Jie Liu, Rui Wang, Kuo Liu, Yuan-Chuan Zou, Zhi-Peng Hang, Chu-Yuan Zhang, Fan Yang, Zhen-Long Liao, Yang-Yang Lin
https://arxiv.org/abs/2508.15615

Long-term simultaneous 2.25/8.60~GHz monitoring of the newly-discovered repeating FRB~20240114A
We report on the simultaneous monitoring of the repeating fast radio burst (FRB) 20240114A at 2.25 and 8.60~GHz, conducted 66 times between 2024 January 29 and 2025 February 15 with the Shanghai Tianma Radio Telescope (TMRT). In about 180 hours of observation, we detected 155 bursts at 2.25~GHz above a fluence threshold of 0.72~Jy~ms, but none at 8.60~GHz above a fluence threshold of 0.27~Jy~ms. FRB~20240114A exhibited frequency-dependent activity, as evidenced by the non-detections in 14.3 hou…

Replaced article(s) found for astro-ph.EP. https://arxiv.org/list/astro-ph.EP/new
[1/1]:
- The GAPS Programme at TNG LXVIII. Characterization of the outer substellar companion around HD 72...
A. Ruggieri, et al.

This https://arxiv.org/abs/2502.06994 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

SyncMind: Measuring Agent Out-of-Sync Recovery in Collaborative Software Engineering
Software engineering (SE) is increasingly collaborative, with developers working together on shared complex codebases. Effective collaboration in shared environments requires participants -- whether humans or AI agents -- to stay on the same page as their environment evolves. When a collaborator's understanding diverges from the current state -- what we term the out-of-sync challenge -- the collaborator's actions may fail, leading to integration issues. In this work, we introduce SyncMind, a fr…

Entanglement witnesses for stabilizer states and subspaces beyond qubits
Jakub Szczepaniak, Owidiusz Makuta, Remigiusz Augusiak
https://arxiv.org/abs/2508.13734 https://

Entanglement witnesses for stabilizer states and subspaces beyond qubits
Genuine multipartite entanglement is arguably the most valuable form of entanglement in the multipartite case, with applications, for instance, in quantum metrology. In order to detect that form of entanglement in multipartite quantum states, one typically uses entanglement witnesses. The aim of this paper is to generalize the results of [G. Tóth and O. Gühne, Phys. Rev. A \textbf{72}, 022340 (2005)] in order to provide a construction of witnesses of genuine multipartite entanglement tailored…

Replaced article(s) found for cs.SE. https://arxiv.org/list/cs.SE/new/
[1/1]:
An Empirical Evaluation of Pre-trained Large Language Models for Repairing Declarative Formal Spe...

Variations in Volatile-Driven Activity of Comet C/2017 K2 (PanSTARRS) Revealed by Long-Term Multi-Wavelength Observations
S. Hmiddouch, E. Jehin, M. Lippi, M. Vander Donckt, K. Aravind, D. Hutsem\'ekers, J. Manfroid, A. Jabiri, Y. Moulane, Z. Benkhaldoun
https://arxiv.org/abs/2507.13451

Variations in Volatile-Driven Activity of Comet C/2017 K2 (PanSTARRS) Revealed by Long-Term Multi-Wavelength Observations
Context. A comprehensive study of comets over a wide heliocentric distance range helps us understand the physical processes driving their activity and reveals compositional differences across dynamical groups. C/2017 K2 (PANSTARRS) is a Dynamically New Oort Cloud comet (DNC) that showed activity as far as 23.75 au and displayed a CO-rich coma at 6.72 au, making it a key object to investigate pre- and post-perihelion behavior. Aims. We aim to study the long-term activity evolution and chemical…

MLLM-Based UI2Code Automation Guided by UI Layout Information
Fan Wu, Cuiyun Gao, Shuqing Li, Xin-Cheng Wen, Qing Liao
https://arxiv.org/abs/2506.10376 htt…

MLLM-Based UI2Code Automation Guided by UI Layout Information
Converting user interfaces into code (UI2Code) is a crucial step in website development, which is time-consuming and labor-intensive. The automation of UI2Code is essential to streamline this task, beneficial for improving the development efficiency. There exist deep learning-based methods for the task; however, they heavily rely on a large amount of labeled training data and struggle with generalizing to real-world, unseen web page designs. The advent of Multimodal Large Language Models (MLLMs…

This https://arxiv.org/abs/2506.02954 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Towards More Effective Fault Detection in LLM-Based Unit Test Generation
Unit tests play a vital role in uncovering potential faults in software. While tools like EvoSuite focus on maximizing code coverage, recent advances in large language models (LLMs) have shifted attention toward LLM-based test generation. However, code coverage metrics -- such as line and branch coverage -- remain overly emphasized in reported research, despite being weak indicators of a test suite's fault-detection capability. In contrast, \textit{mutation score} offers a more reliable and str…

This https://arxiv.org/abs/2506.02943 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

A Multi-agent LLM-based JUit Test Generation with Strong Oracles
Unit testing plays a critical role in ensuring software correctness. However, writing unit tests manually is laborious, especially for strong typed languages like Java, motivating the need for automated approaches. Traditional methods primarily rely on search-based or randomized algorithms to generate tests that achieve high code coverage and produce regression oracles, which are derived from the program's current behavior rather than its intended functionality. Recent advances in large languag…

This https://arxiv.org/abs/2506.02791 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Rethinking the effects of data contamination in Code Intelligence
In recent years, code intelligence has gained increasing importance in the field of automated software engineering. Meanwhile, the widespread adoption of Pretrained Language Models (PLMs) and Large Language Models (LLMs) has raised concerns regarding data contamination and its potential impact on model performance evaluation. This paper presents a systematic empirical study to investigate the fine-grained data contamination on code intelligence tasks. Our study involves diverse representative P…

This https://arxiv.org/abs/2505.23674 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Quantum-Based Software Engineering
Quantum computing has demonstrated potential for solving computationally intensive problems more efficiently than classical methods. Many software engineering tasks, such as test case selection, static analysis, code clone detection, and defect prediction, involve complex optimization, search, or classification, making them candidates for quantum enhancement. In this paper, we propose Quantum-Based Software Engineering (QBSE), a potential research direction for applying quantum computing to cla…

This https://arxiv.org/abs/2505.14759 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

LEANCODE: Understanding Models Better for Code Simplification of Pre-trained Large Language Models
Large Language Models for code often entail significant computational complexity, which grows significantly with the length of the input code sequence. We propose LeanCode for code simplification to reduce training and prediction time, leveraging code contexts in utilizing attention scores to represent the tokens' importance. We advocate for the selective removal of tokens based on the average context-aware attention scores rather than average scores across all inputs. LeanCode uses the attenti…

This https://arxiv.org/abs/2505.13229 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

PARF: An Adaptive Abstraction-Strategy Tuner for Static Analysis
We launch Parf - a toolkit for adaptively tuning abstraction strategies of static program analyzers in a fully automated manner. Parf models various types of external parameters (encoding abstraction strategies) as random variables subject to probability distributions over latticed parameter spaces. It incrementally refines the probability distributions based on accumulated intermediate results generated by repeatedly sampling and analyzing, thereby ultimately yielding a set of highly accurate …

This https://arxiv.org/abs/2505.11205 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

IssueCourier: Multi-Relational Heterogeneous Temporal Graph Neural Network for Open-Source Issue Assignment
Issue assignment plays a critical role in open-source software (OSS) maintenance, which involves recommending the most suitable developers to address the reported issues. Given the high volume of issue reports in large-scale projects, manually assigning issues is tedious and costly. Previous studies have proposed automated issue assignment approaches that primarily focus on modeling issue report textual information, developers' expertise, or interactions between issues and developers based on h…

This https://arxiv.org/abs/2505.07270 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Automated Repair of Ambiguous Natural Language Requirements
The widespread adoption of large language models (LLMs) in software engineering has amplified the role of natural language (NL). The inherent ambiguity of NL threatens software quality, because ambiguous requirements may lead to faulty program generation. The complexity of ambiguity detection and resolution motivates us to introduce automated repair of ambiguous NL requirements, which we approach by reducing code generation uncertainty and aligning NL with input-output examples. Repairing ambig…

This https://arxiv.org/abs/2503.02610 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Monitoring Continuous Integration Practices in Industry: A Case Study
In this paper, we study the benefits and challenges of monitoring Continuous Integration (CI) practices in software development. Our aim is to evaluate the impact of monitoring seven CI practices in industry using three organizations in Brazil as case studies. We developed a tool for monitoring CI practices and conducted a multiple case study, applying a mixed-methods strategy. We combined surveys, interviews, log data, and repositories data from software projects and their CI services.We gauge…

This https://arxiv.org/abs/2412.06430 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Subgraph-Oriented Testing for Deep Learning Libraries
Deep Learning (DL) libraries, such as PyTorch, are widely used for building and deploying DL models on various hardware platforms. Meanwhile, they are found to contain bugs that lead to incorrect calculation results and cause issues like non-convergence training and inaccurate prediction of DL models. Thus, many efforts have been made to test DL libraries and reveal bugs. However, existing DL library testing methods manifest limitations: model-level testing methods cause complexity in fault loc…

This https://arxiv.org/abs/2410.08911 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Test-driven Software Experimentation with LASSO: an LLM Prompt Benchmarking Example
Empirical software engineering faces a critical gap: the lack of standardized tools for rapid development and execution of Test-Driven Software Experiments (TDSEs) -- that is, experiments that involve the execution of software subjects and the observation and analysis of their "de facto" run-time behavior. In this paper we present a general-purpose analysis platform called LASSO that provides a minimal set of domain-specific languages and data structures to conduct TDSEs. By empowering users wi…

This https://arxiv.org/abs/2409.12519 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Multi-View Adaptive Contrastive Learning for Information Retrieval Based Fault Localization
Most studies focused on information retrieval-based techniques for fault localization, which built representations for bug reports and source code files and matched their semantic vectors through similarity measurement. However, such approaches often ignore some useful information that might help improve localization performance, such as 1) the interaction relationship between bug reports and source code files; 2) the similarity relationship between bug reports; and 3) the co-citation relations…

This https://arxiv.org/abs/2409.05101 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

On the Need to Monitor Continuous Integration Practices -- An Empirical Study
Continuous Integration (CI) encompasses a set of widely adopted practices that enhance software development. However, there are indications that developers may not adequately monitor CI practices. Hence, this paper explores developers' perceptions regarding the monitoring CI practices. To achieve this, we first perform a Document Analysis to assess developers' expressed need for practice monitoring in pull requests comments generated by developers during the development process. After that, we …

This https://arxiv.org/abs/2408.09568 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

MergeRepair: An Exploratory Study on Merging Task-Specific Adapters in Code LLMs for Automated Program Repair
Large Language Models (LLMs) have shown high capabilities in several software development-related tasks such as program repair, documentation, code refactoring, debugging, and testing. However, training these models requires massive amount of data and significant computational resources. Adapters are specialized, small modules designed for parameter efficient fine-tuning of LLMs for specific tasks, domains, or applications without requiring extensive retraining of the entire model. These adapte…

This https://arxiv.org/abs/2312.17294 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

Enhancing Open-Domain Task-Solving Capability of LLMs via Autonomous Tool Integration from GitHub
Large Language Models (LLMs) excel in traditional natural language processing tasks but struggle with problems that require complex domain-specific calculations or simulations. While equipping LLMs with external tools to build LLM-based agents can enhance their capabilities, existing approaches lack the flexibility to address diverse and ever-evolving user queries in open domains. Currently, there is also no existing dataset that evaluates LLMs on open-domain knowledge that requires tools to so…

Replaced article(s) found for cs.SE. https://arxiv.org/list/cs.SE/new/
[1/1]:
How Do Users Revise Architectural Related Questions on Stack Overflow: An Empirical Study

SWE-Factory: Your Automated Factory for Issue Resolution Training Data and Evaluation Benchmarks
Lianghong Guo, Yanlin Wang, Caihua Li, Pengyu Yang, Jiachi Chen, Wei Tao, Yingtian Zou, Duyu Tang, Zibin Zheng
https://arxiv.org/abs/2506.10954

SWE-Factory: Your Automated Factory for Issue Resolution Training Data and Evaluation Benchmarks
Constructing large-scale datasets for the GitHub issue resolution task is crucial for both training and evaluating the software engineering capabilities of Large Language Models (LLMs). However, the traditional process for creating such benchmarks is notoriously challenging and labor-intensive, particularly in the stages of setting up evaluation environments, grading test outcomes, and validating task instances. In this paper, we propose SWE-Factory, an automated pipeline designed to address th…

MultiCoSim: A Python-based Multi-Fidelity Co-Simulation Framework
Quinn Thibeault, Giulia Pedrielli
https://arxiv.org/abs/2506.10869 https://

MultiCoSim: A Python-based Multi-Fidelity Co-Simulation Framework
Simulation is a foundational tool for the analysis and testing of cyber-physical systems (CPS), underpinning activities such as algorithm development, runtime monitoring, and system verification. As CPS grow in complexity and scale, particularly in safety-critical and learning-enabled settings, accurate analysis and synthesis increasingly rely on the rapid use of simulation experiments. Because CPS inherently integrate hardware, software, and physical processes, simulation platforms must suppor…

Evaluating Large Language Models on Non-Code Software Engineering Tasks
Fabian C. Pe\~na, Steffen Herbold
https://arxiv.org/abs/2506.10833 https://

Evaluating Large Language Models on Non-Code Software Engineering Tasks
Large Language Models (LLMs) have demonstrated remarkable capabilities in code understanding and generation; however, their effectiveness on non-code Software Engineering (SE) tasks remains underexplored. We present the first comprehensive benchmark, which we name `Software Engineering Language Understanding' (SELU), for evaluating LLMs on 17 non-code tasks, spanning from identifying whether a requirement is functional or non-functional to estimating the effort and complexity of backlog items. …

Solving Package Management via Hypergraph Dependency Resolution
Ryan Gibb, Patrick Ferris, David Allsopp, Michael Winston Dales, Mark Elvers, Thomas Gazagnaire, Sadiq Jaffer, Thomas Leonard, Jon Ludlam, Anil Madhavapeddy
https://arxiv.org/abs/2506.10803

Solving Package Management via Hypergraph Dependency Resolution
Package managers are everywhere, with seemingly every language and operating system implementing their own solution. The lack of interoperability between these systems means that multi-lingual projects are unable to express precise dependencies across language ecosystems, and external system and hardware dependencies are typically implicit and unversioned. We define HyperRes, a formal system for describing versioned dependency resolution using a hypergraph that is expressive enough to model man…

What Users Value and Critique: Large-Scale Analysis of User Feedback on AI-Powered Mobile Apps
Vinaik Chhetri, Krishna Upadhyay, A. B. Siddique, Umar Farooq
https://arxiv.org/abs/2506.10785

What Users Value and Critique: Large-Scale Analysis of User Feedback on AI-Powered Mobile Apps
Artificial Intelligence (AI)-powered features have rapidly proliferated across mobile apps in various domains, including productivity, education, entertainment, and creativity. However, how users perceive, evaluate, and critique these AI features remains largely unexplored, primarily due to the overwhelming volume of user feedback. In this work, we present the first comprehensive, large-scale study of user feedback on AI-powered mobile apps, leveraging a curated dataset of 292 AI-driven apps ac…

From Tea Leaves to System Maps: Context-awareness in Monitoring Operational Machine Learning Models
Joran Leest, Claudia Raibulet, Patricia Lago, Ilias Gerostathopoulos
https://arxiv.org/abs/2506.10770

From Tea Leaves to System Maps: Context-awareness in Monitoring Operational Machine Learning Models
Machine learning (ML) models in production do not fail due to statistical anomalies in their input data; they fail due to contextual misalignment -- when their environment deviates from training assumptions, leading to unreliable predictions. Effective ML monitoring requires rich contextual information to move beyond detecting statistical shifts toward meaningful alerts and systematic root-cause analysis. Yet, surprisingly, despite extensive research in ML monitoring and related disciplines (dr…

Formalising Software Requirements using Large Language Models
Arshad Beg, Diarmuid O'Donoghue, Rosemary Monahan
https://arxiv.org/abs/2506.10704 https:…

Formalising Software Requirements using Large Language Models
This paper is a brief introduction to our recently initiated project named VERIFAI: Traceability and verification of natural language requirements. The project addresses the challenges in the traceability and verification of formal specifications through providing support for the automatic generation of the formal specifications and the traceability of the requirements from the initial software design stage through the systems implementation and verification. Approaches explored in this project…

Not One to Rule Them All: Mining Meaningful Code Review Orders From GitHub
Abir Bouraffa, Carolin Brandt, Andy Zaidmann, Walid Maalej
https://arxiv.org/abs/2506.10654

Not One to Rule Them All: Mining Meaningful Code Review Orders From GitHub
Developers use tools such as GitHub pull requests to review code, discuss proposed changes, and request modifications. While changed files are commonly presented in alphabetical order, this does not necessarily coincide with the reviewer's preferred navigation sequence. This study investigates the different navigation orders developers follow while commenting on changes submitted in pull requests. We mined code review comments from 23,241 pull requests in 100 popular Java and Python repositorie…

Scalable Software Testing in Fast Virtual Platforms: Leveraging SystemC, QEMU and Containerization
Lukas J\"unger, Jan Henrik Weinstock, Tim Kraus
https://arxiv.org/abs/2506.10624

Scalable Software Testing in Fast Virtual Platforms: Leveraging SystemC, QEMU and Containerization
The ever-increasing complexity of HW/SW systems presents a persistent challenge, particularly in safety-critical domains like automotive, where extensive testing is imperative. However, the availability of hardware often lags behind, hindering early-stage software development. To address this, Virtual Platforms (VPs) based on the SystemC TLM-2.0 standard have emerged as a pivotal solution, enabling pre-silicon execution and testing of unmodified target software. In this study, we propose an app…

AdaptiveLLM: A Framework for Selecting Optimal Cost-Efficient LLM for Code-Generation Based on CoT Length
Junhang Cheng, Fang Liu, Chengru Wu, Li Zhang
https://arxiv.org/abs/2506.10525

AdaptiveLLM: A Framework for Selecting Optimal Cost-Efficient LLM for Code-Generation Based on CoT Length
While Large Language Models (LLMs) have significantly advanced code generation efficiency, they face inherent challenges in balancing performance and inference costs across diverse programming tasks. Dynamically selecting the optimal LLM based on task difficulty and resource constraints offers a promising approach to achieve an optimal balance between efficiency and performance. However, existing model selection methods are resource-intensive and often neglect cost efficiency. Moreover, these a…

BugGen: A Self-Correcting Multi-Agent LLM Pipeline for Realistic RTL Bug Synthesis
Surya Jasper, Minh Luu, Evan Pan, Aakash Tyagi, Michael Quinn, Jiang Hu, David Kebo Houngninou
https://arxiv.org/abs/2506.10501

BugGen: A Self-Correcting Multi-Agent LLM Pipeline for Realistic RTL Bug Synthesis
Hardware complexity continues to strain verification resources, motivating the adoption of machine learning (ML) methods to improve debug efficiency. However, ML-assisted debugging critically depends on diverse and scalable bug datasets, which existing manual or automated bug insertion methods fail to reliably produce. We introduce BugGen, a first of its kind, fully autonomous, multi-agent pipeline leveraging Large Language Models (LLMs) to systematically generate, insert, and validate realisti…

EXPEREPAIR: Dual-Memory Enhanced LLM-based Repository-Level Program Repair
Fangwen Mu, Junjie Wang, Lin Shi, Song Wang, Shoubin Li, Qing Wang
https://arxiv.org/abs/2506.10484

EXPEREPAIR: Dual-Memory Enhanced LLM-based Repository-Level Program Repair
Automatically repairing software issues remains a fundamental challenge at the intersection of software engineering and AI. Although recent advancements in Large Language Models (LLMs) have demonstrated potential for repository-level repair tasks, current methodologies exhibit two notable limitations: (1) they often address issues in isolation, neglecting to incorporate insights from previously resolved issues, and (2) they rely on static and rigid prompting strategies, which constrain their ab…

Towards Understanding Bugs in Distributed Training and Inference Frameworks for Large Language Models
Xiao Yu, Haoxuan Chen, Feifei Niu, Xing Hu, Jacky Wai Keung, Xin Xia
https://arxiv.org/abs/2506.10426

Towards Understanding Bugs in Distributed Training and Inference Frameworks for Large Language Models
With the rapid development of large language models (LLMs), distributed training and inference frameworks like DeepSpeed have become essential for scaling model training and inference across multiple GPUs or nodes. However, the increasing complexity of these frameworks brings non-trivial software bugs, which may degrade training performance, cause unexpected failures, and result in significant resource waste. Understanding framework bugs' characteristics is fundamental for quality assurance, al…

Bug Classification in Quantum Software: A Rule-Based Framework and Its Evaluation
Mir Mohammad Yousuf, Shabir Ahmad Sofi
https://arxiv.org/abs/2506.10397 h…

Bug Classification in Quantum Software: A Rule-Based Framework and Its Evaluation
Accurate classification of software bugs is essential for improving software quality. This paper presents a rule-based automated framework for classifying issues in quantum software repositories by bug type, category, severity, and impacted quality attributes, with additional focus on quantum-specific bug types. The framework applies keyword and heuristic-based techniques tailored to quantum computing. To assess its reliability, we manually classified a stratified sample of 4,984 issues from a …

AutoGEEval : A Multi-Level and Multi-Geospatial-Modality Automated Evaluation Framework for Large Language Models in Geospatial Code Generation on Google Earth Engine
Shuyang Hou, Zhangxiao Shen, Huayi Wu, Haoyue Jiao, Ziqi Liu, Lutong Xie, Chang Liu, Jianyuan Liang, Yaxian Qing, Xiaopu Zhang, Dehua Peng, Zhipeng Gui, Xuefeng Guan
https://

AutoGEEval++: A Multi-Level and Multi-Geospatial-Modality Automated Evaluation Framework for Large Language Models in Geospatial Code Generation on Google Earth Engine
Geospatial code generation is becoming a key frontier in integrating artificial intelligence with geo-scientific analysis, yet standardised automated evaluation tools for this task remain absent. This study presents AutoGEEval++, an enhanced framework building on AutoGEEval, and the first automated assessment system for large language models (LLMs) generating geospatial code on Google Earth Engine (GEE). It supports diverse data modalities and varying task complexities. Built on the GEE Python …

Augmenting Large Language Models with Static Code Analysis for Automated Code Quality Improvements
Seyed Moein Abtahi, Akramul Azim
https://arxiv.org/abs/2506.10330

Augmenting Large Language Models with Static Code Analysis for Automated Code Quality Improvements
This study examined code issue detection and revision automation by integrating Large Language Models (LLMs) such as OpenAI's GPT-3.5 Turbo and GPT-4o into software development workflows. A static code analysis framework detects issues such as bugs, vulnerabilities, and code smells within a large-scale software project. Detailed information on each issue was extracted and organized to facilitate automated code revision using LLMs. An iterative prompt engineering process is applied to ensure tha…

Minimizing False Positives in Static Bug Detection via LLM-Enhanced Path Feasibility Analysis
Xueying Du, Kai Yu, Chong Wang, Yi Zou, Wentai Deng, Zuoyu Ou, Xin Peng, Lingming Zhang, Yiling Lou
https://arxiv.org/abs/2506.10322

Minimizing False Positives in Static Bug Detection via LLM-Enhanced Path Feasibility Analysis
Static bug analyzers play a crucial role in ensuring software quality. However, existing analyzers for bug detection in large codebases often suffer from high false positive rates. This is primarily due to the limited capabilities of analyzers in path feasibility validation with multiple conditional branches and complex data dependencies. While current LLM-based approaches attempt to address this issue, their effectiveness remains limited due to insufficient constraint cascade analysis and scal…

AI-Based Software Vulnerability Detection: A Systematic Literature Review
Samiha Shimmi, Hamed Okhravi, Mona Rahimi
https://arxiv.org/abs/2506.10280 https:…

AI-Based Software Vulnerability Detection: A Systematic Literature Review
Software vulnerabilities in source code pose serious cybersecurity risks, prompting a shift from traditional detection methods (e.g., static analysis, rule-based matching) to AI-driven approaches. This study presents a systematic review of software vulnerability detection (SVD) research from 2018 to 2023, offering a comprehensive taxonomy of techniques, feature representations, and embedding methods. Our analysis reveals that 91% of studies use AI-based methods, with graph-based models being th…

Prompt Variability Effects On LLM Code Generation
Andrei Paleyes, Radzim Sendyka, Diana Robinson, Christian Cabrera, Neil D. Lawrence
https://arxiv.org/abs/2506.10204

Prompt Variability Effects On LLM Code Generation
Code generation is one of the most active areas of application of Large Language Models (LLMs). While LLMs lower barriers to writing code and accelerate development process, the overall quality of generated programs depends on the quality of given prompts. Specifically, functionality and quality of generated code can be sensitive to user's background and familiarity with software development. It is therefore important to quantify LLM's sensitivity to variations in the input. To this end we prop…

Reward Models Enable Scalable Code Verification by Trading Accuracy for Throughput
Gabriel Orlanski, Nicholas Roberts, Aws Albarghouthi, Frederic Sala
https://arxiv.org/abs/2506.10056

Reward Models Enable Scalable Code Verification by Trading Accuracy for Throughput
The standard paradigm for solving coding tasks via large language models (LLMs) is to generate-then-rank programs, where the latter step uses a verifier in the ranking process. The growing consensus is that a comprehensive verifier (e.g., a full test suite) should be prioritized over an outcome reward model (ORM) whenever possible, with little consideration given to the trade-offs involved. We aim to challenge this assumption by systematically exploring the tradeoff between speed and accuracy. …

The Effects of GitHub Copilot on Computing Students' Programming Effectiveness, Efficiency, and Processes in Brownfield Programming Tasks
Md Istiak Hossain Shihab, Christopher Hundhausen, Ahsun Tariq, Summit Haque, Yunhan Qiao, Brian Mulanda
https://arxiv.org/abs/2506.10051

The Effects of GitHub Copilot on Computing Students' Programming Effectiveness, Efficiency, and Processes in Brownfield Programming Tasks
When graduates of computing degree programs enter the software industry, they will most likely join teams working on legacy code bases developed by people other than themselves. In these so-called brownfield software development settings, generative artificial intelligence (GenAI) coding assistants like GitHub Copilot are rapidly transforming software development practices, yet the impact of GenAI on student programmers performing brownfield development tasks remains underexplored. This paper i…

Online Discovery of Simulation Models for Evolving Business Processes (Extended Version)
Francesco Vinci, Gyunam Park, Wil van der Aalst, Massimiliano de Leoni
https://arxiv.org/abs/2506.10049

TrioXpert: An automated incident management framework for microservice system
Yongqian Sun, Yu Luo, Xidao Wen, Yuan Yuan, Xiaohui Nie, Shenglin Zhang, Tong Liu, Xi Luo
https://arxiv.org/abs/2506.10043

TrioXpert: An automated incident management framework for microservice system
Automated incident management plays a pivotal role in large-scale microservice systems. However, many existing methods rely solely on single-modal data (e.g., metrics, logs, and traces) and struggle to simultaneously address multiple downstream tasks, including anomaly detection (AD), failure triage (FT), and root cause localization (RCL). Moreover, the lack of clear reasoning evidence in current techniques often leads to insufficient interpretability. To address these limitations, we propose T…

[2025-06-13 Fri (UTC), 24 new articles found for cs.SE Software Engineering]
toXiv_bot_toot

Microservices and Real-Time Processing in Retail IT: A Review of Open-Source Toolchains and Deployment Strategies
Aaditaa Vashisht (Department of Information Science,Engineering, RV College of Engineering, India), Rekha B S (Department of Information Science,Engineering, RV College of Engineering, India)
https://arxiv.org/abs/25…

Microservices and Real-Time Processing in Retail IT: A Review of Open-Source Toolchains and Deployment Strategies
With the rapid pace of digital transformation, the retail industry is increasingly depending on real-time, scalable, and resilient systems to manage financial transactions, analyze customer behavior, and streamline order processing. This literature review explores how modern event-driven and microservices-based architectures, particularly those leveraging Apache Kafka, Spring Boot, MongoDB, and Kubernetes are transforming retail and financial systems. By systematically reviewing academic public…

Assessing a Safety Case: Bottom-up Guidance for Claims and Evidence Evaluation
Scott Schnelle, Francesca Favaro, Laura Fraade-Blanar, David Wichner, Holland Broce, Justin Miranda
https://arxiv.org/abs/2506.09929

Assessing a Safety Case: Bottom-up Guidance for Claims and Evidence Evaluation
As Automated Driving Systems (ADS) technology advances, ensuring safety and public trust requires robust assurance frameworks, with safety cases emerging as a critical tool toward such a goal. This paper explores an approach to assess how a safety case is supported by its claims and evidence, toward establishing credibility for the overall case. Starting from a description of the building blocks of a safety case (claims, evidence, and optional format-dependent entries), this paper delves into t…

Stakeholder Participation for Responsible AI Development: Disconnects Between Guidance and Current Practice
Emma Kallina, Thomas Bohn\'e, Jat Singh
https://arxiv.org/abs/2506.09873

Stakeholder Participation for Responsible AI Development: Disconnects Between Guidance and Current Practice
Responsible AI (rAI) guidance increasingly promotes stakeholder involvement (SHI) during AI development. At the same time, SHI is already common in commercial software development, but with potentially different foci. This study clarifies the extent to which established SHI practices are able to contribute to rAI efforts as well as potential disconnects -- essential insights to inform and tailor future interventions that further shift industry practice towards rAI efforts. First, we analysed 56…

variability.dev: Towards an Online Toolbox for Feature Modeling
Tobias He{\ss}, Lukas Ostheimer, Tobias Betz, Simon Karrer, Tim Jannik Schmidt, Pierre Coquet, Sean Semmler, Thomas Th\"um
https://arxiv.org/abs/2506.09845

variability.dev: Towards an Online Toolbox for Feature Modeling
The emergence of feature models as the default to model the variability in configurable systems fosters a rich diversity in applications, application domains, and perspectives. Independent of their domain, modelers require to open, view, edit, transform, save, and configure models as well as to collaborate with others. However, at the time of writing, the top five results when googling ``Online Editor Feature Model'' point to editors that either have minimal functionality, are unmaintained or d…

Towards Bridging Formal Methods and Human Interpretability
Abhijit Paul, Proma Chowdhury, Kazi Sakib
https://arxiv.org/abs/2506.09759 https://

Towards Bridging Formal Methods and Human Interpretability
Labeled Transition Systems (LTS) are integral to model checking and design repair tools. System engineers frequently examine LTS designs during model checking or design repair to debug, identify inconsistencies, and validate system behavior. Despite LTS's significance, no prior research has examined human comprehension of these designs. To address this, we draw on traditional software engineering and graph theory, identifying 7 key metrics: cyclomatic complexity, state space size, average branc…

A First Look at Bugs in LLM Inference Engines
Mugeng Liu, Siqi Zhong, Weichen Bi, Yixuan Zhang, Zhiyang Chen, Zhenpeng Chen, Xuanzhe Liu, Yun Ma
https://arxiv.org/abs/2506.09713

A First Look at Bugs in LLM Inference Engines
Large language model-specific inference engines (in short as \emph{LLM inference engines}) have become a fundamental component of modern AI infrastructure, enabling the deployment of LLM-powered applications (LLM apps) across cloud and local devices. Despite their critical role, LLM inference engines are prone to bugs due to the immense resource demands of LLMs and the complexities of cross-platform compatibility. However, a systematic understanding of these bugs remains lacking. To bridge this…

Mapping NVD Records to Their VFCs: How Hard is it?
Huu Hung Nguyen, Duc Manh Tran, Yiran Cheng, Thanh Le-Cong, Hong Jin Kang, Ratnadira Widyasari, Shar Lwin Khin, Ouh Eng Lieh, Ting Zhang, David Lo
https://arxiv.org/abs/2506.09702

Mapping NVD Records to Their VFCs: How Hard is it?
Mapping National Vulnerability Database (NVD) records to vulnerability-fixing commits (VFCs) is crucial for vulnerability analysis but challenging due to sparse explicit links in NVD references.This study explores this mapping's feasibility through an empirical approach. Manual analysis of NVD references showed Git references enable over 86% success, while non-Git references achieve under 14%. Using these findings, we built an automated pipeline extracting 31,942 VFCs from 20,360 NVD records (8…

Calculating Software's Energy Use and Carbon Emissions: A Survey of the State of Art, Challenges, and the Way Ahead
Priyavanshi Pathania, Nikhil Bamby, Rohit Mehra, Samarth Sikand, Vibhu Saujanya Sharma, Vikrant Kaulgud, Sanjay Podder, Adam P. Burden
https://arxiv.org/abs/2506.09683 …

Calculating Software's Energy Use and Carbon Emissions: A Survey of the State of Art, Challenges, and the Way Ahead
The proliferation of software and AI comes with a hidden risk: its growing energy and carbon footprint. As concerns regarding environmental sustainability come to the forefront, understanding and optimizing how software impacts the environment becomes paramount. In this paper, we present a state-of-the-art review of methods and tools that enable the measurement of software and AI-related energy and/or carbon emissions. We introduce a taxonomy to categorize the existing work as Monitoring, Estim…

Translating a VDM Model of a Medical Device into Kapture
Joe Hare, Leo Freitas, Ken Pierce
https://arxiv.org/abs/2506.09636 https://a…

Translating a VDM Model of a Medical Device into Kapture
As the complexity of safety-critical medical devices increases, so does the need for clear, verifiable, software requirements. This paper explores the use of Kapture, a formal modelling tool developed by D-RisQ, to translate an existing formal VDM model of a medical implant for treating focal epilepsy called CANDO. The work was undertaken without prior experience in formal methods. The paper assess Kapture's usability, the challenges of formal modelling, and the effectiveness of the translated …

ASTAGEN: Empirical Evaluation of Automated SATD Taxonomy Generation with LLMs
Sota Nakashima, Yuta Ishimoto, Masanari Kondo, Tao Xiao, Yasutaka Kamei
https://arxiv.org/abs/2506.09601

ASTAGEN: Empirical Evaluation of Automated SATD Taxonomy Generation with LLMs
Technical debt refers to suboptimal code that degrades software quality. When developers intentionally introduce such debt, it is called self-admitted technical debt (SATD). Since SATD hinders maintenance, identifying its categories is key to uncovering quality issues. Traditionally, constructing such taxonomies requires manually inspecting SATD comments and surrounding code, which is time-consuming, labor-intensive, and often inconsistent due to annotator subjectivity. This study presents ASTA…

Automated Synthesis of Formally Verified Multi-Abstraction Function Summaries
Fanpeng Yang, Xu Ma, Shuling Wang, Xiong Xu, Qinxiang Cao, Naijun Zhan, Xiaofeng Li, Bin Gu
https://arxiv.org/abs/2506.09550

Automated Synthesis of Formally Verified Multi-Abstraction Function Summaries
Function summaries, which characterize the behavior of code segments (typically functions) through preconditions and postconditions, are essential for understanding, reusing, and verifying software, particularly in safety-critical domains like aerospace embedded systems. However, these mission-critical legacy code serving as a valuable reused asset often lacks formal specifications. It is challenging to automatically generate function summaries for C programs, due to the existence of complex fe…

Reasoning as a Resource: Optimizing Fast and Slow Thinking in Code Generation Models
Zongjie Li, Shuai Wang
https://arxiv.org/abs/2506.09396 https://

Reasoning as a Resource: Optimizing Fast and Slow Thinking in Code Generation Models
This position paper proposes a fundamental shift in designing code generation models: treating reasoning depth as a controllable resource. Rather than being an incidental byproduct of prompting, we argue that the trade-off between rapid, direct answers ("fast thinking") and elaborate, chain-of-thought deliberation ("slow thinking") must be explicitly managed. We contend that optimizing reasoning budgets across the entire model lifecycle - from synthetic data creation and benchmarking to real-wo…

Assessing the Impact of Refactoring Energy-Inefficient Code Patterns on Software Sustainability: An Industry Case Study
Rohit Mehra, Priyavanshi Pathania, Vibhu Saujanya Sharma, Vikrant Kaulgud, Sanjay Podder, Adam P. Burden
https://arxiv.org/abs/2506.09370

Assessing the Impact of Refactoring Energy-Inefficient Code Patterns on Software Sustainability: An Industry Case Study
Advances in technologies like artificial intelligence and metaverse have led to a proliferation of software systems in business and everyday life. With this widespread penetration, the carbon emissions of software are rapidly growing as well, thereby negatively impacting the long-term sustainability of our environment. Hence, optimizing software from a sustainability standpoint becomes more crucial than ever. We believe that the adoption of automated tools that can identify energy-inefficient p…

UTBoost: Rigorous Evaluation of Coding Agents on SWE-Bench
Boxi Yu, Yuxuan Zhu, Pinjia He, Daniel Kang
https://arxiv.org/abs/2506.09289 https://

UTBoost: Rigorous Evaluation of Coding Agents on SWE-Bench
The advent of Large Language Models (LLMs) has spurred the development of coding agents for real-world code generation. As a widely used benchmark for evaluating the code generation capabilities of these agents, SWE-Bench uses real-world problems based on GitHub issues and their corresponding pull requests. However, the manually written test cases included in these pull requests are often insufficient, allowing generated patches to pass the tests without resolving the underlying issue. To addre…

Formal Methods Meets Readability: Auto-Documenting JML Java Code
Juan Carlos Recio Abad, Ruben Saborido, Francisco Chicano
https://arxiv.org/abs/2506.09230

[2025-06-12 Thu (UTC), 15 new articles found for cs.SE Software Engineering]
toXiv_bot_toot

Replaced article(s) found for cs.SE. https://arxiv.org/list/cs.SE/new/
[1/1]:
Enhancing Open-Domain Task-Solving Capability of LLMs via Autonomous Tool Integration from GitHub

[2025-06-09 Mon (UTC), 11 new articles found for cs.SE Software Engineering]
#toXiv_bot_toot #toXiv_bot_new_article_summary_toot

This https://arxiv.org/abs/2207.04285 has been replaced.
link: https://scholar.google.com/scholar?q=a

A Closer Look into Transformer-Based Code Intelligence Through Code Transformation: Challenges and Opportunities
Transformer-based models have demonstrated state-of-the-art performance in many intelligent coding tasks such as code comment generation and code completion. Previous studies show that deep learning models are sensitive to the input variations, but few studies have systematically studied the robustness of Transformer under perturbed input code. In this work, we empirically study the effect of semantic-preserving code transformation on the performance of Transformer. Specifically, 24 and 27 code…

Boosting Rust Unit Test Coverage through Hybrid Program Analysis and Large Language Models
Bei Chu, Yang Feng, Kui Liu, Hange Shi, Zifan Nan, Zhaoqiang Guo, Baowen Xu
https://arxiv.org/abs/2506.09002

Boosting Rust Unit Test Coverage through Hybrid Program Analysis and Large Language Models
Unit testing is essential for ensuring software reliability and correctness. Classic Search-Based Software Testing (SBST) methods and concolic execution-based approaches for generating unit tests often fail to achieve high coverage due to difficulties in handling complex program units, such as branching conditions and external dependencies. Recent work has increasingly utilized large language models (LLMs) to generate test cases, improving the quality of test generation by providing better cont…

AdaDec: Uncertainty-Guided Adaptive Decoding for LLM-based Code Generation
Kaifeng He, Mingwei Liu, Chong Wang, Zike Li, Yanlin Wang, Xin Peng, Zibin Zheng
https://arxiv.org/abs/2506.08980

AdaDec: Uncertainty-Guided Adaptive Decoding for LLM-based Code Generation
Code generation with large language models (LLMs) is highly sensitive to token selection during decoding, particularly at uncertain decision points that influence program logic. While standard strategies like greedy and beam search treat all tokens uniformly, they overlook code-specific uncertainty patterns, leading to suboptimal performance. This paper presents an empirical study revealing that many generation errors stem from ranking mistakes at high-uncertainty steps, where the correct token…

On The Impact of Merge Request Deviations on Code Review Practices
Samah Kansab, Francis Bordeleau, Ali Tizghadam
https://arxiv.org/abs/2506.08860 https://…

On The Impact of Merge Request Deviations on Code Review Practices
Code review is a key practice in software engineering, ensuring quality and collaboration. However, industrial Merge Request (MR) workflows often deviate from standardized review processes, with many MRs serving non-review purposes (e.g., drafts, rebases, or dependency updates). We term these cases deviations and hypothesize that ignoring them biases analytics and undermines ML models for review analysis. We identify seven deviation categories, occurring in 37.02% of MRs, and propose a few-sh…

Towards a Knowledge Base of Common Sustainability Weaknesses in Green Software Development
Priyavanshi Pathania, Rohit Mehra, Vibhu Saujanya Sharma, Vikrant Kaulgud, Sanjay Podder, Adam P. Burden
https://arxiv.org/abs/2506.08812

Towards a Knowledge Base of Common Sustainability Weaknesses in Green Software Development
With the climate crisis looming, engineering sustainable software systems become crucial to optimize resource utilization, minimize environmental impact, and foster a greener, more resilient digital ecosystem. For developers, getting access to automated tools that analyze code and suggest sustainabilityrelated optimizations becomes extremely important from a learning and implementation perspective. However, there is currently a dearth of such tools due to the lack of standardized knowledge, whi…

Do Generative AI Tools Ensure Green Code? An Investigative Study
Samarth Sikand, Rohit Mehra, Vibhu Saujanya Sharma, Vikrant Kaulgud, Sanjay Podder, Adam P. Burden
https://arxiv.org/abs/2506.08790

Do Generative AI Tools Ensure Green Code? An Investigative Study
Software sustainability is emerging as a primary concern, aiming to optimize resource utilization, minimize environmental impact, and promote a greener, more resilient digital ecosystem. The sustainability or "greenness" of software is typically determined by the adoption of sustainable coding practices. With a maturing ecosystem around generative AI, many software developers now rely on these tools to generate code using natural language prompts. Despite their potential advantages, there is a …

Causality-aware Safety Testing for Autonomous Driving Systems
Wenbing Tang, Mingfei Cheng, Renzhi Wang, Yuan Zhou, Chengwei Liu, Yang Liu, Zuohua Ding
https://arxiv.org/abs/2506.08688

Causality-aware Safety Testing for Autonomous Driving Systems
Simulation-based testing is essential for evaluating the safety of Autonomous Driving Systems (ADSs). Comprehensive evaluation requires testing across diverse scenarios that can trigger various types of violations under different conditions. While existing methods typically focus on individual diversity metrics, such as input scenarios, ADS-generated motion commands, and system violations, they often fail to capture the complex interrelationships among these elements. This oversight leads to ga…

Proceedings of the 23rd International Overture Workshop
Hugo Daniel Macedo, Ken Pierce
https://arxiv.org/abs/2506.08680 https://arxiv…

Proceedings of the 23rd International Overture Workshop
This volume contains the papers presented at the 23rd International Overture Workshop, held on the 11th of June 2025. This event was the latest in a series of workshops around the Vienna Development Method (VDM), the open-source project Overture, and related tools and formalisms. VDM is one of the longest established formal methods for systems development. A lively community of researchers and practitioners has grown up in academia and industry has grown around the modelling languages (VDM-SL, …

Logic Mining from Process Logs: Towards Automated Specification and Verification
Radoslaw Klimek, Julia Witek
https://arxiv.org/abs/2506.08628 https://

Logic Mining from Process Logs: Towards Automated Specification and Verification
Logical specifications play a key role in the formal analysis of behavioural models. Automating the derivation of such specifications is particularly valuable in complex systems, where manual construction is time-consuming and error-prone. This article presents an approach for generating logical specifications from process models discovered via workflow mining, combining pattern-based translation with automated reasoning techniques. In contrast to earlier work, we evaluate the method on both ge…

RE-oriented Model Development with LLM Support and Deduction-based Verification
Radoslaw Klimek
https://arxiv.org/abs/2506.08606 https://

RE-oriented Model Development with LLM Support and Deduction-based Verification
The requirements engineering (RE) phase is pivotal in developing high-quality software. Integrating advanced modelling techniques with large language models (LLMs) and formal verification in a logical style can significantly enhance this process. We propose a comprehensive framework that focuses on specific Unified Modelling Language (UML) diagrams for preliminary system development. This framework offers visualisations at various modelling stages and seamlessly integrates large language models…

Evaluating the Performance and Efficiency of Sentence-BERT for Code Comment Classification
Fabian C. Pe\~na, Steffen Herbold
https://arxiv.org/abs/2506.08581

Evaluating the Performance and Efficiency of Sentence-BERT for Code Comment Classification
This work evaluates Sentence-BERT for a multi-label code comment classification task seeking to maximize the classification performance while controlling efficiency constraints during inference. Using a dataset of 13,216 labeled comment sentences, Sentence-BERT models are fine-tuned and combined with different classification heads to recognize comment types. While larger models outperform smaller ones in terms of F1, the latter offer outstanding efficiency, both in runtime and GFLOPS. As result…

Detecting State Manipulation Vulnerabilities in Smart Contracts Using LLM and Static Analysis
Hao Wu, Haijun Wang, Shangwang Li, Yin Wu, Ming Fan, Yitao Zhao, Ting Liu
https://arxiv.org/abs/2506.08561

Detecting State Manipulation Vulnerabilities in Smart Contracts Using LLM and Static Analysis
An increasing number of DeFi protocols are gaining popularity, facilitating transactions among multiple anonymous users. State Manipulation is one of the notorious attacks in DeFi smart contracts, with price variable being the most commonly exploited state variable-attackers manipulate token prices to gain illicit profits. In this paper, we propose PriceSleuth, a novel method that leverages the Large Language Model (LLM) and static analysis to detect Price Manipulation (PM) attacks proactively.…

Understanding Software Engineering Agents Through the Lens of Traceability: An Empirical Study
Ira Ceka, Saurabh Pujar, Shyam Ramji, Luca Buratti, Gail Kaiser, Baishakhi Ray
https://arxiv.org/abs/2506.08311

Understanding Software Engineering Agents Through the Lens of Traceability: An Empirical Study
With the advent of large language models (LLMs), software engineering agents (SWE agents) have emerged as a powerful paradigm for automating a range of software tasks -- from code generation and repair to test case synthesis. These agents operate autonomously by interpreting user input and responding to environmental feedback. While various agent architectures have demonstrated strong empirical performance, the internal decision-making worfklows that drive their behavior remain poorly understoo…

MBTModelGenerator: A software tool for reverse engineering of Model-based Testing (MBT) models from clickstream data of web applications
Sasidhar Matta, Vahid Garousi
https://arxiv.org/abs/2506.08179

MBTModelGenerator: A software tool for reverse engineering of Model-based Testing (MBT) models from clickstream data of web applications
Automated testing has become a standard practice in software engineering, yet the creation of test models and suites remains labor-intensive. To reduce this effort, we developed an open-source tool that automatically generates Model-Based Testing (MBT) models from clickstream data collected during user interaction with web applications. The tool captures UI events, transforms them into state-transition models, and exports the result in a format compatible with the GraphWalker MBT tool. This ena…

Repeton: Structured Bug Repair with ReAct-Guided Patch-and-Test Cycles
Nguyen Phu Vinh, Anh Chung Hoang, Chris Ngo, Truong-Son Hy
https://arxiv.org/abs/2506.08173

Repeton: Structured Bug Repair with ReAct-Guided Patch-and-Test Cycles
Large Language Models (LLMs) have shown strong capabilities in code generation and comprehension, yet their application to complex software engineering tasks often suffers from low precision and limited interpretability. We present Repeton, a fully open-source framework that leverages LLMs for precise and automated code manipulation in real-world Git repositories. Rather than generating holistic fixes, Repeton operates through a structured patch-and-test pipeline: it iteratively diagnoses issue…

Worst-Case Symbolic Constraints Analysis and Generalisation with Large Language Models
Daniel Koh, Yannic Noller, Corina S. Pasareanu, Adrians Skapars, Youcheng Sun
https://arxiv.org/abs/2506.08171

Worst-Case Symbolic Constraints Analysis and Generalisation with Large Language Models
Large language models (LLMs) have been successfully applied to a variety of coding tasks, including code generation, completion, and repair. However, more complex symbolic reasoning tasks remain largely unexplored by LLMs. This paper investigates the capacity of LLMs to reason about worst-case executions in programs through symbolic constraints analysis, aiming to connect LLMs and symbolic reasoning approaches. Specifically, we define and address the problem of worst-case symbolic constraints a…

A Metrics-Oriented Architectural Model to Characterize Complexity on Machine Learning-Enabled Systems
Renato Cordeiro Ferreira (University of S\~ao Paulo, Jheronimus Academy of Data Science, Technical University of Eindhoven, Tilburg University)
https://arxiv.org/abs/2506.08153

A Metrics-Oriented Architectural Model to Characterize Complexity on Machine Learning-Enabled Systems
How can the complexity of ML-enabled systems be managed effectively? The goal of this research is to investigate how complexity affects ML-Enabled Systems (MLES). To address this question, this research aims to introduce a metrics-based architectural model to characterize the complexity of MLES. The goal is to support architectural decisions, providing a guideline for the inception and growth of these systems. This paper showcases the first step for creating the metrics-based architectural mode…

A Systematic Literature Review on Continuous Integration and Deployment (CI/CD) for Secure Cloud Computing
Sabbir M. Saleh, Nazim Madhavji, John Steinbacher
https://arxiv.org/abs/2506.08055

A Systematic Literature Review on Continuous Integration and Deployment (CI/CD) for Secure Cloud Computing
As cloud environments become widespread, cybersecurity has emerged as a top priority across areas such as networks, communication, data privacy, response times, and availability. Various sectors, including industries, healthcare, and government, have recently faced cyberattacks targeting their computing systems. Ensuring secure app deployment in cloud environments requires substantial effort. With the growing interest in cloud security, conducting a systematic literature review (SLR) is critica…

[2025-06-11 Wed (UTC), 17 new articles found for cs.SE Software Engineering]
toXiv_bot_toot

Adversarial Attack Classification and Robustness Testing for Large Language Models for Code
Yang Liu, Armstrong Foundjem, Foutse Khomh, Heng Li
https://arxiv.org/abs/2506.07942

Adversarial Attack Classification and Robustness Testing for Large Language Models for Code
Large Language Models (LLMs) have become vital tools in software development tasks such as code generation, completion, and analysis. As their integration into workflows deepens, ensuring robustness against vulnerabilities especially those triggered by diverse or adversarial inputs becomes increasingly important. Such vulnerabilities may lead to incorrect or insecure code generation when models encounter perturbed task descriptions, code, or comments. Prior research often overlooks the role of …

Towards a Small Language Model Lifecycle Framework
Parsa Miraghaei, Sergio Moreschini, Antti Kolehmainen, David H\"astbacka
https://arxiv.org/abs/2506.07695

Towards a Small Language Model Lifecycle Framework
Background: The growing demand for efficient and deployable language models has led to increased interest in Small Language Models (SLMs). However, existing research remains fragmented, lacking a unified lifecycle perspective. Objective: This study aims to define a comprehensive lifecycle framework for SLMs by synthesizing insights from academic literature and practitioner sources. Method: We conducted a comprehensive survey of 36 works, analyzing and categorizing lifecycle-relevant techniq…

Centrality Change Proneness: an Early Indicator of Microservice Architectural Degradation
Alexander Bakhtin, Matteo Esposito, Valentina Lenarduzzi, Davide Taibi
https://arxiv.org/abs/2506.07690

Centrality Change Proneness: an Early Indicator of Microservice Architectural Degradation
Over the past decade, the wide adoption of Microservice Architecture has required the identification of various patterns and anti-patterns to prevent Microservice Architectural Degradation. Frequently, the systems are modelled as a network of connected services. Recently, the study of temporal networks has emerged as a way to describe and analyze evolving networks. Previous research has explored how software metrics such as size, complexity, and quality are related to microservice centrality in…

Leveraging Network Methods for Hub-like Microservice Detection
Alexander Bakhtin, Matteo Esposito, Valentina Lenarduzzi, Davide Taibi
https://arxiv.org/abs/2506.07683

Leveraging Network Methods for Hub-like Microservice Detection
Context: Microservice Architecture is a popular architectural paradigm that facilitates flexibility by decomposing applications into small, independently deployable services. Catalogs of architectural anti-patterns have been proposed to highlight the negative aspects of flawed microservice design. In particular, the Hub-like anti-pattern lacks an unambiguous definition and detection method. Aim: In this work, we aim to find a robust detection approach for the Hub-like microservice anti-pattern …

Evaluating LLMs Effectiveness in Detecting and Correcting Test Smells: An Empirical Study
E. G. Santana Jr, Jander Pereira Santos Junior, Erlon P. Almeida, Iftekhar Ahmed, Paulo Anselmo da Mota Silveira Neto, Eduardo Santana de Almeida
https://arxiv.org/abs/2506.07594

Evaluating LLMs Effectiveness in Detecting and Correcting Test Smells: An Empirical Study
Test smells indicate poor development practices in test code, reducing maintainability and reliability. While developers often struggle to prevent or refactor these issues, existing tools focus primarily on detection rather than automated refactoring. Large Language Models (LLMs) have shown strong potential in code understanding and transformation, but their ability to both identify and refactor test smells remains underexplored. We evaluated GPT-4-Turbo, LLaMA 3 70B, and Gemini-1.5 Pro on Pyth…

IntenTest: Stress Testing for Intent Integrity in API-Calling LLM Agents
Shiwei Feng, Xiangzhe Xu, Xuan Chen, Kaiyuan Zhang, Syed Yusuf Ahmed, Zian Su, Mingwei Zheng, Xiangyu Zhang
https://arxiv.org/abs/2506.07524

IntenTest: Stress Testing for Intent Integrity in API-Calling LLM Agents
LLM agents are increasingly deployed to automate real-world tasks by invoking APIs through natural language instructions. While powerful, they often suffer from misinterpretation of user intent, leading to the agent's actions that diverge from the user's intended goal, especially as external toolkits evolve. Traditional software testing assumes structured inputs and thus falls short in handling the ambiguity of natural language. We introduce IntenTest, an API-centric stress testing framework th…

Large Language Models for Multilingual Vulnerability Detection: How Far Are We?
Honglin Shu, Michael Fu, Junji Yu, Dong Wang, Chakkrit Tantithamthavorn, Junjie Chen, Yasutaka Kamei
https://arxiv.org/abs/2506.07503

Large Language Models for Multilingual Vulnerability Detection: How Far Are We?
Various deep learning-based approaches utilizing pre-trained language models (PLMs) have been proposed for automated vulnerability detection. With recent advancements in large language models (LLMs), several studies have begun exploring their application to vulnerability detection tasks. However, existing studies primarily focus on specific programming languages (e.g., C/C++) and function-level detection, leaving the strengths and weaknesses of PLMs and LLMs in multilingual and multi-granularit…

A Framework for Creating Non-Regressive Test Cases via Branch Consistency Analysis Driven by Descriptions
Yuxiang Zhang, Pengyu Xue, Zhen Yang, Xiaoxue Ren, Xiang Li, Linhao Wu, Jiancheng Zhao, Xingda Yu
https://arxiv.org/abs/2506.07486

A Framework for Creating Non-Regressive Test Cases via Branch Consistency Analysis Driven by Descriptions
Automated test-generation research overwhelmingly assumes the correctness of focal methods, yet practitioners routinely face non-regression scenarios where the focal method may be defective. A baseline evaluation of EvoSuite and two leading Large Language Model (LLM)-based generators, namely ChatTester and ChatUniTest, on defective focal methods reveals that despite achieving up to 83% of branch coverage, none of the generated tests expose defects. To resolve this problem, we first construct …

Generate Realistic Test Scenes for V2X Communication Systems
An Guo, Xinyu Gao, Chunrong Fang, Haoxiang Tian, Weisong Sun, Yanzhou Mu, Shuncheng Tang, Lei Ma, Zhenyu Chen
https://arxiv.org/abs/2506.07419

Generate Realistic Test Scenes for V2X Communication Systems
Accurately perceiving complex driving environments is essential for ensuring the safe operation of autonomous vehicles. With the tremendous progress in deep learning and communication technologies, cooperative perception with Vehicle-to-Everything (V2X) technologies has emerged as a solution to overcome the limitations of single-agent perception systems in perceiving distant objects and occlusions. Despite the considerable advancements, V2X cooperative perception systems require thorough testin…

GUIPilot: A Consistency-based Mobile GUI Testing Approach for Detecting Application-specific Bugs
Ruofan Liu, Xiwen Teoh, Yun Lin, Guanjie Chen, Ruofei Ren, Denys Poshyvanyk, Jin Song Dong
https://arxiv.org/abs/2506.07385

GUIPilot: A Consistency-based Mobile GUI Testing Approach for Detecting Application-specific Bugs
In this work, we propose GUIPilot, an approach for detecting inconsistencies between the mobile design and their implementations. The mobile design usually consists of design mock-ups that specify (1) the expected screen appearances (e.g., widget layouts, colors, and shapes) and (2) the expected screen behaviors, regarding how one screen can transition into another (e.g., labeled widgets with textual description). Given a design mock-up and the implementation of its application, GUIPilot report…

Taxonomy of migration scenarios for Qiskit refactoring using LLMs
Jos\'e Manuel Su\'arez, Lu\'is Mariano Bibb\'o, Joaqu\'in Bogado, Alejandro Fernandez
https://arxiv.org/abs/2506.07135

Taxonomy of migration scenarios for Qiskit refactoring using LLMs
As quantum computing advances, quantum programming libraries' heterogeneity and steady evolution create new challenges for software developers. Frequent updates in software libraries break working code that needs to be refactored, thus adding complexity to an already complex landscape. These refactoring challenges are, in many cases, fundamentally different from those known in classical software engineering due to the nature of quantum computing software. This study addresses these challenges b…

Is Your Training Pipeline Production-Ready? A Case Study in the Healthcare Domain
Daniel Lawand (University of S\~ao Paulo), Lucas Quaresma (University of S\~ao Paulo), Roberto Bolgheroni (University of S\~ao Paulo), Alfredo Goldman (University of S\~ao Paulo), Renato Cordeiro Ferreira (University of S\~ao Paulo, Jheronimus Academy of Data Science, Technical University of Eindhoven, Tilburg University)

Is Your Training Pipeline Production-Ready? A Case Study in the Healthcare Domain
Deploying a Machine Learning (ML) training pipeline into production requires robust software engineering practices. This differs significantly from experimental workflows. This experience report investigates this challenge in SPIRA, a project whose goal is to create an ML-Enabled System (MLES) to pre-diagnose insufficiency respiratory via speech analysis. The first version of SPIRA's training pipeline lacked critical software quality attributes. This paper presents an overview of the MLES, then…

Beyond Surface Similarity: Evaluating LLM-Based Test Refactorings with Structural and Semantic Awareness
Wendk\^uuni C. Ou\'edraogo, Yinghua Li, Xueqi Dang, Xin Zhou, Anil Koyuncu, Jacques Klein, David Lo, Tegawend\'e F. Bissyand\'e
https://arxiv.org/abs/2506.06767

Beyond Surface Similarity: Evaluating LLM-Based Test Refactorings with Structural and Semantic Awareness
Large Language Models (LLMs) are increasingly employed to automatically refactor unit tests, aiming to enhance readability, naming, and structural clarity while preserving functional behavior. However, evaluating such refactorings remains challenging: traditional metrics like CodeBLEU are overly sensitive to renaming and structural edits, whereas embedding-based similarities capture semantics but ignore readability and modularity. We introduce CTSES, a composite metric that integrates CodeBLEU,…

Mind the Gap: A Readability-Aware Metric for Test Code Complexity
Wendk\^uuni C. Ou\'edraogo, Yinghua Li, Xueqi Dang, Xin Zhou, Anil Koyuncu, Jacques Klein, David Lo, Tegawend\'e F. Bissyand\'e
https://arxiv.org/abs/2506.06764

Mind the Gap: A Readability-Aware Metric for Test Code Complexity
Automatically generated unit tests-from search-based tools like EvoSuite or LLMs-vary significantly in structure and readability. Yet most evaluations rely on metrics like Cyclomatic Complexity and Cognitive Complexity, designed for functional code rather than test code. Recent studies have shown that SonarSource's Cognitive Complexity metric assigns near-zero scores to LLM-generated tests, yet its behavior on EvoSuite-generated tests and its applicability to test-specific code structures remai…

Private GPTs for LLM-driven testing in software development and machine learning
Jakub Jagielski, Markus Abel
https://arxiv.org/abs/2506.06509 https://

Private GPTs for LLM-driven testing in software development and machine learning
In this contribution, we examine the capability of private GPTs to automatically generate executable test code based on requirements. More specifically, we use acceptance criteria as input, formulated as part of epics, or stories, which are typically used in modern development processes. This gives product owners, or business intelligence, respectively, a way to directly produce testable criteria through the use of LLMs. We explore the quality of the so-produced tests in two ways: i) directly b…