Immutable Data Structures

Data whose values never change after construction — state updates create new values rather than mutating existing ones. Immutability is a monotonic discipline: the set of values in existence only grows. It is one of the practical design patterns the CALM Theorem motivates for coordination-free distributed systems, alongside Tombstones and CRDTs.

Functional-programming heritage (persistent trees, zippers, deforestation) carries directly into the distributed setting: immutable logs, append-only storage, event-sourced architectures, deforested pipelines.

In this vault

Backlinks

Tombstones line 12
Coordination Avoidance line 7
concept-map line 110
CALM Theorem line 12
Keeping CALM - When Distributed Consistency is Easy line 41

Linked Pages

Programming Erlang Second Edition

Programming Erlang: Software for a Concurrent World (Second Edition)

Reference: Armstrong, J. (2013). The Pragmatic Bookshelf. Source file: cbcl-ref/programming-erlang-2nd-edition.pdf. URL

Summary

Joe Armstrong’s second-edition textbook introduces Erlang as a language and runtime for building highly concurrent, distributed, and fault-tolerant systems. Part I motivates concurrency and tours the shell, modules, and compilation. Part II teaches sequential Erlang: atoms, tuples, lists, pattern matching, funs, records/maps, error handling with try/catch, binaries and the bit syntax, and the type system with Dialyzer.

Part III covers the concurrency primitives (spawn/send/receive), error handling in concurrent programs (links, monitors, supervised fault-tolerance), and distributed programming over Erlang nodes. Part IV covers libraries and frameworks (ports for C interfacing, files, sockets, web/WebSocket applications, ETS/DETS and Mnesia databases, and profiling/debugging/tracing). The book is widely cited as a canonical introduction to the Actor model and the “let it crash” philosophy that informs modern reactive and distributed-agent systems.

Key Ideas

Actor-model concurrency: processes + asynchronous message passing.
“Let it crash” + supervision trees for fault tolerance.
Pattern matching as pervasive control structure.
Distributed programming built on the same primitives as local.
Mnesia, ETS/DETS for in-memory and persistent storage.

Connections

Conceptual Contribution

Claim: Concurrent, distributed and fault-tolerant software is simpler and more reliable when built on isolated processes that share nothing and communicate only by asynchronous messages, with failures handled by supervision rather than defensive programming (“let it crash”).
Mechanism: Armstrong teaches the Erlang trinity of spawn / send / receive, reinforces isolation via immutability and pattern matching, and then layers links, monitors and supervisor trees for systemic recovery. Distribution uses the same primitives as local concurrency, so topology becomes deployment-time. Supporting libraries (ports for C, sockets, ETS/DETS, Mnesia, tracing/profiling, web/WebSocket) show how the model scales to realistic systems.
Concepts introduced/used: Actor Model, Let It Crash, Supervision Tree, Erlang Process, Pattern Matching, Link and Monitor, Mnesia, ETS-DETS, Bit Syntax, OTP
Stance: engineering
Relates to: The practical counterpart to the fault-tolerance philosophy of Theory of Self-Reproducing Automata and the architectural dependability of Architectural Patterns for Dependable Software Systems - SOL; its message-passing primitives underpin agent frameworks surveyed in Intelligent Agents Theory and Practice and mesh with the calculus-level treatment in Secure Communications Processing for Distributed Languages.

In this vault

CRDTs

Conflict-free Replicated Data Types (Shapiro et al.) — data types whose operations commute, associate, and are idempotent, guaranteeing that replicas updated in any order converge to the same value. Each CRDT is an object-oriented packaging of a small monotonic state-merge lattice.

From the CALM Theorem viewpoint, CRDTs are canonical monotonic building blocks: programs that stay within the CRDT abstraction are automatically coordination-free. They express a partial monotonic pattern — for end-to-end application consistency the program’s composition of CRDTs also has to stay monotonic, which is the standing open problem the CALM paper highlights.

Common examples

G-Counter, PN-Counter
G-Set, 2P-Set, OR-Set, LWW-Set
LWW-Register, MV-Register
RGA (sequence CRDTs)

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

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.