implement state tracking

This paper addresses the challenge of cross-version evolution of persistent objects in Multi-Schema Version Data Management (MSVDM). To this end, it proposes an abstraction-level evolution language specifically designed for persistent objects. The language uniformly specifies model-level changes—including class hierarchy refactoring and field addition/removal—and coordinates with database schema evolution, thereby enabling, for the first time, semantics-preserving evolution of class inheritance structures. By decoupling abstract evolution logic from concrete ORM implementations (e.g., JPA), the approach achieves generic adaptability across diverse persistence mechanisms. Formal semantic modeling and theorem proving guarantee correctness of evolution behavior. Empirical evaluation across three open-source project histories validates coverage of mainstream evolution operations. The work delivers a verifiable, extensible language framework and practical foundation for coordinated structural evolution of data in multi-version coexistence scenarios.

Shared state profoundly influences the performance and fault tolerance of stream processing, service-oriented, and continual learning systems, yet existing approaches often treat access control, hardware-aware execution, memory management, and long-term evolution in isolation. This work reframes state management as a runtime control problem and introduces a contract-driven blueprint centered on state objects, control planes, coupling paths, evaluation boundaries, and pending contracts. Building upon this foundation, we develop a unified analytical framework encompassing state-access scheduling, state-aware execution, and state evolution reuse. Through systematic scheduling, runtime control, and cross-layer coupling analysis, our approach identifies critical anti-patterns and advances a perturbation-aware evaluation paradigm, thereby establishing both theoretical foundations and practical design guidelines for state control in distributed systems.

In software design, paradigm-implied semantic expectations—such as data abstraction consistency and feedback-control closed-loop behavior—are often left implicit, leading to design deviations and verification challenges. To address this, we introduce the concept of *design obligations*: explicit, logically formalizable, and verifiable specifications that codify such implicit constraints inherent to design paradigms. Leveraging formal modeling and paradigm semantics analysis, we establish two obligation frameworks—one for data-abstraction-based systems and another for feedback-driven adaptive systems—precisely capturing their core semantic requirements. We demonstrate that common design flaws stem from obligation violations and show how these obligations enable rigorous compliance verification and pedagogical application. This work bridges the semantic gap between design intent and implementation, providing both theoretical foundations and a methodological framework for paradigm-driven design assurance.

Dynamic Software Updates (DSUs) reduce downtime, improve security, and accelerate iterative development; however, existing research lacks systematic, empirical comparisons of DSU techniques in the Java ecosystem—particularly regarding supported code-change types and associated runtime resource overhead. Method: This paper presents the first cross-cutting evaluation of mainstream Java DSU mechanisms—including bytecode hot-swapping, class redefinition, and proxy injection—using micro-benchmarks and system-level monitoring to quantify CPU and memory overhead across representative change scenarios (e.g., method body modification, field addition/removal). Contribution/Results: We propose a “change capability–resource cost” analytical framework that empirically correlates update expressiveness with runtime overhead, filling a critical gap in evidence-based DSU comparison. Our findings provide data-driven guidance for industry practitioners selecting lightweight, secure, and evolution-aware hot-update solutions aligned with real-world maintenance requirements.

This work addresses the challenge of seamless evolution in distributed systems undergoing backward-incompatible software updates by proposing a novel approach that models application code and its semantic versioning as an App CRDT (Conflict-Free Replicated Data Type). Coupled with an API-compatible message middleware, this mechanism enables the system to remain operational even when only a subset of its components has been updated. The study pioneers the application of CRDT principles to the dynamic replication and management of executable code, effectively tolerating backward-incompatible changes while preserving system availability. The method is implemented in the AmbientTalk language with minimal modifications to existing applications and further validated for cross-language applicability through integration with the LuAT framework.

This work addresses the challenge of effectively evaluating the trade-offs between data consistency and coordination overhead among distributed transaction patterns—such as Saga and TCC—in business logic-intensive microservice systems prior to production deployment. The authors propose a lightweight microservice simulator grounded in Domain-Driven Design (DDD), which, for the first time, integrates DDD aggregate root modeling with multiple transaction models to decouple business logic from communication and transactional infrastructure. The framework supports configurable deployment topologies and network constraints, enabling seamless transitions from centralized to fully distributed architectures while providing a deterministic verification environment. Empirical evaluation on complex multi-aggregate systems quantifies the performance, coordination overhead, and resilience of different transaction models, substantially reducing development costs and facilitating left-shifted architectural validation.

Databases continuously evolve through operations such as schema changes, version updates, and data transformations; however, existing approaches typically address these functionalities in isolation, lacking a unified abstraction. This work proposes the first integrated model that unifies continuous schema evolution, version management, and data transformation within a single framework. Built upon general-purpose computational primitives, the model supports operation provenance, conditional update propagation, and change alerts, while employing a declarative mechanism to manage the co-evolution of dependent artifacts—including views and machine learning models. A prototype system implements this framework using an enhanced, parameterized Prolly Tree—a Merkle tree–inspired data structure—to construct a relational-like engine. Experimental evaluation demonstrates that the proposed approach is both feasible and offers tunable performance across diverse evolution scenarios.

This study addresses the critical gap in governance of persistent state—such as memory, credentials, and commitments—in long-running large language model agents, particularly concerning recoverability, auditability, and controlled deprecation. Through a systematic review of 435 publications, the work introduces the first comprehensive model of agent persistent state, integrating multidimensional elements including task logs, credentials, and commitments. Building on this foundation, it proposes AOEP-v0, an evaluation protocol grounded in six dimensions: authoritativeness, scope, mutability, provenance, recoverability, and operability. Distinct from prior approaches that prioritize response quality alone, AOEP-v0 explicitly centers on obligations surrounding state modification and recovery, establishing the first cross-domain governance benchmark for the reliability and controllability of always-on intelligent agents.

This work addresses the longstanding challenge in large-scale data processing pipelines of simultaneously achieving low cost, high performance, and strong scalability. The authors propose ASAP (Application Semantic-Aware Processing), a novel paradigm that, for the first time, treats semantic preservation as a first-class design principle across all stages of the data lifecycle. ASAP unifies semantic-aware processing primitives in data ingestion, transmission, storage, and analytics. By integrating techniques such as approximate query processing (AQP), sketching, compression, and aggregation, ASAP enables cross-stage co-optimization and cross-domain technique reuse. Experimental evaluation demonstrates that ASAP significantly improves the cost–speed–scalability (CSP) trade-off across multiple real-world applications, yielding performance gains of up to three orders of magnitude.