Declarative, Secure, Convergent Edge Computation

Eventual consistency is a more natural model than strong consistency for a distributed system, since it is closer to the underlying physical reality. Therefore, we propose that it is important to find a programming model that is both congenial to developers and supports eventual consistency. In particular, we consider that a crucial test for such a model is that it should support edge computation in a both natural and secure way. We present a preliminary work report with an initial solution, called Lasp, which resembles a concurrent functional language while naturally supporting an eventually consistent coordination-free distribution model.

💡 Research Summary

The paper argues that eventual consistency, rather than strong consistency, more accurately reflects the physical realities of distributed systems and therefore should be the foundation of a developer‑friendly programming model that also supports secure edge computation. Traditional client‑server architectures place the data centre at the centre of computation, forcing edge devices to either buffer data until connectivity returns or to stop generating data altogether. This approach is increasingly untenable because edge devices have limited storage, power, and may experience frequent disconnections, yet many applications (e.g., a hospital refrigerator temperature monitor) require timely local decisions.

To overcome these limitations the authors propose a paradigm in which each client owns a replica of its data, performs local mutations, and disseminates updates peer‑to‑peer. However, replicating state without a total order introduces the classic problem of concurrent modifications. Systems such as Amazon Dynamo accept this trade‑off by providing only eventual delivery and leaving conflict resolution to the application. The authors contend that a more principled solution can be built on Conflict‑Free Replicated Data Types (CRDTs), which guarantee convergence under any order of message delivery because their merge operations are associative, commutative, and idempotent.

The core contribution is Lasp, a language and runtime that combines declarative functional programming with CRDTs. In Lasp, data structures are expressed as CRDTs, and program composition is purely functional, allowing developers to write distributed applications without explicit coordination. The runtime uses an epidemic (gossip‑based) dissemination protocol, which tolerates out‑of‑order and duplicate messages and continues to make progress even when parts of the network are partitioned.

Two critical challenges are identified: (1) Causality – the ability to track which inputs produced a given computation result, enabling incremental maintenance and merge of partial results; and (2) Security – ensuring that edge devices can contribute to a global computation without revealing their raw data. The paper proposes embedding causality metadata in the output of CRDT‑based computations, allowing later merges to be performed deterministically. For security, the authors explore order‑preserving encryption (OPE) as a way to compare encrypted values (e.g., temperature thresholds) without decrypting them, thereby protecting privacy while still supporting useful aggregation.

The paper surveys related work, noting that many existing systems (MapReduce‑style stream processors, Directed/Digest Diffusion, Tiny Aggregation) either target specific domains or lack a general programming model. Lasp distinguishes itself by offering a Turing‑complete, declarative language that abstracts away low‑level replication details while still guaranteeing convergence.

In the conclusion, the authors acknowledge open problems: extending causality support beyond a limited set of operations, reducing the overhead of metadata and encryption, and validating performance at planetary scale. Nonetheless, they present Lasp as a promising step toward a natural, secure, and convergent model for edge computation that aligns with the eventual‑consistency reality of modern distributed systems.