liveBook · Manning

Remote procedure call

Also called RPC, remote call

A remote procedure call is a communication mechanism in which a program invokes an operation executed by another process or system, often through an interface resembling a local call.

How 8 Manning books explain it

Microservices Patterns, Second Edition

An interaction style in which a client invokes an operation on a remote service through a call resembling a local method invocation.

How it is used
Supports timely request/reply interactions between distributed services through a familiar call interface.
How deep it goes
Explains proxy and server adapter flow, trade-offs, gRPC code generation, and resilience choices.
Examples
Illustrates typed order-service operations and an API gateway fallback for unavailable delivery information.
What you can do after
Evaluate synchronous calls against messaging and choose discovery and resilience measures for service interactions.

Read how Microservices Patterns, Second Edition explains remote procedure call →

Robotics for Programmers

A remote procedure call is a communication mechanism in which a program invokes a procedure executed in another process or on another computer over a network.

How it is used
Deploys request-and-response communication between ROS nodes when a client needs a server result or confirmation.
How deep it goes
Explains client-server flow, blocking behavior, pattern selection, and distributed failure modes, but does not derive transport internals.
Examples
Demonstrates a ROS 2 SetBool service with Python server and client code, ros2 service call, and the RQt Service Caller.
What you can do after
Build and operate a ROS 2 service, invoke it asynchronously from Python, and test it through the ROS 2 CLI or RQt.

Read how Robotics for Programmers explains remote procedure call →

ActiveMQ in Action

A remote procedure call (RPC) is a request-response communication mechanism in which a program invokes an operation provided by another process or system.

How it is used
Uses synchronous RPC as a contrast for introducing loosely coupled messaging architectures.
How deep it goes
Explains blocking and coupling, then compares asynchronous messaging and scaling; does not implement an RPC call.
Examples
Cites ATMs, web applications, credit card systems, and point-of-sale systems as applications using RPC-style calls.
What you can do after
Evaluate synchronous RPC against asynchronous messaging for coupling and potential scaling benefits.

Read how ActiveMQ in Action explains remote procedure call →

Server-Side WebAssembly

A remote procedure call is a communication mechanism that lets a program invoke a function or procedure on another system.

How it is used
Uses RPC to connect wasmCloud components dynamically across hosts through NATS and wRPC.
How deep it goes
Defines RPC and explains its wasmCloud architecture, but stops short of detailing the wRPC protocol internals.
Examples
Demonstrates an HTTP component, a linked HTTP server capability, a wadm manifest, NATS, and a curl response.
What you can do after
Evaluate how wasmCloud components communicate locally or across hosts through configured runtime links.

Read how Server-Side WebAssembly explains remote procedure call →

Akka in Action, Second Edition

A remote procedure call is a communication mechanism that invokes an operation in another process or system as though it were a local procedure.

How it is used
Frames RPC as a traditional scaling mechanism whose interaction with databases and threads raises complexity.
How deep it goes
Explains blocking database RPCs and introduces Akka gRPC interfaces, while deferring client-side treatment.
Examples
Uses a scaling business chat application, DAO database calls, and a traditional-versus-actor comparison table.
What you can do after
Apply it via Akka gRPC to create a server-side port after defining a .proto interface.

Read how Akka in Action, Second Edition explains remote procedure call →

Elixir in Action, Third Edition

A remote procedure call, or remote function call, is an invocation of an operation on another process or machine presented as though it were a local function call.

How it is used
Supports result-bearing calls and multi-node coordination inside distributed Elixir systems.
How deep it goes
Explains invocation, returned results, message costs, and the :rex implementation, while deferring broader distributed-system challenges.
Examples
Demonstrates Kernel.abs(-1) executed on node2 through an IEx :rpc.call/4 expression.
What you can do after
Apply it via :rpc.call/4 to execute functions remotely and retrieve results from one or multiple nodes.

Read how Elixir in Action, Third Edition explains remote procedure call →

API Design Patterns

A remote procedure call is a mechanism for invoking a procedure or method whose execution occurs on another computer or process.

How it is used
Deploys APIs around explicit actions, especially independent operations such as forecasting weather, encrypting data, or sending email.
How deep it goes
Defines invocation style and contrasts stateless and stateful fit without detailing transport or implementation internals.
Examples
Uses weather forecasting, encryption, email, and flight-booking methods to illustrate action-oriented API naming.
What you can do after
Evaluate whether an action-oriented RPC interface fits stateless functionality or stateful resource operations.

Read how API Design Patterns explains remote procedure call →

Advanced Algorithms and Data Structures

A remote call is an invocation of an operation provided by a component running outside the caller's local process or machine.

How it is used
Frames communication with externally hosted services in distributed e-commerce order processing.
How deep it goes
Explains addressing spaces, latency, and failure modes, but stops short of detailing recovery strategies.
Examples
Uses retailer inventory, shop.order, HTTP timeouts, crashed servers, and order-processing workflows.
What you can do after
Evaluate distributed workflows by accounting for latency, unreachable services, timeouts, and uncertain operation outcomes.

Read how Advanced Algorithms and Data Structures explains remote procedure call →

Also covered in

What to know first

Related concepts

Questions about remote procedure call

What is remote procedure call?

A remote procedure call is a communication mechanism in which a program invokes an operation executed by another process or system, often through an interface resembling a local call.

Which Manning books explain remote procedure call?

Microservices Patterns, Second Edition, Robotics for Programmers, ActiveMQ in Action, Server-Side WebAssembly, Akka in Action, Second Edition, Elixir in Action, Third Edition, API Design Patterns and Advanced Algorithms and Data Structures.

What should I know before learning remote procedure call?

Manning books that teach remote procedure call usually introduce HTTP, REST, gRPC and JSON first.

What kinds of remote procedure call are there?

Kinds of remote procedure call include Apache Thrift.

What is remote procedure call also called?

Remote procedure call is also called RPC or remote call.

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.