liveBook · Manning

Message passing

Message passing is a communication technique in which independent entities exchange explicit messages to transmit information, coordinate computation, or update state.

How 13 Manning books explain it

Graph Neural Networks in Action

Message passing is a graph neural network technique in which node representations are updated by aggregating information from neighboring nodes.

How it is used
Uses neighbor information to produce graph-aware representations for node classification, link prediction, and graph-level prediction.
How deep it goes
Works through collection, aggregation, transformation, and update, then illustrates layered implementations and a GraphSAGE aggregation procedure.
Examples
Shows a two-layer PyTorch Geometric GCN generating embeddings, a GraphSAGE neighbor update, and a masked-training GCN baseline.
What you can do after
Apply it via PyTorch Geometric `GCNConv` to update node embeddings while preserving graph context during masked training.

Read how Graph Neural Networks in Action explains message passing →

Optimization Algorithms: AI techniques for design, planning, and control problems

Message passing is a graph-learning technique in which nodes exchange and aggregate information with neighboring nodes to update representations.

How it is used
Uses neighborhood information to produce graph embeddings for prediction and combinatorial optimization.
How deep it goes
Explains successive neighborhood passes and illustrates a two-layer GCN implementation.
Examples
Illustrates connected road segments for ETA prediction, a Cora GCN, and traveling salesman tours.
What you can do after
Apply it via PyTorch Geometric using GCNConv layers to generate node representations.

Read how Optimization Algorithms: AI techniques for design, planning, and control problems explains message passing →

Learn Concurrent Programming with Go

Message passing is a communication approach in which concurrent executions exchange information by sending and receiving messages.

How it is used
Coordinates goroutines by exchanging values through channels instead of directly sharing mutable memory.
How deep it goes
Explains channel blocking, buffering, closure, result collection, selection, CSP, and trade-offs, while deferring deeper CSP detail.
Examples
Uses goroutines that count web-page letter frequencies locally and send slices for aggregation.
What you can do after
Apply it via Go channels to exchange concurrent results, coordinate blocking behavior, and choose against memory sharing when appropriate.

Read how Learn Concurrent Programming with Go explains message passing →

Elixir in Action, Third Edition

Message passing is interprocess communication in which processes exchange data through runtime messages rather than shared memory.

How it is used
Coordinates isolated Elixir processes for asynchronous work, result collection, and communication across distributed nodes.
How deep it goes
Explains send/2, receive, tagged responses, caller PIDs, mailbox matching, timeouts, and remote implementation boundaries.
Examples
Demonstrates spawned queries, tagged result messages, receive timeouts, remote :rpc calls, and distributed locks.
What you can do after
Apply it via Elixir's send/2 and receive to coordinate workers, collect asynchronous results, and invoke remote services.

Read how Elixir in Action, Third Edition explains message passing →

Grokking Concurrency

Message passing is an interprocess communication technique in which execution contexts exchange data through discrete messages rather than directly sharing memory.

How it is used
Uses message passing to coordinate tasks and introduce communication in distributed client-server applications.
How deep it goes
Explains OS-managed channels, copying costs, and common mechanisms, with Python examples.
Examples
Illustrates a rubber duck sent through a pipe and workers processing items from a queue.
What you can do after
Apply message passing via Python’s multiprocessing.Pipe and queue.Queue in thread examples.

Read how Grokking Concurrency explains message passing →

Functional Programming in C#, Second Edition

Message passing is communication between concurrent processes by sending messages rather than directly accessing one another’s state.

How it is used
Controls access to mutable state in concurrent programs by assigning exclusive ownership to message-processing agents or actors.
How deep it goes
Explains the inbox and sequential processing loop with an idealized C# agent implementation.
Examples
Illustrates an agent with a queued inbox, a Tell method, and a state-processing function.
What you can do after
Evaluate/understand how sequential message processing prevents concurrent updates to an agent’s state.

Read how Functional Programming in C#, Second Edition explains message passing →

Knowledge Graphs and LLMs in Action

Message passing is a graph-neural-network technique in which nodes iteratively exchange, aggregate, and use information from neighboring nodes to update their representations.

How it is used
Uses iterative neighborhood aggregation to learn node representations for graph-structured prediction tasks.
How deep it goes
Defines aggregation and update, gives a basic trainable equation, and compares self-loops with specialized architectural enhancements.
Examples
Uses social networks, molecular graphs, citation networks, and an unfolded neighborhood computation tree.
What you can do after
Build a basic GNN update pipeline and choose between standard aggregation and self-loop variants.

Read how Knowledge Graphs and LLMs in Action explains message passing →

C++ Concurrency in Action, Second Edition

Message passing is a communication technique in which concurrent components exchange information by sending and receiving messages.

How it is used
Coordinates concurrent operations by communicating between threads through asynchronous messages and a messaging subsystem.
How deep it goes
Explains message handling through ATM state examples and notes that the messaging library hides synchronization.
Examples
Uses an ATM state machine that handles card, PIN, and cancel messages and contacts a bank interface.
What you can do after
Apply message passing by defining which messages a component handles and sends at each state.

Read how C++ Concurrency in Action, Second Edition explains message passing →

Sutskever's List

Message passing is an iterative graph-computation technique in which nodes send information to neighboring nodes and update their representations.

How it is used
Supports supervised learning on graph data by letting nodes exchange information before graph-level prediction.
How deep it goes
Defines iterative node-state updates and readout, then discusses long-range communication and efficiency designs without formal derivation.
Examples
Uses molecular atoms and bonds to illustrate neighborhood exchange, with QM9 tower results as an efficiency example.
What you can do after
Understand how graph nodes accumulate neighborhood information and why long-range propagation can bottleneck.

Read how Sutskever's List explains message passing →

Machine Learning Algorithms in Depth

Message passing is a graph-computation technique in which nodes exchange information with neighboring nodes to update their representations.

How it is used
Processes graph data for learning tasks that depend on relationships among nodes.
How deep it goes
Defines message passing as dependence capture between graph nodes but stops short of update equations, derivation, or implementation.
Examples
Uses social-network modeling and protein-structure prediction as graph-data applications.

Read how Machine Learning Algorithms in Depth explains message passing →

Build AI Drug Discovery Pipelines

A message passing algorithm iteratively aggregates information from neighboring nodes to update node representations in a graph.

How it is used
Builds context-aware atom and residue representations for graph neural networks predicting drug-target affinity.
How deep it goes
Explains the three-step update cycle, permutation invariance, graph tensors, and information range, while deferring full derivations.
Examples
Uses molecular atoms, protein residues, bonds, structural proximity, and PyTorch Geometric tensors as concrete teaching artifacts.
What you can do after
Apply it via PyTorch Geometric to represent neighboring structure in molecular and protein graphs.

Read how Build AI Drug Discovery Pipelines explains message passing →

Type-Driven Development with Idris

Message passing is communication between processes by sending and receiving messages.

How it is used
Uses message passing to coordinate concurrent processes, including a main process that requests work from an adder service.
How deep it goes
Moves from runtime primitives to typed protocols, noting unsafe channel guarantees and using state machines to describe process responses.
Examples
Uses an adder process that receives `Add 2 3` and replies with `5`.
What you can do after
Build from scratch a typed process model that specifies message types and the order in which processes send and receive.

Read how Type-Driven Development with Idris explains message passing →

Timeless Algorithms, The Foundational Ideas

Message passing is a procedure that propagates information between connected nodes to compute or approximate quantities in a network.

How it is used
Distributes a global inference calculation across local relationships in coding and probabilistic graphical models.
How deep it goes
Defines local belief updates and distinguishes exact marginals on loop-free graphs from approximate, potentially nonconvergent updates on loopy graphs.
Examples
Maps unknown bits to hidden variables, coding constraints to probabilistic factors, and decoding messages to local belief updates.
What you can do after
Understand how local probability summaries propagate evidence and when the resulting inference is exact or approximate.

Read how Timeless Algorithms, The Foundational Ideas explains message passing →

Also covered in

What to know first

Related concepts

Questions about message passing

What is message passing?

Message passing is a communication technique in which independent entities exchange explicit messages to transmit information, coordinate computation, or update state.

Which Manning books explain message passing?

Graph Neural Networks in Action, Optimization Algorithms: AI techniques for design, planning, and control problems, Learn Concurrent Programming with Go, Elixir in Action, Third Edition, Grokking Concurrency, Functional Programming in C#, Second Edition, Knowledge Graphs and LLMs in Action, C++ Concurrency in Action, Second Edition and 5 more.

What should I know before learning message passing?

Manning books that teach message passing usually introduce concurrency, thread, graph neural network and locking first.

What is the difference between message passing and shared memory?

Message passing is a communication technique in which independent entities exchange explicit messages to transmit information, coordinate computation, or update state. Shared memory is a memory region accessible to multiple processes, threads, or other concurrent execution contexts for sharing data.

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.