Message passing
A communication or computation technique in which entities exchange messages to transmit or propagate information, coordinate work, 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 neighboring-node information to create graph embeddings for traffic-aware representations and combinatorial-optimization pipelines.
- How deep it goes
- Explains successive neighborhood passes and shows GCNConv code, without deriving message-update equations.
- Examples
- Illustrates neighboring traffic effects in a road network, GCN node embeddings, and a pretrained traveling-salesperson pipeline.
- What you can do after
- Apply it via PyTorch Geometric’s GCNConv to produce node representations, or use pretrained graph embeddings within TSP search.
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
- Enables tasks to exchange data without directly sharing memory.
- How deep it goes
- Explains named-task communication, OS-managed channels, copying costs, and concrete mechanisms without descending into system-call internals.
- Examples
- Uses a rubber-duck pipe analogy and Python examples of a pipe handoff, queued worker tasks, and socket communication.
- What you can do after
- Apply it via Python multiprocessing.Pipe for a send-and-receive handoff or queue.Queue for queued thread work.
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 →
Related concepts
- shared memoryalternative to · Shared memory is a memory region or storage area accessible to multiple processes, threads, or other execution components for accessing or exchanging data.
- actorused by · An actor is an independent entity or participant that performs actions, maintains or pursues state or goals, and interacts with other entities or systems.
- distributed systemused by · A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
- graph neural networkused by · A graph neural network is a neural-network model that learns representations or predictions from graph-structured data by combining information from connected entities.
- embeddingproduces · A numerical vector representation of an item or input that encodes features or relationships useful for computational tasks.
- communicating sequential processused by · Communicating Sequential Processes is a formal concurrency model in which independent sequential processes communicate through channels by exchanging messages.
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.