systems integration

This study addresses the imbalance in the test pyramid—characterized by an overreliance on coarse-grained integration and system tests, which leads to difficulties in fault localization and slow execution—by proposing, for the first time, a method to automatically generate unit tests from existing integration tests. The approach combines static and dynamic analysis to automatically isolate component dependencies and enhance coverage at the unit level. Implemented as a Node.js tool and evaluated on twelve open-source JavaScript projects, the technique produces high-quality unit tests that significantly improve test suite structure, thereby increasing both testing efficiency and maintainability.

Current tool-augmented large language model (LLM) ecosystems suffer from fragmentation—characterized by coexisting heterogeneous protocols (e.g., OpenAI Function Calling, Toolformer), manual schema definition, and complex execution orchestration—leading to low development efficiency and high integration overhead. To address this, we propose a protocol-agnostic unified tool integration framework. Our approach introduces an abstract protocol layer for cross-standard compatibility, an automated schema inference mechanism to eliminate manual specification, and a dual-mode concurrent scheduler enabling seamless synchronous and asynchronous tool execution. Experimental evaluation demonstrates that, compared to baseline approaches, our framework reduces implementation code volume by 60–80%, achieves up to 3.1× improvement in end-to-end execution latency, and maintains full backward compatibility with mainstream LLM tool-calling ecosystems.

Existing LLM orchestration scripts suffer from insufficient modularity and limited parallelization capabilities. To address these issues, this paper proposes an abstract framework grounded in algebraic effects and composable effect handlers, which decouples side effects—such as LLM invocations, I/O operations, and concurrency—into replaceable, composable effect interfaces. This design enforces a strict separation between workflow logic and execution details, preserving code clarity and maintainability while natively enabling fine-grained parallel scheduling and optimization. Evaluated on Tree-of-Thoughts reasoning tasks, the framework achieves a 10× end-to-end performance improvement over baseline approaches. Results demonstrate that the method effectively enhances execution efficiency without compromising modularity, confirming its validity and broad applicability across LLM-driven workflows.

Rigid activity implementation binding in digital business processes hinders adaptation to heterogeneous organizational requirements. Method: This paper proposes a three-level dynamic binding mechanism—operating at compile time, launch time, and runtime—that enables concurrent execution of multiple implementations for the same activity and supports context-aware, dynamic customization of input/output data contracts. Integrating Software Product Line (SPL) engineering with Process-Aware Information Systems (PAIS), we develop a variability modeling and runtime feature configuration framework. Contribution/Results: Our approach achieves, for the first time, end-to-end flexible activity binding across the full process lifecycle. It overcomes the limitations of conventional single-version, static binding by enabling on-demand composition of diverse activity implementations and data interfaces within a unified process model. This significantly enhances the adaptability and configurability of process systems in multi-organizational settings.

This work addresses the inherent limitations of individual program analysis techniques—particularly their constrained precision, coverage, and insight—which hinder comprehensive software reliability assurance. Through a systematic mapping study of 248 relevant publications, the paper presents the first taxonomy of combined program analysis approaches explicitly centered on synergistic effects and interaction patterns. The proposed multidimensional classification framework is structured around three core dimensions: collaboration objectives, workflow architectures, and types of mapping functions. This framework systematically uncovers commonalities and distinctions in the design of existing methods, offering a clear conceptual foundation for understanding, comparing, and developing novel combined analysis techniques. Furthermore, it delineates current research trends and identifies promising directions for future investigation.

This work addresses the limitations of traditional structural coverage metrics in embedded software testing, which are often confined to the unit level and fail to reflect true coverage completeness in integration and system testing. Instrumentation-based approaches risk perturbing runtime behavior, while pure tracing techniques suffer from unreliability under high compiler optimization. To overcome these challenges, the paper proposes an integration-test-driven coverage strategy featuring a novel “integration-first” closed-loop workflow. By synergistically combining embedded tracing with hybrid runtime analysis (hRA) to preserve semantic boundaries, and leveraging source-to-target mapping for evidential traceability alongside Hyper Coverage for cross-variant merging, the approach establishes a unified evidence-integration mechanism. Evaluated on -O3-optimized release binaries, it reliably achieves branch, condition, and MC/DC coverage measurements and precisely identifies source code lines consistently uncovered across all variants, thereby significantly enhancing confidence in the test completeness of embedded systems.

This work addresses the limitations of existing join pattern implementations, which often rely on domain-specific languages and exhibit rigid, inflexible matching algorithms that hinder integration into general-purpose programming ecosystems. To overcome these challenges, we propose and implement JoinActors—a modular and extensible join pattern matching library built on Scala 3. JoinActors is the first library to support join patterns natively within a general-purpose language, offering an intuitive API powered by metaprogramming and incorporating fair join semantics. Its key innovation lies in enabling plug-and-play support for multiple matching algorithms, facilitating direct performance comparisons. Experimental results demonstrate that the new implementation significantly improves performance while preserving matching correctness, thereby providing an efficient coordination mechanism for complex message-passing systems and establishing a reusable experimental platform for future research on join patterns.

This work addresses the limited reusability and evolvability of existing software product line (SPL) engineering approaches, which are typically tied to specific technology stacks and integrated development environments (IDEs). To overcome this constraint, the authors propose a workspace-agnostic protocol that incrementally extracts feature models from lightweight dependency units called “atoms.” The approach introduces a configuration and generation architecture comprising a generic SPL server and pluggable clients—each combining a universal frontend with a specialized backend. This design decouples SPL engineering from underlying technical spaces, enabling flexible, cross-language and cross-IDE component substitution. A prototype implementation, with a Go/Prolog-based server, a Java backend, and a JavaScript frontend, was validated on Neverlang language artifacts, demonstrating the protocol’s generality, reusability, and independence from specific development workspaces.

This work addresses the limitations of traditional workflow platforms, which rely on static, pre-defined processes and struggle to accommodate the dynamic data integration demands of distributed systems. To overcome this, the authors propose a configuration-driven runtime orchestration framework that dynamically constructs execution graphs at request time through dependency-aware scheduling and parallel task execution, thereby circumventing the constraints of fixed workflows. This approach enables rapid adaptation to evolving integration scenarios without requiring system redeployment, significantly reducing latency. Empirical evaluation in a real-world Customer 360 enterprise use case demonstrates that the framework offers substantial advantages in flexibility, scalability, and efficient data aggregation compared to conventional solutions.