Skip to main content
Programming models provide abstractions that make it easier to reason about and build distributed systems. These papers explore different approaches to distributed programming.

​
Essential Papers

These papers introduce innovative programming models and abstractions for distributed computing.

Distributed Programming Model

Foundational concepts for distributed programming

PSync Language

A partially synchronous language for fault-tolerant distributed algorithms

Programming Models Course

Comprehensive course on programming models for distributed computing

Logic and Lattices

Using logic and lattices for distributed programming

​
Distributed Programming Model

This foundational paper explores the core concepts and challenges in distributed programming, including:Key Topics:
  • Communication primitives in distributed systems
  • Synchronization mechanisms
  • Consistency models
  • Fault tolerance considerations
Understanding these fundamentals is essential before diving into specific programming models and languages.
Read Distributed Programming Model Paper

​
PSync: Partially Synchronous Language

PSync is a domain-specific language for writing fault-tolerant distributed algorithms with a focus on clarity and correctness.

​
What is PSync?

PSync is a programming language designed specifically for fault-tolerant distributed algorithms. It operates in a partially synchronous model, bridging the gap between synchronous and asynchronous systems.
Language Design:
  • High-level abstractions for distributed algorithms
  • Built-in support for rounds and message passing
  • Automatic handling of common fault-tolerance patterns
  • Verification-friendly semantics
Synchrony Model:
  • Partial synchrony assumptions
  • Bounded message delays (eventually)
  • Suitable for consensus and agreement protocols
PSync is particularly well-suited for:
  • Consensus algorithms (like Paxos variants)
  • Byzantine fault-tolerant protocols
  • Leader election algorithms
  • Distributed agreement protocols
The language makes it easier to express and verify these algorithms correctly.

​
Resources

Paper

Read the POPL 2016 paper on PSync

Conference Talk

Watch the conference presentation

​
Logic and Lattices for Distributed Programming

This research from UC Berkeley explores using declarative logic and lattice theory for distributed programming.Core Concepts:
  • CALM Theorem: Consistency As Logical Monotonicity
  • Programs that are logically monotonic are eventually consistent without coordination
  • Lattices provide a mathematical foundation for conflict-free replicated data
Practical Impact:
  • Influenced the design of CRDTs (Conflict-free Replicated Data Types)
  • Provides formal basis for reasoning about consistency
  • Enables deterministic distributed programming

​
Why Lattices Matter

1

Mathematical Foundation

Lattices provide a rigorous mathematical framework for reasoning about distributed state
2

Monotonicity

Monotonic operations don’t require coordination, enabling better performance
3

Composability

Lattice operations compose naturally, making it easier to build complex systems
4

Verification

Formal properties make it easier to verify correctness of distributed programs
Read Logic and Lattices Paper

​
Programming Models Course

For a comprehensive overview of programming models for distributed computing, check out this course by Heather Miller.
The course covers:

Shared Memory Models

Understanding different consistency models and memory semantics

Message Passing

Actor models, CSP, and other message-passing abstractions

Data-Centric Models

Programming with distributed data structures and CRDTs

Declarative Models

Logic programming and dataflow approaches to distribution
Visit Course Website

​
Comparison of Programming Models

Imperative Models:
  • Explicit control flow and state management
  • Examples: Traditional RPC, message passing
  • More control but higher complexity
Declarative Models:
  • Specify what to compute, not how
  • Examples: Logic programming, dataflow
  • Less control but simpler reasoning
Synchronous Models:
  • Bounded message delays
  • Simpler to reason about
  • Less realistic for internet-scale systems
Partially Synchronous:
  • Eventually bounded delays (like PSync)
  • Balance between simplicity and realism
  • Suitable for many practical algorithms
Asynchronous Models:
  • No timing assumptions
  • Most realistic but most challenging
  • Requires careful handling of uncertainty
Coordination-Free:
  • Based on monotonic operations and lattices
  • Eventually consistent
  • High performance, no blocking
Coordination-Based:
  • Uses consensus and synchronization
  • Strong consistency guarantees
  • May require blocking and reduce availability

CRDTs

Conflict-free data types inspired by lattice theory

Actor Models

Encapsulated state with message passing (Akka, Orleans)

Reactive Streams

Asynchronous stream processing with backpressure

Choreography

Decentralized workflow coordination

Serverless

Event-driven, stateless function composition

Edge Computing

Geo-distributed programming models
The choice of programming model significantly impacts the complexity, performance, and correctness of your distributed system. Understanding different models helps you choose the right abstraction for your specific problem.

Build docs developers (and LLMs) love

Get started for freeTalk to us