Distributed system
A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
Elixir in Action, Third Edition
A distributed system is a system whose components execute across multiple networked machines or runtime environments.
- How it is used
- Deploys clustered services for horizontal scaling and continued availability when individual machines fail.
- How deep it goes
- Explains processes, messages, replication, joining nodes, and failure boundaries, while deferring complete partition and recovery strategies.
- Examples
- Demonstrates a replicated to-do service running on two connected nodes and serving requests through separate HTTP endpoints.
- What you can do after
- Build it from scratch by combining Erlang distribution primitives, explicit message protocols, replication, and failure recovery.
Read how Elixir in Action, Third Edition explains distributed system →
Think Distributed Systems
A computing system whose components execute across multiple networked locations and must coordinate despite having incomplete views of system state.
- How it is used
- Organizes reasoning about systems whose components coordinate through messages while pursuing correctness, scalability, and reliability.
- How deep it goes
- Defines components, local state, messages, network steps, and system models, then stops short of implementing particular protocols.
- Examples
- Uses an office corporation analogy, equivalent message-buffer models, nested database subsystems, and a split-brain leadership scenario.
- What you can do after
- Evaluate system behavior by separating global guarantees from local observations and by making network, component, and failure assumptions explicit.
Read how Think Distributed Systems explains distributed system →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
An application architecture in which components execute as separate processes or services that communicate across a network.
- How it is used
- Frames microservices as a practical way to divide a growing application while weighing scalability against added complexity.
- How deep it goes
- Explains operational benefits and tradeoffs, but keeps distributed-computing theory secondary to building and deploying an application.
- Examples
- Uses resource allocation for busy services and a partial monolith-to-microservices conversion to illustrate design choices.
- What you can do after
- Evaluate/understand when separate services offer enough scaling and deployment value to justify their operating costs.
Building Distributed Applications that Work
A distributed system is a system composed of multiple networked computing components that coordinate to provide shared behavior.
- How it is used
- Frames local development and debugging of a multi-service online shop as a coordination problem.
- How deep it goes
- Defines independent networked components, contrasts monoliths, and outlines local orchestration without detailing network protocols or failure recovery.
- Examples
- Follows a shopper’s request through a storefront and catalog API, with data stores and background processing in the wider system.
- What you can do after
- Apply it via Aspire to run, connect, observe, and debug independent application components from one local development setup.
Read how Building Distributed Applications that Work explains distributed system →
LLMs in Production
Distributed computing is a computing technique that divides workloads across multiple networked devices or nodes for concurrent execution.
- How it is used
- Uses concurrent computation to make oversized deep-learning models and pipelines train or infer efficiently across clusters.
- How deep it goes
- Explains data, model, tensor, and sequence parallelism plus microbatching, but does not detail cluster internals or communication mechanics.
- Examples
- Demonstrates a ten-call Ray task and illustrates tensor splitting, transformer parallelization, GPU bubbles, and microbatching.
- What you can do after
- Apply it via Ray for concurrent tasks and select data, model, tensor, or sequence parallelism for deep-learning workloads.
Effective Platform Engineering
A distributed architecture pattern structures capabilities across multiple coordinating components rather than concentrating them in one component.
- How it is used
- Structures engineering-platform capabilities across coordinating services, teams, and control planes as complexity and scale increase.
- How deep it goes
- Explains orchestration, extensibility, boundaries, replication, and coordination practices, but stops short of implementation-level distributed-systems internals.
- Examples
- Uses Kubernetes cluster components, pod sidecars, isolated platform replication, and public API-gateway integration as concrete examples.
- What you can do after
- Evaluate platform boundaries and choose incremental distribution, standardization, replication, or self-service according to scaling priorities.
Read how Effective Platform Engineering explains distributed system →
Rust Servers, Services, and Apps
A distributed system is a collection of independent computing components that coordinate over a network to provide combined functionality.
- How it is used
- Uses distributed web applications as the setting for developing Rust-based web services and applications.
- How deep it goes
- Defines system components and stack layers, then relates them to web applications without detailing implementation internals.
- Examples
- Uses social media, e-commerce, sharing-economy, and entertainment services, plus a social media stack diagram.
- What you can do after
- Build Rust web servers, services, and applications using the distributed-web context.
Read how Rust Servers, Services, and Apps explains distributed system →
Advanced Algorithms and Data Structures
A distributed system is a system whose components execute across multiple networked computers and communicate by exchanging messages.
- How it is used
- Frames real applications and large-scale data processing as coordinated work across machines connected by networks.
- How deep it goes
- Explains remote calls, latency, failures, timeouts, communication choices, and scale-out, without developing a complete fault-tolerance design.
- Examples
- Uses retailer services, customer orders, HTTP sequence diagrams, and distributed versions of k-means, canopy clustering, and DBSCAN.
- What you can do after
- Diagnose/debug with it by locating network uncertainty, timeout mismatches, remote failures, and scale-out trade-offs.
Read how Advanced Algorithms and Data Structures explains distributed system →
Platform Engineering on Kubernetes
A distributed system is a computing system whose functionality is divided among independently operating services that communicate across process or network boundaries.
- How it is used
- Uses independently operating services to support cloud-native applications and distribute team, scaling, and deployment responsibilities.
- How deep it goes
- Explains architectural differences, scaling benefits, and operational failures, but stops short of service-internal implementation details.
- Examples
- Uses a walking-skeleton application, monolith comparison, Kubernetes cluster, and figures contrasting bundled logic with distributed services.
- What you can do after
- Evaluate distributed architecture trade-offs and experiment with service latency, failures, scaling, and consistency in Kubernetes.
Read how Platform Engineering on Kubernetes explains distributed system →
PostgreSQL Mistakes and How to Avoid Them
A distributed system is a system whose components execute across multiple networked computing nodes that coordinate to provide a unified service.
- How it is used
- Frames PostgreSQL replication as a distributed-system design with consistency, availability, and latency consequences.
- How deep it goes
- Explains primary-standby lag through a worked account scenario and stops short of exhaustive distributed-systems implementation detail.
- Examples
- Uses PostgreSQL alpha and beta nodes, delayed account reads, balance updates, and a mistaken bonus calculation.
- What you can do after
- Diagnose inconsistent application behavior by comparing primary and standby reads under replication lag.
Read how PostgreSQL Mistakes and How to Avoid Them explains distributed system →
ScyllaDB in Action
A distributed system is a system whose components run on multiple networked nodes and coordinate to provide a unified service.
- How it is used
- Uses distribution to provide ScyllaDB scalability, fault tolerance, availability, and configurable consistency.
- How deep it goes
- Traces request routing, replication, consistency levels, eventual consistency, and the hash ring, while deferring deeper implementation details.
- Examples
- Demonstrates any-node writes, hash-ring forwarding, replicated rows, and ALL, QUORUM, and ONE consistency levels.
- What you can do after
- Evaluate consistency and availability trade-offs while reasoning about ScyllaDB reads, writes, failures, and cluster behavior.
Grokking Simplicity
A software system whose components communicate over a network and may experience delayed, reordered, duplicated, or lost messages.
- How it is used
- Frames distributed systems as a setting for isolating time-dependent actions and reasoning about unreliable communication.
- How deep it goes
- Defines message uncertainty and develops timeline reasoning, but defers detailed implementation of distributed protocols.
- Examples
- Uses network message rules, frontend/backend sharing, and a dinner-preparation postmortem with dough, sauce, cheese, and timeline diagrams.
- What you can do after
- Evaluate distributed behavior with message-delivery rules and timeline diagrams, then isolate timing-sensitive actions for safer design.
Learn Docker in a Month of Lunches, Second Edition
A distributed system is a system whose components execute across multiple networked processes or computing environments.
- How it is used
- Uses containers to modernize monoliths incrementally and operate flexible, scalable application components.
- How deep it goes
- Explains decomposition, networking, startup behavior, and self-healing operations without descending into application-code internals.
- Examples
- Uses monolith decomposition, private container networking, production clusters, failed dependencies, and out-of-memory container replacement.
- What you can do after
- Operate/configure containerized distributed applications with Docker Compose or Kubernetes, using health checks instead of fixed startup order.
Read how Learn Docker in a Month of Lunches, Second Edition explains distributed system →
Real-World Cryptography
A distributed system is a set of independent computing components that coordinate over a network to provide a shared service or state.
- How it is used
- Builds resilience against server loss by replicating data and coordinating access across multiple machines.
- How deep it goes
- Explains replication, leaders, lag, eventual consistency, forks, and Byzantine faults, but stops short of protocol implementation details.
- Examples
- Uses geographically distributed database replicas, leader-based writes, differing account balances, and contradictory histories as examples.
- What you can do after
- Evaluate replication designs by weighing availability, write conflicts, lag, consistency, crashes, partitions, and compromised servers.
Read how Real-World Cryptography explains distributed system →
Apache Kafka in Action
A distributed system is a set of computing components that coordinate across multiple machines to provide a unified service.
- How it is used
- Frames Kafka architecture around coordination, scaling, replication, and failure handling across multiple servers.
- How deep it goes
- Explains coordination and failure concerns, then stops short of detailed algorithms or implementation procedures.
- Examples
- Uses adding servers, assigning requests, detecting failures, replacing servers, and copying or splitting logs as concrete examples.
- What you can do after
- Evaluate distributed designs by considering coordination, failure behavior, scaling strategy, replication, and operational simplicity.
Read how Apache Kafka in Action explains distributed system →
Related concepts
- microservice architectureincludes · Microservice architecture is a software architectural style that organizes an application as independently deployable services with focused responsibilities that communicate through defined interfaces.
- networkuses · A network is a system of connected entities and links that enables communication or represents relationships among those entities.
- Apache Kafkaincludes · Apache Kafka is a distributed event-streaming platform for publishing, storing, processing, and consuming streams of records.
- docker compose up --buildproduced by · docker compose up --build is a Docker Compose command that rebuilds service images before creating and starting the services.
- messageuses · A message is a discrete unit of information or data represented, processed, or exchanged in a communication context.
- Docker Composeconfigured by · Docker Compose is a tool for defining and running applications composed of multiple containers through declarative configuration.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.