event-driven programming

Static synchronization mechanisms in distributed systems impose severe scalability bottlenecks by enforcing strong consistency even in the absence of actual conflicts. This work introduces the “dynamic concurrency” paradigm—the first approach to perform fine-grained, runtime state–aware conflict detection: synchronization is triggered only when concurrent operations induce genuine dependency conflicts under the current data state. Methodologically, we design a state-aware, generic conflict predicate that integrates dynamic conflict detection with lightweight synchronization arbitration. Experimental evaluation shows that our approach significantly reduces redundant synchronization overhead, achieving 32%–68% higher throughput and 41% lower latency under typical distributed workloads, while preserving linearizability. The core contribution lies in elevating conflict detection from static, operation-level reasoning to dynamic, state-level reasoning—establishing a novel, efficient foundation for concurrency control in high-concurrency distributed systems.

This work addresses safety and liveness risks arising from the interplay between global protocols and locally optimized specifications in asynchronous multiparty session types. We propose the first precise and practical theoretical framework for asynchronous multirole session types. Our approach introduces a rigorously defined asynchronous multirole subtyping relation and formally establishes, for the first time, an asynchronous correspondence between global protocols and their local projections. We mechanically verify in Coq and Isabelle the soundness and completeness of this correspondence. Crucially, this correspondence serves as a system-level invariant: it guarantees type safety, deadlock freedom, and liveness—even when distributed components are developed independently and their actions are asynchronously reordered. The framework thus provides a foundational basis for compositional verification of asynchronous distributed systems.

This work investigates whether coordination is inherently required by specifications in distributed systems, independent of any particular protocol or implementation. Operating within the asynchronous message-passing model, it introduces a semantic characterization of coordination requirements based on the monotonicity of history extensions, leveraging Lamport’s happens-before partial order and the observable outcomes defined by the specification. Notably, this approach requires no assumptions about programming languages or protocols. The framework unifies and explains several foundational results—including CAP, CALM, snapshot consistency, and transaction isolation—by precisely delineating the boundary between specifications that can be implemented without coordination and those that fundamentally require it, thereby offering a cohesive theoretical foundation for distributed computing.

Distributed time-sensitive systems struggle to simultaneously ensure timeliness and consistency under communication delays and synchronization uncertainty. This work proposes the maxwait mechanism, which integrates classical approaches—including PTIDES, Chandy-Misra, Time-Warp, and Lamport-style failure detection—within a unified semantic framework through an explicitly configurable coordination policy. The mechanism provides bounded-time failure detection, determinism guarantees, and real-time behavior support for paradigms such as logical execution time, CRDTs, and Actors. Implemented as an extension of Lingua Franca, the approach ensures logical time consistency when communication delays remain within prescribed bounds and offers structured fault tolerance when they are exceeded, thereby significantly enhancing temporal control and robustness in multi-paradigm distributed systems.

Traditional typestate systems struggle to capture quantitative constraints—such as quorum requirements—and concurrent I/O behaviors inherent in distributed protocols, and they lack resilience to runtime network failures. This work proposes a probabilistic runtime verification approach that integrates mutable internal state, hybrid session mechanisms, and expected action ratios into an extended typestate model. The resulting framework enables dynamic modeling and monitoring of critical properties like concurrent message exchange and quorum satisfaction. Evaluated on commit and voting-based consensus protocols, the method effectively detects runtime behavioral deviations, significantly enhancing the expressiveness and practical applicability of typestate reasoning in distributed systems.

Informal Hoare-style reasoning in distributed systems lacks formal foundations, undermining its reliability and semantic correspondence with standard models—especially for compositional verification in Byzantine fault-tolerant settings. Method: We propose the Sync/Async dual-language framework, grounded in functional denotational semantics and trace-driven operational semantics. Leveraging monadic modeling and language compilation techniques, it rigorously compiles asynchronous fault-tolerant behaviors into synchronous programs while preserving safety properties across compilation. Contribution/Results: Our approach establishes, for the first time, a provably equivalent link between Hoare-style reasoning and formal semantics, enabling modular and compositional safety proofs. Implemented in the Rocq toolchain, it verifies the safety of BOSCO and SeqPaxos and generates executable code—demonstrating both theoretical soundness and practical applicability.

Existing swarm protocols lack compositionality, hindering modular development and code reuse in large-scale, complex systems. This work proposes a compositional approach grounded in a local-first, asynchronous communication model, establishing the first theoretical framework for compositional swarm protocols that enables independent component design, formal specification, and correct integration. By integrating formal methods, asynchronous event propagation, and local-first computation paradigms, the authors develop a verifiable protocol composition technique accompanied by an automated toolchain. This ensures that verified components retain global system correctness upon integration, substantially enhancing both development efficiency and system reliability.

This work addresses the limitations imposed by the FLP impossibility result on deterministic consensus in asynchronous systems by proposing an event-synchronized vector consensus algorithm. It distinguishes between data-independent and data-dependent consensus, uncovering three implicit assumptions underlying the FLP theorem and demonstrating that a key assumption lacks empirical support. By integrating an event-driven synchronization mechanism with formal verification and experimental evaluation, the proposed protocol achieves both safety and liveness in a fault-tolerant manner. Experimental results show that the algorithm tolerates single-node crash failures while effectively transcending the practical applicability boundary of the FLP impossibility result.

This work addresses the correctness challenges in implementing linearizable atomic registers in asynchronous message-passing systems, where precise real-time ordering of operations is unavailable. By combining equivalence and indistinguishability arguments with message-chain theory, the paper rigorously establishes that ensuring linearizability necessitates the formation of extensive message chains between operations of any type. This result formally characterizes, for the first time, the inherent communication overhead imposed by linearizability in asynchronous settings, thereby establishing a fundamental lower bound on the communication complexity required for its implementation. The findings provide a theoretical foundation for understanding the structural constraints and design costs associated with achieving linearizable semantics in distributed systems.