develop custom operators

Existing mutation operators for performance testing lack realism and fail to accurately reflect real-world performance regressions. Method: This paper introduces the first high-fidelity, performance-oriented mutation operator set, systematically derived from real-world performance regression cases through code change pattern mining. It integrates code change analysis, pattern abstraction and modeling, and empirically driven performance mutation testing, quantitatively evaluating execution time and memory overhead changes across multiple real systems. Contributions: (1) Establishes a causal mapping between code change patterns and performance degradation; (2) Bridges the gap in authenticity and practicality for performance mutation testing; (3) Provides a reusable operator set, an evaluation framework, and foundational support for anti-pattern identification—significantly enhancing performance defect detection capability and the rigor of test effectiveness assessment.

This work addresses the challenge of balancing precision and efficiency in static analysis for sharing and linearity in logic programs, where theoretically optimal abstract operators are often too complex to implement effectively. Building upon the PLAI analyzer in the CiaoPP preprocessor, this study presents the first implementation and integration of multiple optimal abstract operators for unification and matching within a real-world analysis framework. The authors systematically evaluate the impact of these operators on both analysis precision and runtime performance. Experimental results quantitatively demonstrate the accuracy gains achieved by enhancing operator precision alongside the associated computational overhead, offering crucial empirical evidence for navigating the trade-off between precision and efficiency in static program analysis.

This work addresses the high latency, cost, and limited scalability of existing semantic operator systems that rely on interpreted execution with frequent large language model (LLM) invocations. The authors propose a compiler-based approach to semantic operator execution, treating the LLM as a semantic compiler that, during a one-time compilation phase, translates its outputs into deterministic, executable code—thereby eliminating the need for repeated LLM calls at runtime. By integrating techniques from database query optimization, program synthesis, and LLM-driven data processing, the method substantially reduces both execution time and the number of LLM invocations while preserving high output quality. The approach has been successfully integrated into an existing system, demonstrating its practical viability.

Achieving efficient and general-purpose performance optimization remains challenging for systems operating under dynamic workloads and heterogeneous hardware. Method: This paper proposes an online automatic specialization framework that integrates runtime performance feedback with just-in-time (JIT) compilation to dynamically explore developer-defined specialization spaces—generating optimal specialized configurations without source-code modification or compromising generality. Contribution/Results: Its key innovation is the first integration of a lightweight online search strategy into the JIT pipeline, enabling low-overhead, continuously evolving specialization decisions. The framework supports cross-platform, multi-granularity (function- and module-level) specialization while avoiding the inflexibility inherent in traditional offline specialization. Experimental evaluation on real-world systems demonstrates an average performance improvement of 23.6%, while preserving interface compatibility and developer friendliness.

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 frequent neglect of sampling strategy design and generalizability in software engineering research, which often undermines the representativeness of empirical findings. To remedy this, the paper introduces a domain-specific language (DSL) that explicitly models complex sampling workflows over code repositories through composable sampling operators, enabling—for the first time—formal specification and reasoning about the generalizability of sampling strategies. Implemented as a fluent Python API, the DSL is integrated with a statistical metric system to quantitatively assess the external validity of sampled datasets. The authors demonstrate the expressiveness and practical utility of their approach by reconstructing and formalizing the sampling procedures from multiple Mining Software Repositories (MSR) studies, thereby validating the framework’s capacity to capture real-world methodological diversity.

Modern software systems suffer performance degradation and increased operational costs due to suboptimal parameter configurations across multi-layer runtime stacks—including virtualization, storage, and trusted execution environments (TEEs). Existing tuning tools are typically domain-specific, single-layer, or constrained to fixed optimization objectives, rendering them ill-suited for startups and innovative ventures (SIVs) with resource constraints, customized technology stacks, and limited expert expertise. This paper introduces the first general-purpose, cross-layer, cross-domain, multi-objective parameter tuning framework. It requires no prior knowledge, supports black-box evaluation and incremental optimization, and synergistically integrates Bayesian optimization, multi-objective evolutionary algorithms, and meta-learning to dynamically model parameter–performance relationships in heterogeneous environments. Evaluated on real-world deployments and standard benchmarks, the framework consistently improves performance, reduces resource consumption, and demonstrates strong generalizability and deployment robustness.

This work addresses the challenge that existing AI systems struggle to dynamically observe, intervene in, and optimize agent behavior at runtime, making it difficult to simultaneously achieve high task success rates, low latency, token efficiency, reliability, and safety. To overcome this limitation, the paper proposes a novel runtime infrastructure layer situated between the model and the application, which treats the AI execution process itself as an optimizable object—departing from conventional approaches that restrict optimization to static model or log-level adjustments. This layer enables proactive intervention and multi-dimensional performance co-optimization through mechanisms such as runtime monitoring, real-time inference, adaptive memory management, fault recovery, and policy enforcement. Experimental results demonstrate that the proposed approach significantly enhances the holistic performance of long-horizon agent workflows across task success rate, response latency, token efficiency, system reliability, and safety compliance.

This work addresses the fragility, inefficiency, and strong platform coupling commonly found in CI/CD pipelines for legacy COBOL systems, which often result in high maintenance costs and vendor lock-in. To overcome these challenges, the authors propose a portable CI/CD architecture tailored for highly secure and compliance-driven environments. The approach leverages OCI-compliant container images preloaded with COBOL toolchains, introduces a platform abstraction layer, integrates multiple repositories, and employs Groovy script refactoring to achieve platform-agnostic continuous integration and delivery. Empirical evaluation demonstrates that the proposed solution significantly enhances efficiency—reducing pipeline execution time by 82%—while simultaneously improving system portability, security, and maintainability. This architecture offers a reusable paradigm for modernizing legacy COBOL applications within regulated domains.