Synchronous call
A synchronous call is an invocation in which the caller waits for the operation to complete or return a response before continuing.
Rust Servers, Services, and Apps
Synchronous programming executes an operation and waits for it to complete before continuing with subsequent work.
- How it is used
- Establishes a sequential baseline for comparing blocking work with multithreaded and async execution.
- How deep it goes
- Defines waiting at a function call and works through simulated file delays; stops short of synchronous implementation internals.
- Examples
- Uses a Rust main() calling simulated file reads with four- and two-second sleeps, producing a six-second total delay.
- What you can do after
- Diagnose/debug with it when sequential blocking calls make independent operations wait for one another.
Read how Rust Servers, Services, and Apps explains synchronous call →
Grokking Concurrency
A synchronous call is an I/O call that retains control until the operation completes and thereby creates a synchronization point.
- How it is used
- Marks the point where an I/O caller can continue after an operation completes.
- How deep it goes
- Defines the call’s completion behavior and distinguishes control flow from blocking mode, without detailing an implementation.
- Examples
- Contrasts a phone conversation with texting and identifies pipes as a synchronous producer–consumer communication mechanism.
- What you can do after
- Evaluate/understand when waiting for communication prevents tasks from doing other useful work.
Apache Kafka in Action
Synchronous communication is an interaction in which the sender and receiver coordinate during the same exchange and the sender waits for a response.
- How it is used
- Positions synchronous calls as a simple way to connect services while distinguishing immediate acknowledgement from asynchronous downstream processing.
- How deep it goes
- Explains service dependencies, cascading failures, and a button-click alternative, but does not detail HTTP implementation.
- Examples
- Contrasts dependent service calls with a button click that receives prompt confirmation while processing continues through Kafka.
- What you can do after
- Evaluate/understand when to acknowledge a request synchronously and when to let downstream work proceed asynchronously.
F# in Action: A Revised Edition of Get Programming with F#
A synchronous operation runs to completion in the caller's execution flow and normally keeps its thread occupied while it waits.
- How it is used
- Frames sequential execution as the simple baseline for deciding when asynchronous communication is warranted.
- How deep it goes
- Explains blocking, sequential flow, and thread consequences without implementing synchronous calls.
- Examples
- Uses database queries, desktop freezes, web requests, and everyday communication media to contrast waiting with asynchronous alternatives.
- What you can do after
- Evaluate/understand when a blocked synchronous I/O call may harm responsiveness or web-request throughput.
Read how F# in Action: A Revised Edition of Get Programming with F# explains synchronous call →
Latency
Synchronous processing is a processing model in which operations are handled sequentially and completion or errors are observed before subsequent processing proceeds.
- How it is used
- Provides the sequential baseline for deciding whether overlapping tasks could hide I/O latency.
- How deep it goes
- Defines completion-before-next-task behavior and traces a blocking server request, without developing a separate synchronous-call API.
- Examples
- Uses a socket request loop and task timelines to show where waiting prevents the next task from starting.
- What you can do after
- Evaluate/understand when a blocking call delays subsequent work and when another thread can still make progress.
Quarkus in Action
Synchronous communication is an interaction in which the requesting application waits for a response from another system before continuing.
- How it is used
- Coordinates request-and-response interactions among microservices when the caller must wait for another service’s result.
- How deep it goes
- Defines the waiting model, names REST, GraphQL, and gRPC, and explains failure propagation without detailing protocol internals.
- Examples
- Uses a car-rental system of Users, Reservation, Rental, Inventory, and Billing services plus a synchronous failure-propagation diagram.
- What you can do after
- Apply it via Quarkus annotations to design and consume REST, GraphQL, or gRPC APIs while recognizing availability and latency trade-offs.
Related concepts
- asynchronous programmingcontrasts with · Asynchronous programming is an execution approach in which operations can progress independently without requiring the initiating flow to wait for their completion or an immediate response.
- synchronization pointproduces · A synchronization point is a program location, component, or operation where concurrent computations coordinate their progress or ordering.
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.