Manually extracting device knowledge from dense hardware manuals for requirements elicitation is a timeconsuming and error-prone bottleneck in embedded systems development. While Large Language Models (LLMs) offer automation potential, their direct application is unreliable for this high-precision task due to factual inaccuracies and sensitivity to prompt engineering. To address this, we propose a novel hybrid method that synergizes parameter-efficient tuning with the reasoning power of LLMs. Instead of directly tuning the LLM, our approach uses soft prompts to efficiently optimize a lightweight sentence encoder, transforming it into a domainaware semantic retriever. This specialized retriever then generates superior, context-rich prompts for a frozen LLM. Our optimization strategy features a multi-task contrastive loss to discern fine-grained semantics and a clustering-based exemplar selection process to ensure prompt diversity and relevance. On a real-world dataset of devices, our method achieves F1-scores of 87.02% for entity extraction and 77.60% for relation extraction, significantly outperforming baseline LLMs and a strong, heavyweight, domain-specific pre-trained model (EquipBERT).
Ensuring the safety of autonomous driving systems (ADS) in a cost-effective and efficient manner remains a critical challenge. Existing law-guided scenario generation approaches are typically limited to a narrow subset of legal rules, resulting in insufficient scenario diversity, and search-based methods often struggle with large and sparse search spaces. To address these limitations, we propose SLaFE (Semantic Law Modeling and Fuzzing based on Cooperative Evolution), a novel traffic violation scenario generation framework designed to systematically evaluate the safety of ADS. SLaFE harnesses the reasoning capabilities of large language models (LLMs) to convert traffic laws into structured scenario constraints. These scenarios are then optimized via a cooperative evolutionary fuzzing algorithm that explores the parameter space to identify boundary cases likely to trigger abnormal ADS behaviors. We evaluate SLaFE on the Apollo platform within the LGSVL simulator using ten realworld traffic regulations. Experimental results show that SLaFE successfully triggered all 10 types of traffic law violations (10/10), outperforming the best existing method, VioHawk (9/10), while others detected no more than 3. Moreover, SLaFE achieved an average triggering time of 5.1 minutes per law type, significantly faster than VioHawk (9.0 minutes) and other baselines. These results highlight SLaFE’s effectiveness in discovering diverse and critical law-violating scenarios for ADS testing.
Recent studies have demonstrated outstanding capabilities of large language models (LLMs) in software engineering tasks, including code generation and comprehension. While LLMs have shown significant potential in assisting with coding, LLMs are vulnerable to adversarial attacks. In this paper, we investigate the vulnerability of LLMs to imperceptible attacks. This class of attacks manipulate source code at the character level, which renders the changes invisible to human reviewers yet effective in misleading LLMs’ behaviour. We devise these attacks into four distinct categories and analyse their impacts on code analysis and comprehension tasks. These four types of imperceptible character attacks include coding reordering, invisible coding characters, code deletions, and code homoglyphs. To assess the robustness of state-of-the-art LLMs, we present a systematic evaluation across multiple models using both perturbed and clean code snippets. Two evaluation metrics, model confidence using log probabilities of response and response correctness, are introduced. The results reveal that LLMs are susceptible to imperceptible coding perturbations, with varying degrees of degradation highlighted across different LLMs. Furthermore, we observe a consistent negative correlation between perturbation magnitude and model performance. These results highlight the urgent need for robust LLMs capable of manoeuvring behaviours under imperceptible adversarial conditions.
Driver fatigue detection is a core functional module in intelligent driver monitoring systems, and its performance directly affects the reliability and safety of Advanced Driver Assistance Systems (ADAS). Existing computer vision-based fatigue detection methods have issues such as redundant feature extraction and insufficient modeling of long-term temporal dependencies. In particular, when facial actions are highly similar to yawning, they are prone to causing misjudgments in decisionmaking. To address these challenges, this paper proposes a facial feature and attention-based temporal convolutional network (FATCN) for software engineering practice, it improves the performance by optimizing feature engineering. FA-TCN includes two core software modules: the first is the facial feature detection module (FFD-Module), it simplifies the input dimensions by extracting the temporal features of the eye aspect ratio (EAR) and mouth aspect ratio (MAR), enhances the robustness of the module in complex driving scenarios; the second is the facial action classification module (FAC-Module), it uses an attention-based temporal convolutional network (TCN) to optimize the longsequence feature modeling capability by parallelizing convolution operations. The experimental results show that, on the YawDD dataset, FA-TCN outperforms existing advanced methods and effectively enhances the recognition ability of intelligent driving software for subtle fatigue actions.
Floating-point arithmetic is widely used in high-precision computing fields such as national defense, aerospace, and finance. Different applications have varying requirements for floating-point computation precision, and how to maximize program performance while meeting precision requirements is a crucial challenge in high-performance program design. Mixed-precision technology is a common optimization strategy to address this issue, which involves using multiple precision types within the same program. However, most existing research on mixed precision tends to fall into local optima and fails to directly provide users with usable mixed-precision programs. Since genetic algorithms are optimization methods with global search capabilities, we propose a genetic algorithm-based mixed-precision tuning method and develop a tool called GATUNER. Specifically, GATUNER first analyzes the variables and statements of the program to construct a dependency graph of the program. Then, it uses the Leiden algorithm to detect community structures in the dependency graph, employs an improved genetic algorithm to search for mixed-precision configurations, and finally automatically generates the corresponding mixed-precision program. We evaluated GATUNER on 14 benchmark tests and application programs. The experimental results show that GATUNER can find valid mixed-precision configurations for 76.79% of the test programs, with an average performance improvement of 31.65% for the found mixed-precision configurations. Compared with HIFPTUNER, ADAPT, and CHEF-FP, the average performance improvement of the mixed-precision configurations found by GATUNER increased by 14.1%, 24.09%, and 15.18% respectively. In addition, compared with PESA, the average performance improvement of the mixed-precision configurations obtained by GATUNER increased by 18.67%.
Unit testing, as a critical means of ensuring software quality, is often constrained in practice by the high cost and low efficiency of manual test case construction, resulting in limited test coverage and a scarcity of unit test cases in real-world projects. Traditional test generation tools can improve coverage but suffer from poor readability and limited generalization. In recent years, large language models (LLMs) have demonstrated strong potential in the field of test generation, owing to their powerful generalization and reasoning capabilities. However, the static nature of training data often causes hallucinations, undermining the reliability of generated tests. To address this, we propose MUATC, a multi-agent unit test generation framework based on LLMs. This work introduces, for the first time in coverage-driven LLM-based test generation, a multi-agent collaborative mechanism that integrates Chain-of-Thought reasoning and Retrieval-Augmented Generation to enhance both the quality and coverage of generated test cases. Additionally, we propose a unit test repair algorithm MTCRA aimed at further improving test coverage. The experimental results show that MUATC achieves 4.8%-5.5% higher coverage than Coverup, with performance gains independent of model architecture and programming languages. Compared with advanced LLM-based coverage enhancement tools such as ChatUniTest, TestPilot and Coverup, MUATC achieves a 12.7% improvement in test coverage on the benchmark dataset provided by ChatUniTest. To demonstrate the superior readability of test cases generated by MUATC, we conducted a readability study via the HumanEval platform. The results indicate that MUATC-generated test cases are significantly more readable than those produced by Pynguin. Therefore, to leverage the high readability of generated test cases, we also develop UnitTestPlat, a user-oriented platform for visualized unit test generation.
In safety critical domains such as aerospace and defense, software must perform with high reliability, making trustworthiness assessment indispensable. The trustworthiness assessment integrates key attributes such as reliability and maintainability, drawing evidence from across the entire software life cycle and fusing it to determine overall trustworthiness. However, these indicators are not independent, since causal dependencies among them increase the complexity of evaluation. To address this, we build a life cycle Causal Evidence Graph to model cross stage links, causal directions, confounders, mediators, and calibrate evidence weights by causal consistency. To resolve conflicts, we use falsity, credibility, and uncertainty measures, apply game theoretic weighted aggregation, and then perform Dempster Shafer fusion. Preliminary experimental results show that our approach satisfies monotonicity, acceleration, sensitivity, and substitutability, and yields greater interpretability than methods that ignore causal relations.
Despite advances in automated repair technologies, software vulnerabilities continue to pose significant threats to system security. Existing deep learning-based methods (e.g., VRepair, VulRepair) focus primarily on generating patch code, but suffer from low success rates (<20%) and poor interpretability due to syntactic/semantic discrepancies and lack of contextual awareness. To address these issues, we propose FixConsult 1, a novel framework that generates natural language repair suggestions by integrating external defect knowledge. FixConsult leverages a neural network architecture trained on a CodeT5-based fine-tuned LLM, introducing three key innovations: (1) Patch Knowledge Integration: Embeds structural patterns from historical fixes to enhance contextual repair reasoning. (2) Defect Type Classification: Uses the Qwen-Max LLM to classify vulnerabilities, providing targeted repair solutions for different defect types. (3) Self-learning Composite Loss: Implements an adaptive attention strategy to dynamically balance keyword relevance and semantic consistency. In experiments conducted on 18K real-world C/C++ vulnerability-suggestion pairs, FixConsult significantly surpasses the state-of-the-art baseline across various automatic evaluation metrics, including BLEU (+1.8), ROUGE-L (+4.7), BERTScore (+5.1) and RAS (+2.2), as well as human evaluation scores (+0.29) that combine repair actions and repair objectives. Case studies further confirm its superiority in generating accurate, actionable repair rationales. This work pioneers the integration of patch structure and defect type, offering a developer-centric, trustworthy path for explainable vulnerability repair automation.
Platform ecosystems have revolutionized value creation across numerous industries, inducing technical leaps and scaling artifact generation in scales and speeds unattainable through traditional vertically integrated or single-firm models. These ecosystems rely on collaborative interactions among actors to co-create and reuse value. Such ecosystems are socio-technical environments which require complex governance and orchestration strategies to ensure ecosystem health and performance from financial, technical, and social perspectives. Consequently, monitoring the performance of platform ecosystems requires non-primitive metrics as factors contributing to ecosystem performance are multifaceted compared to conventional software settings. Effective orchestration of platform ecosystems requires relies on access to real-time quantitative performance indicators. The existing literature offers various quantitative health metrics and performance indicators for platform ecosystems, yet these are dispersed across multiple studies and often embedded in abstract models or found within generic analytics systems. This research reviews existing quantitative real-time health metrics and performance indicators of platform ecosystems. We identified 417 distinct metrics after eliminating duplicates and incomplete definitions, and refined 168 of these metrics to be calculable in real-time using a consistent framework for definition, nomenclature, and quantification. Furthermore, we compiled existing real-time ecosystem health monitoring methods into a reference architecture and tested its feasibility in two active platform ecosystems. The study yields four key contributions: a practical catalog of platform ecosystem health metrics; a reference architecture for creating real-time ecosystem health monitoring solutions, demonstrated through implementation in two operational platform ecosystems; industry-relevant insights for practitioners; and a discussion of potential future research directions.
Decentralized Finance (DeFi) can provide traditional financial services through blockchain and smart contract technology. The generation of DeFi smart contracts from DeFi legal contracts has become a hot topic. However, we found that current approaches for generating DeFi smart contracts from legal contracts fail to ensure conformance between the two. To address this, we propose caSPESC2Vyper, a method to generate Vyper smart contracts from SPESC legal contracts while guaranteeing conformance. First, we define the executable formal semantics K-SPESC. Next, we establish a syntactic structure mapping from the SPESC language to the Vyper language, based on which caSPESC2Vyper is implemented. Finally, we analyze the conformance and demonstrate that caSPESC2Vyper effectively ensures conformance between DeFi legal contracts and Vyper smart contracts.
Background: Mocking is a common technique for isolating test dependencies, yet duplicated mock setup code-what we call "mock clones"-can increase test maintenance overhead and reduce clarity. While code clone detection is a mature research area, the prevalence, characteristics, and refactoring of mock clones remain insufficiently understood. Aims: This study investigates the prevalence, detection challenges, and practical elimination of mock clones in real-world Java test suites, aiming to identify systematic patterns and assess the feasibility and value of mock clone refactoring. Method: We analyzed 698 mock clone instances across six open-source Java projects. We evaluated the effectiveness of existing code clone detection tools in capturing mock clones, manually refactored a large subset of clones to assess behavior preservation, and measured the structural impact of mock clone elimination. Results: Mock clones are prevalent, with frequently mocked classes often exhibiting extensive duplication. Existing clone detection tools failed to reliably detect mock clones due to scattered, reordered, and semantically varied mocking logic. Manual refactoring successfully eliminated 60% of identified mock clones while preserving test behavior, resulting in up to 64% reduction in mock objects and up to 61% reduction in mocking-related LOC. Targeting only the top 5-10 high-impact clones still achieved substantial simplification. Conclusions: Mock clone elimination is both feasible and highly valuable for improving test code maintainability. Systematic refactoring strategies can address common patterns, and prioritizing high-impact clones enables efficient gains with minimal effort. These findings motivate the need for mock-aware detection and automated refactoring tools to unlock broader maintainability improvements in testing practices.
Black-box fairness testing aims to reveal potential discriminatory behaviors in deployed AI models by generating individual discriminatory instances, thereby safeguarding trustworthiness in socially critical domains such as smart education and talent recruitment. However, existing approaches often suffer from limited instance space coverage due to their reliance on local neighborhood searches around predefined seed instances, leading to poor diversity and suboptimal exploration. To address these limitations, we propose Cobweb, a novel black-box fairness testing framework that combines genetic algorithms with explicit region-guided generation and multi-objective evolutionary search. First, the initial population is constructed via spatial uniform initialization to maximize instance diversity through pairwise distance optimization. Second, we introduce an explicit region-guided strategy and design a dualobjective optimization mechanism, which concurrently optimizes for both individual discrimination and spatial sparsity, enabling outward search into low-density regions. These mechanisms jointly improve Cobweb's ability to generate diverse and spatially representative discriminatory instances. Extensive experiments on seven benchmark tabular datasets demonstrate that Cobweb achieves significant improvements over state-of-the-art baselines, with gains in effectiveness (similar to 1.6x), efficiency (similar to 2.9x) on average under fixed query budgets. In particular, Cobweb consistently achieves higher scores in three complementary diversity metrics, confirming its superior exploratory capability. Retraining target models with Cobweb-generated instances leads to an average reduction of 57% in individual fairness violations, confirming the practical value of our approach.
Software fault localization is widely known to be costly, which motivates researchers to develop automated root cause analysis techniques. While many existing approaches focus on pinpointing the location of bugs, they often overlook the process of locating them. However, in practice, while the exact location or fix of a bug can be subjective, the explanation of how a bug manifests is often more objective and broadly agreed upon. Such explanations can thus offer a stronger foundation for understanding and resolving bugs. In this work, we propose, TraceWalker, a tool-supported root cause analysis approach that generates a step-by-step debugging plan to guide developers toward the root cause with convincing explanations. Technically, we build the execution trace as a causal model where each step, control dependency, and data dependency is modeled with quantified suspiciousness. Based on the suspiciousness, TraceWalker traverses the execution trace to guide users toward the root cause. Specifically, each travel is on an estimated decision to explore control or data dependencies on the trace. While guiding the programmers to the root cause, TraceWalker collects their agreement on the estimated decision as feedback, which in turn updates the predicted root cause with a new planned travelling path. Our simulation experiments on Defects4j dataset show that (1) TraceWalker is effective in root-cause location comparing to state-of-the-art approaches, (2) TraceWalker can generate accurate explanation and save the debugging efforts to reach the root cause and (3) TraceWalker is robust against potential incorrect feedbacks. Moreover, our user study on 21 participants show that TraceWalker can boost the debugging performance with convincing explanation in practice.
Unit testing is a foundational practice in software engineering, essential for verifying program correctness, ensuring reliability, and supporting long-term maintainability. Rust, as a systems programming language emphasizing safety and performance, has seen rapid adoption in critical software infrastructures. However, writing effective unit tests in Rust is challenging due to its strict type system, ownership model, and module structure. Existing Rust unit test generation approaches can be divided into three categories: search-based, fuzzing-based, and large language models (LLMs)-based methods. Search-based and fuzzing-based methods often suffer from poor readability and lack semantic alignment with developer intent. LLMs-based methods can generate human-like, context-aware test cases, showing promise in Rust test generation. Despite their promise, LLMs-based methods still have two challenges. (1) There is a lack of high-quality training data to align the focal methods and their unit tests. (2) Rust's strict type system, ownership rules, and modular design introduce barriers for generating test cases with high compile success rate, execution success rate, and code coverage. To address these issues, we propose RustTest, an LLM-based framework for automated Rust unit test generation. RustTest includes three stages: dataset fine-tuning, rich context-aware prompting, and post-processing optimization. In the first stage, we fine-tune an LLM on the constructed high-quality dataset. In the second stage, we construct rich, context-aware prompts that combine semantic intent (e.g., natural language descriptions and input-output examples) with structural information (e.g., callers, callees, and module metadata). In the third stage, we apply post-processing optimization techniques that leverage compiler feedback and coverage analysis to refine generated test cases. Experimental results on 230 focal methods from 85 real-world Rust projects show that RustTest outperforms state-of-the-art baselines, achieving a 135.1% improvement in compilation success rate, a 345.9% increase in execution success rate, and notable gains in both line and branch coverage. These findings highlight the effectiveness and practicality of RustTest for high-quality, executable, and semantically meaningful Rust unit test generation.
Organizations are increasingly adopting Participatory Reuse, an InnerSource practice where consumers of the reusable assets also contribute to their development and maintenance. While existing literature has reported various challenges, solutions, and lessons learned from organizations engaging in participatory reuse, a consolidated synthesis of these findings remains lacking. This study aims to collect and analyze the challenges, solutions, and lessons learned in participatory reuse from empirical works conducted within industrial settings. We conducted a case survey of 34 primary studies in 15 case organizations that have implemented participatory reuse practices. Based on the core characteristics of software reuse, we categorized the identified challenges, solutions, and lessons learned into three themes: developing reusable assets, using reusable assets, and managing participatory reuse. We organized the identified evidence as a catalog of participatory reuse challenges, solutions, and lessons learned. This catalog is intended to support both practitioners and researchers in identifying relevant strategies to address specific participatory reuse challenges within their organizations. We also pilot tested the catalog with four industry experts, who found it valuable in identifying solutions and lessons learned from the challenges.
As a key pre-processing step of software defect prediction, data transformation techniques aim to eliminate dimensional inconsistencies among software metrics and improve model performance. However, the impact of data transformation techniques on the performance of clustering-based unsupervised defect prediction (UDP) has not been fully explored. To this end, our aim is to empirically investigate the effect of data transformation techniques on the performance of clustering-based UDP models. In this paper, we systematically evaluated 23 unsupervised clustering models under 4 data conditions: (1) raw untransformed data (original), (2) logarithmic transformation, (3) z-score standardization, and (4) min-max normalization. Our experimental design consists of two dimensions: comparative analysis of individual models' performance before and after data transformation and evaluation of relative performance across different models under various transformations. Extensive experiments conducted on 22 software projects indicate that: (1) Data transformation techniques have significant potential to improve the performance of unsupervised clustering models. They achieve improvements of 6.9%-22.9% in AUC, 10.7%-41.6% in MCC, and 3.1%-12.2% in F measure@20%. However, these transformations lead to a degradation in IFA performance, which inevitably increases code inspection efforts but within tolerable operational thresholds. (2) The performance of unsupervised clustering models varies depending on the data transformation techniques used, with no single clustering model showing consistent superiority. Empirical findings indicate that data transformation techniques exhibit general effectiveness in clustering-based UDP models, and the choice of an unsupervised clustering model should align with the specific data transformation technique employed.
LLM-based Multi-Agent Systems (LLM-MAS) present an emerging paradigm for constructing intelligent and adaptive applications that enable autonomous reasoning and collaborative problem-solving. Empirical studies show that current LLM-MAS still suffers from overlapping agent roles, unclear capabilities, and goal misalignment. In contrast, Microservice Systems (MS) are designed with modularity, and each service encapsulates a well-defined context and interface with structured and deterministic execution. From the system architecture principles, these paradigms demonstrate parallel attributes and complementary strengths that lead to a synthesized hybrid architecture. In this paper, we analyze the design factors of hybrid MS and LLM-MAS, as well as the main challenges, through a comparative study across eight architectural dimensions, including function encapsulation, orchestration, API design, auto-correction, data communication, operations, quality attributes, and environment awareness. The analysis reveals critical mismatches, design synergies, and transferable best practices. To motivate future work, we define four research questions to categorize the challenges. The goal is to create a converging design space for exploring architecture design towards intelligent, autonomous, modular, and adaptive systems.
Decompilation is one of the key techniques in software reverse engineering and is widely used in security-related tasks such as malware analysis and vulnerability detection. Software is typically released in binary form with symbol information stripped. Although decompilers are capable of reconstructing a lot of the information lost during compilation, they often fail to recover meaningful variable names. As a result, the readability of the decompiled code is significantly reduced, severely hindering the efficiency of reverse analysis. To address this problem, we propose a novel variable name recovery approach ReDevar for the decompiled code based on Multi-task Learning (MTL), which takes variable name recovery as the main task and introduces two additional tasks, including data source prediction and name complexity prediction, corresponding to two aspects of semantic understanding and semantic transformation of variables in the decompiled code. Data source prediction simulates the data flow relationship among variable instances, assisting ReDevar better understand the semantics of variables. The name complexity prediction task enables ReDevar to perceive the complexity of the expected variable name at a mask position, obtaining appropriate semantic transformation results. They are both jointly trained with the variable name recovery task to improve the understanding of ReDevar for variable semantics and name composition. We conducted a series of experiments to validate the effectiveness of ReDevar. Experimental results show that ReDevar achieves top-1 accuracy of 54.44% on the VarCorpus benchmark dataset, 2.81% and 1.50% higher than the state-of-the-art approaches VarBERT and Resym respectively. In addition, we also evaluated the performance of ReDevar under various conditions, including different dataset splitting strategies, different decompilers, and different optimization levels. The results demonstrate that ReDevar generalizes well across all settings. Furthermore, the ablation study indicates that the two auxiliary tasks we introduced in ReDevar are both beneficial for the variable name recovery task.
Network protocol fuzzing faces significant challenges in exploring cross-state vulnerabilities due to the sparse reward problem in traditional coverage-guided approaches. Existing tools struggle with extremely low success rates that lead to uniform sampling and ineffective state space exploration. This paper presents SCSPFUZZ, a novel learning-based protocol fuzzing framework that employs Thompson Sampling with enhanced reward criteria and a conscious cross-state mutation engine to overcome these fundamental limitations. SCSPFUZZ employs a clustering mechanism based on syntactic similarity and protocolspecific state coverage to maintain a diverse seed pool, which reduces redundant executions and improves exploration. To tackle the sparse-reward problem, a seed-adaptive selection algorithm dynamically refines reward criteria for more effective guidance. Furthermore, a novel cross-state mutation strategy integrates fast seed crossover with an enhanced byte inference mechanism to boost deep state exploration. Together, the seed clustering mechanism, seed-adaptive selection algorithm, and cross-state mutation strategies enable effective state-aware fuzzing for network protocols. Evaluations on 11 real-world implementations from ProFuzzBench show an average 10.4% increase in code coverage and 14% more unique crashes compared to AFLNet, demonstrating its effectiveness.
Code idioms are widely recognized as common, reusable templates, patterns, or best practices in software development, which significantly enhance programming efficiency and code quality. In this work, we propose the CIMAS model, which adopts a modular framework to perform idiom mining in a structured and progressive manner. Specifically, CIMAS comprises four sub-modules: idiom representation identification, large-scale idiom code mining, idiom elements abstraction, and idiom judgment and synthesis with large language models. To validate the effectiveness of CIMAS, we apply the mined idiom repository to two downstream tasks: unit test generation and programming specification recognition. Experimental results demonstrate that code idioms effectively enhance semantics. The number of AST nodes increases by an average of 38.8% and 2 8. 4% for the two downstream tasks, respectively.
