component isolation techniques

Randomized controlled trials (RCTs) are often infeasible in software engineering, hindering rigorous causal assessment of tools, processes, or guidelines on development outcomes (e.g., efficiency, quality, user experience). Method: We propose a statistical causal inference methodology grounded in observational data, integrating the potential outcomes framework, propensity score matching, and difference-in-differences to systematically address confounding bias and selection bias. Contribution/Results: This work pioneers the systematic application of formal causal inference paradigms to requirements engineering and software practice research, tailoring analytical workflows and evaluation criteria to the characteristics of software engineering data. Empirical validation demonstrates that our approach substantially improves internal validity and reproducibility of causal conclusions in non-experimental settings. By enabling robust, evidence-based causal claims from real-world development data, it strengthens the empirical foundation for translating research findings into industrial practice.

Current research on the security of execution environments for AI coding agents remains highly fragmented, lacking systematic integration and cross-disciplinary coordination. This work presents the first comprehensive survey of the field, analyzing 39 papers published between 2023 and 2026 and categorizing them into 17 thematic groups. Through CVE validation, cross-category comparison, and threat modeling, the study identifies critical disconnects among key areas such as isolation, access control, and time-of-check-to-time-of-use (TOCTOU) vulnerabilities, revealing five major research gaps. The analysis confirms four patched CVEs affecting production frameworks, quantifies the failure rate of existing mitigation strategies at 69%–98%, and uncovers that 17.1% of benign out-of-bound behaviors remain unaddressed by current mechanisms. Building on these findings, the paper proposes a unified research agenda to advance the field.

This work addresses the vulnerability of build system code to poisoning attacks, which pose a critical threat to software supply chain security. While existing tools primarily focus on application source code, they largely overlook the security of the build process itself. To bridge this gap, we propose a novel paradigm—“development-phase isolation”—that, for the first time, incorporates build scripts into the scope of security analysis. By leveraging information flow tracking and behavioral privilege modeling, our approach enables fine-grained monitoring of build-time code execution. We implement this methodology in a prototype tool, Foreman, which effectively detects anomalous and malicious behaviors within build scripts. In real-world evaluations, Foreman successfully identified the poisoned test files used in the recent XZ Utils supply chain attack, demonstrating both the efficacy and practicality of our approach.

Rust’s memory safety relies on its ownership system, yet `unsafe` code can bypass these checks, introducing critical security vulnerabilities. Existing isolation approaches support only static, fixed-boundary sandboxing of `unsafe` modules, lacking flexibility for dynamic, fine-grained co-sandboxing of safe and unsafe code. This paper proposes a lightweight, syntax-aware dynamic isolation mechanism for Rust: leveraging zero-cost abstractions and fine-grained sandbox partitioning, it enables runtime-configurable cross-safety-domain policies; combined with optimized data transfer, it significantly reduces inter-sandbox call overhead. Evaluated on multiple real-world Rust applications, the mechanism effectively contains vulnerability propagation while incurring an average performance overhead of less than 8.2%. It thus achieves a practical balance among security assurance, usability, and backward compatibility.

To address the high runtime overhead imposed by instrumentation-based sanitizers in fuzzing, this paper proposes a lightweight, on-demand detection framework that decouples taint analysis from the fuzzing loop. Methodologically, it introduces (1) a novel execution-mode analysis to precisely identify inputs with potential vulnerability-triggering behavior; (2) dynamic deferred scheduling of sanitizer invocations—enabling sanitizer-augmented builds only for “interesting” inputs; and (3) a synergistic integration of lightweight execution trace capture, pattern matching, and conditional triggering, ensuring compatibility with multiple sanitizers including ASan and UBSan. Implemented atop AFL++, the framework demonstrates superior vulnerability discovery—outperforming all baseline fuzzers across 12 real-world programs within 24 hours—while achieving zero missed detections on known bugs. Crucially, it reduces average overhead by several orders of magnitude compared to conventional sanitizer-integrated fuzzing.

This work addresses the security risks associated with executing industrial control software on unauthorized hardware, a challenge inadequately mitigated by conventional protection mechanisms that often fail to balance security and functional correctness. The authors propose a novel hardware-software binding approach that integrates Physical Unclonable Functions (PUFs) with symbolic execution to enforce program behavior constraints and verify critical security properties. This method ensures that the software operates correctly only on authorized target devices while maintaining secure behavior—even in the presence of unauthorized execution environments or PUF failures. Notably, this study is the first to leverage symbolic execution for preserving software security properties under anomalous execution conditions, thereby achieving a robust combination of strong anti-reverse-engineering capabilities and high reliability.

Static analysis struggles to reconstruct complete control flow graphs for binaries employing dynamic loading techniques—such as packed programs and modern malware—due to unresolved indirect calls. This work proposes a novel approach that integrates symbolic execution with speculative library preloading. By deploying custom hooks during symbolic execution, the method intercepts dynamic loading operations in real time, speculatively preloads required libraries, and synchronously tracks instructions while managing intercepted functions—all without executing potentially malicious code. Consequently, it safely recovers accurate control flow graphs. Experimental evaluation on 16 synthetic benchmarks demonstrates that, compared to pure static analysis, the proposed technique recovers on average 29.8% more nodes and 26.5% more edges, while achieving 100% precision and recall in library identification.

This work addresses the limitations of current safety evaluations for large language model–based agent tool use, which often rely solely on attack success rates and fail to distinguish between semantic compliance, auditable evidence of harm, and actual sandbox-observable damage. To overcome this, we introduce SafeClawBench, a novel benchmark that decouples safety assessment into three dimensions: semantic acceptance, auditable harmful evidence, and sandbox-observable harm. The benchmark comprises 600 adversarial tasks spanning six attack categories. Leveraging adversarial task design, a multi-endpoint evaluation protocol, an executable sandbox environment, and four prompting strategies, we conduct systematic experiments across five mainstream agent models. Results reveal semantic failure rates ranging from 9.0% to 44.2%, with 291 out of 347 sandbox harms occurring in cases that passed semantic checks, thereby validating the necessity and effectiveness of the proposed tripartite evaluation framework.

This work proposes CausalSE, a novel framework that systematically integrates structural causal models (SCMs) with propensity score matching to rigorously identify the true causal effects of interventions—such as prompt engineering—on large language model code generation performance. Addressing a critical limitation in traditional software engineering empirical studies, which often rely on statistical associations vulnerable to confounding bias, this study introduces Pearl’s causal inference paradigm into the field. Empirical evaluation on the Galeras dataset reveals that while conventional association-based analyses suggest complex prompts improve performance, causal analysis under CausalSE finds no significant treatment effect, thereby exposing false-positive conclusions arising from unaccounted confounders. The paper further provides a reproducible methodology for causal inference in software engineering contexts.

This work addresses the prevalence of erroneous conclusions in scientific experimental design due to overlooked confounding variables and the absence of formal verification methods meeting the rigorous standards of programming language communities. It presents the first probability-free semantic characterization of the d-separation criterion in causal inference, establishing its equivalence to non-interference semantics from security theory. By integrating graph theory, formal semantics, and program analysis, the authors mechanize this result in the theorem prover Rocq, thereby formally verifying the semantic correctness of d-separation. This foundational contribution enables automated, falsifiable, and formally verifiable modeling of real-world systems, offering a principled basis for assessing the quality of experimental designs.

This study investigates the causal impact of adopting agent-based AI programming tools on software architecture quality, with a focus on changes in architectural smell density. Leveraging a dataset of 151 Java open-source repositories, it extends causal inference frameworks from the code level to the architectural level for the first time. The analysis integrates the Arcan tool for smell detection, a staggered difference-in-differences design, the Borusyak imputation estimator, and multiple robustness checks. Results indicate that while the total number of architectural smells shows no significant change post-adoption (+1.1%, p=0.82), code volume increases substantially (+12.8%, p=0.003), leading to a 6.7% reduction in smell density (p=0.004). This apparent improvement stems from denominator inflation—i.e., increased code size—rather than genuine architectural enhancement.