Message passing
Message passing is a communication technique in which independent entities exchange explicit messages to transmit information, coordinate computation, or update state.
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.
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.
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.
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
- AI Agents in Action, Second Edition
- Quarkus in Action
- Go by Example
- Functional Design and Architecture: Examples in Haskell
- Grokking Simplicity
- Latency
- 100 Go Mistakes and How to Avoid Them
- Go in Action, Second Edition
- Learn C++ by Example
- Distributed Machine Learning Patterns
What to know first
- concurrencyConcurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
- threadA thread is a distinct sequence of execution with its own control flow and state, managed or scheduled by a processor, runtime, or operating system.
- graph neural networkA graph neural network is a neural-network model that learns representations or predictions from graph-structured data by combining information from connected entities.
- lockingLocking is a synchronization technique that controls concurrent access to a shared resource or protected operation.
Related concepts
- actorused by · An actor is a person, system, process, or computational entity that performs actions or participates in interactions within a system.
- shared memoryalternative to · Shared memory is a memory region accessible to multiple processes, threads, or other concurrent execution contexts for sharing data.
- messageuses · A message is a discrete unit of information or data communicated between participants or software components, often represented as a structured record.
- lockingaddresses · Locking is a synchronization technique that controls concurrent access to a shared resource or protected operation.
- System.Concurrency.Channelsused by · System.Concurrency.Channels is an Idris base-library module providing primitives for starting concurrent processes and communicating between them.
- distributed systemused by · A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
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.












