Bloom Language

Declarative, Dedalus-based language for distributed programming (Alvaro, Conway, Hellerstein, Marczak) in which state is modelled as relations and computation as monotonic rules over them. Bloom ships a syntactic monotonicity check — programs written in the monotonic subset are guaranteed by the CALM Theorem to be eventually consistent and coordination-free.

Non-monotone operators (<-, aggregates over closed sets, deletions) are visible at the type level, giving the programmer / compiler a “bright line” for where coordination is required.

In this vault

Backlinks

Relational Transducer line 12
Coordination Avoidance line 20
Coordination Avoidance line 9
CALM Theorem line 24
Keeping CALM - When Distributed Consistency is Easy line 41
Keeping CALM - When Distributed Consistency is Easy line 27
Keeping CALM - When Distributed Consistency is Easy line 10
Dedalus line 8
Dedalus line 3

Linked Pages

Relational Transducer

Ameloot-Neven-Van den Bussche formalisation of a distributed program node: a relational event-loop server that, on each tick, (1) ingests an unordered batch of insert/delete requests into local relations, (2) queries the updated relations (a monotonic relational query: selection, projection, join, union, transitive closure), and (3) sends results as messages to other machines and outputs.

A relational transducer network distributes data across machines of this shape. The CALM Theorem is proved over this model: a query has a coordination-free evaluation plan on such a network iff the query is monotone.

In this vault

Coordination Avoidance

The design discipline of eliminating synchronisation (locks, quorums, consensus rounds) wherever a computation can be proved correct without it. The CALM Theorem makes this precise: coordination is avoidable exactly for monotonic programs.

Practical techniques:

Build from monotonic primitives (CRDTs, set unions, counters-up-only)
Use Immutable Data Structures and Tombstones to convert mutation into monotonic history
Isolate the non-monotonic boundary (e.g. a shopping-cart checkout) and coordinate there only
Program in a language like Bloom Language that makes monotonicity syntactically checkable

Contrasts with storage-consistency work (linearizability, serializability) which enforces coordination inside the storage layer regardless of program shape.

In this vault

Monotonic Logic

A logic in which the conclusion set grows monotonically with the premise set: adding information never retracts a conclusion. Formally, a program P is monotone if S ⊆ T ⟹ P(S) ⊆ P(T).

Monotone relational operations: selection, projection, intersection, join, transitive closure. Non-monotone: universal quantification, set difference, aggregates with totality assumption, Negation as Failure.

In distributed systems, monotonicity is the load-bearing property behind the CALM Theorem: monotone programs are safe under arbitrary message reordering and partial delivery, because no conclusion ever has to be taken back.

In this vault

Dedalus

Temporal Datalog variant (Alvaro, Marczak, Conway, Hellerstein, Maier) designed as a formal model of state and time in distributed computation. Tuples carry a logical timestamp; rules are partitioned into deductive (same-time), inductive (next-time), and asynchronous (non-deterministic-time). Dedalus is the logical basis of Bloom Language and the substrate on which the CALM Theorem is proved for programmable systems.

In this vault

CALM Theorem

Consistency As Logical Monotonicity (Hellerstein 2010 conjecture; Ameloot, Neven, Van den Bussche 2013 proof). A distributed program has a consistent, coordination-free implementation if and only if it is expressible in monotonic logic.

Monotonic programs produce a set of outputs that only grows as inputs arrive (S ⊆ T ⟹ P(S) ⊆ P(T)). Such programs are safe under missing information: any conclusion reached on a subset of inputs remains valid when more arrive. Non-monotonic programs may retract earlier conclusions, so they must wait for “all the news” — which is what distributed coordination enforces.

CALM is the positive counterpart to the CAP Theorem: it names the exact class of programs that can satisfy Consistency, Availability, and Partition-tolerance simultaneously.

Why it matters

Moves consistency from a property of storage (linearizability, serializability) to a property of programs — Confluence.
Tells programmers what kinds of features are free (monotonic: set union, counting up, set-containment) and what must be paid for (non-monotonic: set difference, strict aggregation, count-exact, deletions without tombstones).
Gives a design rule for coordination-free systems: build from monotonic primitives — CRDTs, Immutable Data Structures, Tombstones, monotonic accumulators — and only add coordination at non-monotonic boundaries.

Formal statement

Using Relational Transducer networks as the execution model and Confluence as the consistency criterion, Ameloot et al. prove: a query Q has a coordination-free distributed evaluation plan iff Q is monotone.

In this vault

Keeping CALM - When Distributed Consistency is Easy — the definitive survey
CAP Theorem
Confluence
Monotonic Logic
Coordination Avoidance
Relational Transducer
Bloom Language
Dedalus
CRDTs
Non-monotonic Reasoning

Keeping CALM - When Distributed Consistency is Easy

Keeping CALM: When Distributed Consistency is Easy

Reference: Joseph M. Hellerstein & Peter Alvaro (2019). arXiv:1901.01930v2. Source file: ../1901.01930v2.pdf (in parent directory). URL

Summary

An accessible, updated statement of the CALM Theorem — Consistency As Logical Monotonicity: a program has a consistent, coordination-free distributed implementation if and only if it is monotonic in a formal logical sense. Monotonic programs are “safe” under missing information and can proceed without waiting: once something has been concluded, it stays concluded. Non-monotonic programs (“change their mind” in the face of new inputs) are necessarily order-sensitive and therefore require coordination to produce a single deterministic outcome.

CALM is a positive counterpart to the negative results of the CAP Theorem and the FLP impossibility. Where CAP says “you can’t always have it all”, CALM delineates the class of programs that can in fact satisfy all of C, A, and P simultaneously: exactly the monotonic ones. The theorem shifts attention away from storage consistency (linearizability, serializability) toward program consistency — Confluence: deterministic outcomes despite non-deterministic message delivery and ordering.

The paper traces the theorem’s implications for Bloom Language, Dedalus, CRDTs, coordination-free design patterns (monotonic accumulation, tombstones, immutable data), distributed garbage collection, and Amazon’s shopping-cart example. It closes with open questions: expressiveness of monotonic languages, program synthesis targeting monotonicity, repair of non-monotonic code, and a possible Stochastic CALM for near-optimum stochastic algorithms.

Key Ideas

Monotonicity ⇔ coordination-freeness ⇔ consistency (CALM)
Program consistency = confluence: same outputs regardless of message order / batching
Non-monotonic operations retract earlier conclusions, hence must wait for “all the news” — requiring Coordination Avoidance logic to know when
Formalisation via Relational Transducer networks (Ameloot, Neven, Van den Bussche)
CAP is a special case: linearizable storage is one non-monotonic operation; CALM asks the question across all programs
Practical playbook: immutable data structures, tombstones, set-monotonic accumulation, CRDTs as object-oriented monotonic types
Bloom gives syntactic monotonicity checking — a programmer writing monotonic Bloom is guaranteed coordination-free correctness

Connections

Conceptual Contribution

Claim: A distributed program is consistent and coordination-free iff it is expressible in monotonic logic — a tight, provable characterisation that converts “distributed consistency is hard” into a precise question about a program’s logical shape.
Mechanism: Formalise programs as networks of Relational Transducers (Ameloot et al.); define Confluence as program-level determinism under non-deterministic delivery; prove biconditional between confluence and monotonic-logic expressibility.
Concepts introduced/used: Monotonic Logic, Confluence, Coordination Avoidance, Relational Transducer, Bloom Language, Dedalus, CRDTs, CAP Theorem, Immutable Data Structures, Tombstones, Stochastic CALM
Stance: foundational / survey
Relates to: Provides the theoretical companion to the Gossip Protocols cluster (Gossip-Based Computation of Aggregate Information, Gossip-based Aggregation in Large Dynamic Networks) — gossip aggregation with mass conservation is exactly a monotonic accumulation, hence coordination-free. Frames why Extensible Distributed Coordination must reach for stored-procedure coordination precisely where programs are non-monotonic. Contrasts with Are Multiagent Systems Resilient to Communication Failures: that paper shows game-theoretic MAS are brittle under message loss — CALM identifies the logical class of programs immune to such loss. The monotonic/non-monotonic split echoes Foundations of Logic Programming - Lloyd’s distinction between Horn-clause logic and Negation as Failure.