liveBook · Manning

Asynchronous programming

Also called async, asynchronous operation, asynchronous execution, asynchrony

Asynchronous programming structures operations so that the initiating execution can continue or yield control without synchronously waiting for each operation to complete.

How 37 Manning books explain it

C# Concurrency: Asynchronous and multithreaded programming

Asynchronous programming is an execution model in which a program can initiate an operation and continue other work without synchronously waiting for that operation to finish.

How it is used
Improves responsiveness and I/O-bound throughput by freeing threads during file, network, device, or other external waits.
How deep it goes
Explains blocking, notifications, compiler transformation, Task usage, performance trade-offs, and failure modes, while deferring detailed exception mechanics.
Examples
Uses pizza-making, web requests, BMP reads, parallel file processing, mail merge, camera capture, and responsive WinForms controls.
What you can do after
Apply it via C# async/await, asynchronous APIs, Task.WhenAll, and controlled Task.Run usage while avoiding blocking and re-entry bugs.

Read how C# Concurrency: Asynchronous and multithreaded programming explains asynchronous programming →

Grokking Concurrency

An asynchronous operation is an operation that can be initiated without blocking the initiating computation until it completes.

How it is used
Keeps event-based servers responsive while operations wait or run elsewhere.
How deep it goes
Develops event-loop, future, and thread-pool mechanics through a working server, while noting its production limitations.
Examples
Uses texting, a burger order, and a pizza server to illustrate delayed responses and continued work.
What you can do after
Builds a teaching server that delegates long operations to a thread pool and receives results through futures.

Read how Grokking Concurrency explains asynchronous programming →

Think Like a Software Engineering Manager

Asynchronous communication is information exchange in which participants do not need to communicate or respond at the same time.

How it is used
Uses asynchronous communication to coordinate nonurgent work while protecting focused time.
How deep it goes
Gives practical channel and response-time guidance, but does not address asynchronous programming or code internals.
Examples
Uses email, chat, technical-discussion records, meeting outcomes, and urgent paging as concrete communication choices.
What you can do after
Practice/perform priority-based communication by deferring nonurgent replies, sharing outcomes, and escalating urgent issues.

Read how Think Like a Software Engineering Manager explains asynchronous programming →

Rust Servers, Services, and Apps

Asynchronous programming is a technique in which tasks can suspend during external operations and allow other tasks to make progress before resuming.

How it is used
Handles concurrent web requests by making progress on other tasks during I/O waits.
How deep it goes
Works from synchronous and threaded comparisons through Tokio tasks to future polling, wakers, and a custom timer future.
Examples
Uses two delayed file reads and a custom timer future to contrast execution models and show polling.
What you can do after
Build it from scratch with a custom future, or apply it via Tokio task APIs.

Read how Rust Servers, Services, and Apps explains asynchronous programming →

Learn Docker in a Month of Lunches, Second Edition

Asynchronous messaging is a communication technique in which a sender and receiver exchange messages without requiring the receiver to process each message immediately.

How it is used
Decouples a web request from database-saving work by publishing an event for a separate handler.
How deep it goes
Works through container startup, publishing, handler verification, and scaling; compares messaging patterns without implementing their internals.
Examples
Uses a NATS-backed to-do app, Docker Compose commands, subscriber logs, scaled save handlers, and an added audit handler.
What you can do after
Apply it via Docker Compose and NATS to publish to-do events, run handlers, and observe delayed saves.

Read how Learn Docker in a Month of Lunches, Second Edition explains asynchronous programming →

Latency

Asynchronous processing is a technique in which an operation can proceed or return control before all of its work has completed, allowing other work to continue concurrently.

How it is used
Uses asynchronous processing to hide latency and keep applications responsive while I/O or deferred work remains pending.
How deep it goes
Explains event-loop polling, nonblocking handlers, futures, and asynchronous messaging, with resource and error-handling trade-offs.
Examples
Illustrates concurrent server requests, asynchronous file reads, and an actor that handles counter increments.
What you can do after
Evaluate and understand how asynchronous execution overlaps waiting with other work and what resource and failure-management concerns follow.

Read how Latency explains asynchronous programming →

JavaScript in Depth

A mode of execution in which operations do not complete in the same immediate call sequence that initiated them.

How it is used
Uses callback scheduling to explain surprising output, execution-context bugs, ordering guarantees, and stream-pipeline costs.
How deep it goes
Defines asynchrony through call-stack separation, then examines callback paths and queue ordering without specifying one universal runtime schedule.
Examples
Contrasts forEach with timers, cache hits with fetches, sequential awaits during a funds transfer, and synchronous with async transforms.
What you can do after
Diagnose/debug with it when callback timing changes error handling or output order, and avoid unnecessary async stream-transform overhead.

Read how JavaScript in Depth explains asynchronous programming →

F# in Action: A Revised Edition of Get Programming with F#

Asynchronous programming is a technique in which an operation can proceed without blocking other work while waiting for a result.

How it is used
Handles external I/O, background jobs and parallel work, with particular value for web-server throughput.
How deep it goes
Explains blocking and thread reuse, then gives practical F# constructs; defers the broader complexities of parallel and distributed workloads.
Examples
Uses a database profile lookup, high-throughput web requests and everyday synchronous-versus-asynchronous communication to make the trade-off concrete.
What you can do after
Apply it via F# task { } blocks to await asynchronous .NET operations at application boundaries.

Read how F# in Action: A Revised Edition of Get Programming with F# explains asynchronous programming →

GPU Programming with Triton

Asynchronous execution allows a processor to issue work and continue without waiting for that work to finish.

How it is used
Explains why GPU kernel benchmarks must account for launches returning before GPU work finishes.
How deep it goes
Defines queued GPU execution and independent CPU/GPU clocks, then demonstrates synchronization for completed-work timing.
Examples
Compares naive wall-clock timing with timing that brackets a Triton kernel launch using torch.cuda.synchronize.
What you can do after
Diagnose misleading kernel timings by synchronizing around launches or using triton.testing.do_bench.

Read how GPU Programming with Triton explains asynchronous programming →

Quarkus in Action

Asynchronous execution is computation in which an operation completes independently of the caller and reports its result or failure later.

How it is used
Enables microservices to exchange messages without blocking callers or tightly coupling service availability.
How deep it goes
Works through Quarkus messaging channels, emitters, failure handling, and broker connectors, but does not cover Kafka internals.
Examples
Uses an invoice channel, a Billing stub, a reservation endpoint, and Kafka and RabbitMQ service links.
What you can do after
Build it from scratch with Quarkus messaging channels and connectors, and handle an emitter's reported failure.

Read how Quarkus in Action explains asynchronous programming →

Apache Kafka in Action

Asynchronous data exchange transfers information without requiring communicating components to remain synchronized or wait for one another to complete.

How it is used
Enables microservices to exchange events without waiting for one another’s processing or maintenance windows.
How deep it goes
Explains architectural trade-offs and a web-action workflow, but stops short of implementation code.
Examples
Uses a button click whose backend acknowledges receipt while another service processes the action and reports progress.
What you can do after
Apply it via Kafka to decouple service data exchange without turning an asynchronous workflow into a synchronous request-response wait.

Read how Apache Kafka in Action explains asynchronous programming →

Fast Python: High performance techniques for large datasets

How it is used
Uses asynchronous programming to keep a request-receiving server responsive while clients wait or send data.
How deep it goes
Compares blocking and asynchronous server architectures, while treating request processing separately from the server scaffold.
Examples
Uses a MapReduce request-receiving server and web-server workloads to illustrate the approach.
What you can do after
Evaluate asynchronous server designs for workloads with many waiting connections and relatively small processing demands.

Read how Fast Python: High performance techniques for large datasets explains asynchronous programming →

Akka in Action, Second Edition

An asynchronous operation initiates work without requiring the initiator to wait for its completion.

How it is used
Enables distributed chat components to keep working while other servers have not responded.
How deep it goes
Explains actor messaging and fire-and-forget acknowledgments, while deferring thread configuration details.
Examples
Uses a multi-server chat application with Supervisor, Conversation, and Mentions actors.
What you can do after
Apply it via Akka actors by sending messages, continuing work, and requesting acknowledgments when needed.

Read how Akka in Action, Second Edition explains asynchronous programming →

Fast by Default

Asynchronous execution is running work independently of the immediate caller so the caller can continue without waiting for completion.

How it is used
Keeps critical paths responsive by acknowledging user intent immediately and completing secondary work through background processing.
How deep it goes
Explains deferral choices, non-deferrable work, worker-pool routing, queues, status communication, and coordination trade-offs.
Examples
Uses mobile transfers, deferred web content, background jobs, purchase processing, event streams, and project-board interactions.
What you can do after
Apply it by designing responsive interactions, routing background jobs, choosing status mechanisms, and separating urgent from deferred work.

Read how Fast by Default explains asynchronous programming →

.NET in Action, Second Edition

Asynchronous programming is a programming technique in which operations can progress without blocking the execution flow while waiting for external work to complete.

How it is used
Unblocks application code waiting for HTTP, disk, or database operations.
How deep it goes
Works through Task-based HTTP retrieval, cancellation, concurrent requests, and an awaiting caller; defers retries and backoff.
Examples
Times a synchronous comic-title search, then converts HTTP retrieval and its caller to asynchronous methods.
What you can do after
Apply it via the Task Parallel Library to await HTTP retrieval and avoid blocking during a comic-title search.

Read how .NET in Action, Second Edition explains asynchronous programming →

Refactoring to Rust

Asynchronous processing is execution in which work can proceed without waiting for a response from another operation.

How it is used
Coordinates independent image-generation or network tasks so waiting on one result does not block other work.
How deep it goes
Explains blocking, task scheduling, gathering, completion order, and measured refactoring, without descending into runtime internals.
Examples
Demonstrates eight Mandelbrot images, randomized sleeps, gathered Python tasks, and paginated Rust search requests.
What you can do after
Apply it via asyncio by defining async functions, gathering tasks, awaiting operations, and running the asynchronous entry point.

Read how Refactoring to Rust explains asynchronous programming →

Amazon Web Services in Action, Third Edition: An in-depth guide to AWS

Asynchronous processing is a technique in which work is performed independently of the operation that initiates it and completed later.

How it is used
Decouples web requests from longer-running work so queues can buffer requests and workers can process them independently.
How deep it goes
Works through queue submission, worker processing, result storage, and message acknowledgement, but does not detail every operational failure mode.
Examples
Uses website screenshot generation and sepia-filtered image uploads as practical workflows.
What you can do after
Apply the pattern with SQS queues and workers that store results in S3 and track image-processing state in DynamoDB.

Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains asynchronous programming →

Platform Engineering on Kubernetes

Asynchronous processing handles work independently of event arrival so producers do not wait for processing to complete.

How it is used
Uses message brokers to decouple distributed services and avoid requiring producers and consumers to be available simultaneously.
How deep it goes
Explains decoupling, topics, broker dependencies, and scheduled event transformation, but stops short of implementation commands.
Examples
Uses Conference services, Kafka topics, CloudEvents-to-CDEvents transformation, and deployment events as concrete examples.
What you can do after
Apply it via Kafka or a platform messaging API, and design scheduled transformations that avoid blocking event processing.

Read how Platform Engineering on Kubernetes explains asynchronous programming →

Code Like a Pro in Rust

Asynchronous programming structures computation so operations can progress independently without requiring the initiating flow to wait synchronously.

How it is used
Uses asynchronous programming to handle concurrent I/O and build a Rust web service.
How deep it goes
Explains interleaving and workload trade-offs, then builds a complete service example while deferring deployment and high availability details.
Examples
Uses filesystem and socket operations, network clients, and a database-backed todo REST service as examples.
What you can do after
Build an async Rust HTTP REST service with database-backed CRUD operations as a starter for future projects.

Read how Code Like a Pro in Rust explains asynchronous programming →

Kafka Streams in Action, Second Edition

Asynchronous processing handles work independently of the caller so the caller does not wait for processing completion.

How it is used
Coordinates long-running record processing with Kafka polling when high traffic makes synchronous handling too slow.
How deep it goes
Explains handoff, polling, offset calculation, and manual commitment, stopping short of broader concurrency implementation.
Examples
Uses consumer polling, partition-based record processing, offset queues, and a failure scenario involving prematurely committed records.
What you can do after
Operate/configure Kafka consumers with asynchronous processing and commit offsets only after records are fully processed.

Read how Kafka Streams in Action, Second Edition explains asynchronous programming →

Grokking Software Architecture

An execution model in which work is initiated without requiring the caller to wait for its completion.

How it is used
Decouples noncritical work from user-facing requests and overlaps independent service calls to reduce waiting.
How deep it goes
Demonstrates queue-based deferral and concurrent HTTP requests without detailing asynchronous execution internals.
Examples
Uses queued shipping-label printing and a blog aggregator that concurrently requests post, author, and comment data.
What you can do after
Apply it by queueing noncritical work or issuing independent HTTP calls concurrently, while accounting for partial failures.

Read how Grokking Software Architecture explains asynchronous programming →

Functional Programming in Scala, Second Edition

An asynchronous computation is a computation whose execution can proceed independently of the caller without requiring the caller to wait synchronously for completion.

How it is used
Uses asynchronous computations to model parallel work while separating computation descriptions from their execution.
How deep it goes
Builds Par and Async representations, interpreters, combinators, and execution details rather than stopping at a definition.
Examples
Uses parallel sum, Par, Async constructors, interpreters, and parMap as concrete artifacts.
What you can do after
Build it from scratch by modeling asynchronous computations as values and implementing composable interpreters and combinators.

Read how Functional Programming in Scala, Second Edition explains asynchronous programming →

Secrets of the JavaScript Ninja, Second Edition

Program code structured to handle operations that may complete after control has returned to the caller.

How it is used
Uses asynchronous coordination to keep the browser UI responsive during dependent, long-running remote requests.
How deep it goes
Explains callback drawbacks and generator-promise suspension and resumption, without detailing promise internals.
Examples
Uses dependent ninja, mission, and mission-details JSON requests to compare synchronous, callback, and generator-promise code.
What you can do after
Understand how generators and promises coordinate dependent asynchronous tasks without blocking the UI.

Read how Secrets of the JavaScript Ninja, Second Edition explains asynchronous programming →

Functional Programming in JavaScript

A programming approach in which operations proceed without blocking the current thread while results are delivered later via completion, events, or callbacks.

How it is used
Handles progressively loaded remote data without blocking user interaction.
How deep it goes
Explains callbacks, temporal dependencies, nested-call problems, closures, and a continuation-passing refactoring.
Examples
Uses email loading, student records, grades, AJAX requests, XMLHttpRequest, and student-search interface handlers.
What you can do after
Diagnose timing and closure bugs, sequence callbacks, and refactor nested asynchronous handlers.

Read how Functional Programming in JavaScript explains asynchronous programming →

Building LLM Applications with DSPy

Asynchronous processing is a programming approach in which an operation can proceed without blocking other work while it waits for completion.

How it is used
Uses asynchronous processing as a performance option for Python and DSPy applications.
How deep it goes
Weighs performance benefits against debugging, complexity, and environment costs, but does not develop an implementation.
Examples
Uses intermittently appearing bugs and Jupyter Notebooks or Google Colab as examples of debugging and environment challenges.
What you can do after
Apply it by starting synchronously and switching to asynchronous processing only for identified slow code.

Read how Building LLM Applications with DSPy explains asynchronous programming →

Event Processing in Action

Processing in which work can proceed without requiring each operation to wait for the previous one to finish.

How it is used
Uses event-driven processing to let work proceed without requiring each operation to wait for the previous one.
How deep it goes
Defines the approach through an everyday analogy and producer-consumer behavior, but does not detail implementation internals.
Examples
Uses a coffee shop, parallel data analysis across computing nodes, and event activity spikes as examples.
What you can do after
Understand when event-driven processing can handle irregular activity, distribute analysis, or defer work during spikes.

Read how Event Processing in Action explains asynchronous programming →

Build Financial Software with Generative AI (From Scratch)

Asynchronous processing is execution in which a request can proceed without waiting synchronously for the complete operation to finish.

How it is used
Applies asynchronous processing to FastAPI endpoints handling large ACH uploads and slow downstream operations.
How deep it goes
Explains the response-and-background-work pattern and status tracking, while deferring fuller implementation details to later treatment.
Examples
Uses large ACH uploads, staged file processing, file statuses, dashboards, email, and text messages as concrete examples.
What you can do after
Apply it via FastAPI by acknowledging uploads promptly and tracking deferred processing through explicit file statuses.

Read how Build Financial Software with Generative AI (From Scratch) explains asynchronous programming →

Microsoft Azure in Action

Asynchronous processing is the execution of work without requiring the initiating operation to wait for completion.

How it is used
Uses queues to let applications exchange work without waiting synchronously or overwhelming downstream processing.
How deep it goes
Explains queue-based processing, decoupling, ordering, and failed-message retention, but does not survey asynchronous techniques beyond storage queues.
Examples
Uses Banning Books orders, burst sales, PowerShell queue commands, and ordered message retrieval as concrete examples.
What you can do after
Apply it via Azure Queue Storage to buffer work, decouple components, and process messages at a controlled pace.

Read how Microsoft Azure in Action explains asynchronous programming →

Data Pipelines with Apache Airflow, Second Edition

Asynchronous processing is execution in which a task can progress or await conditions without continuously occupying a worker.

How it is used
Uses asynchronous execution to keep Airflow workers available while the triggerer monitors tasks waiting on external systems.
How deep it goes
Explains worker deferral, triggerer monitoring, and asyncio-based parallelism, but stops short of implementation code.
Examples
Uses long-running Spark jobs and a ten-worker capacity constraint to illustrate waiting-task concurrency.
What you can do after
Apply it through Airflow’s deferrable-task pattern to move waiting work from workers to the triggerer.

Read how Data Pipelines with Apache Airflow, Second Edition explains asynchronous programming →

Build an AI Agent (From Scratch)

Asynchronous operation is execution in which a task proceeds independently of the initiating interaction and reports its result later.

How it is used
Coordinates concurrent LLM requests, benchmark evaluations, model comparisons, and multi-agent workloads.
How deep it goes
Explains coroutines, await, gathering, concurrency limits, and retries, without descending into event-loop internals.
Examples
Uses concurrent question answering, 100 rate-limited prompts, and pausable tool-confirmation workflows.
What you can do after
Apply it via Python asyncio and LiteLLM to run requests concurrently, limit load, and retry transient failures.

Read how Build an AI Agent (From Scratch) explains asynchronous programming →

Spring in Action, Sixth Edition

Asynchronous communication is interapplication communication in which the sender can continue processing without waiting for the recipient's response.

How it is used
Uses brokered messages to decouple applications that must communicate without blocking on immediate responses.
How deep it goes
Explains indirection, brokers, templates, consumers, and listener annotations without detailing message-processing internals.
Examples
Uses email delivery and Taco Cloud order routing as examples of send-now, receive-later communication.
What you can do after
Apply it via Spring JmsTemplate, RabbitTemplate, KafkaTemplate, or message-listener annotations.

Read how Spring in Action, Sixth Edition explains asynchronous programming →

Designing AI Systems

Asynchronous execution is an execution model in which a request returns before its operation completes, allowing processing to continue independently in the background.

How it is used
Keeps AI conversations and services responsive while slow external operations or long-running workflows execute in the background.
How deep it goes
Explains task and job lifecycles, polling, callbacks, progress, recovery, and HTTP handling, but defers detailed message schemas.
Examples
Uses insurance verification, deep document research, data analysis, batch processing, task polling, callbacks, and HTTP 202 responses.
What you can do after
Operate long-running tools and workflows through job identifiers, background execution, status polling, callbacks, and progress management.

Read how Designing AI Systems explains asynchronous programming →

Build AI-Enhanced Web Apps

An asynchronous operation is a computation whose completion occurs independently of the execution flow that initiated it.

How it is used
Supports streaming AI responses in web applications by handling data asynchronously as it arrives.
How deep it goes
Explains asynchronous processing within streaming workflows but stops short of language-level execution mechanics.
Examples
Uses chunked transfer encoding and streaming chat as concrete examples.
What you can do after
Apply it via the Vercel AI SDK to deliver streaming responses with managed buffering, connections, and errors.

Read how Build AI-Enhanced Web Apps explains asynchronous programming →

Rust in Action: Systems programming concepts and techniques

Asynchronous programming is a programming model in which externally occurring events influence the order of control-flow execution.

How it is used
Describes I/O-heavy execution where external events determine control flow instead of a predetermined sequence.
How deep it goes
Defines the model, distinguishes related execution terms, and explains system-call and context-switch implications.
Examples
Uses network sockets, device-driver readiness signals, queued I/O, and functions returning in another thread.
What you can do after
Evaluate/understand why asynchronous execution can improve I/O-heavy runtime performance while increasing developer complexity.

Read how Rust in Action: Systems programming concepts and techniques explains asynchronous programming →

Microservices Patterns, Second Edition

An asynchronous implementation performs an operation's work independently of the caller after the invocation returns.

How it is used
Uses asynchronous messaging to implement work behind a synchronous HTTP request.
How deep it goes
Compares two response timings and outlines the early-response steps and trade-offs.
Examples
Uses order creation and validation involving Consumer and Restaurant Services.
What you can do after
Evaluate response timing by weighing final outcomes against latency, availability, and runtime coupling.

Read how Microservices Patterns, Second Edition explains asynchronous programming →

CUDA for LLMs

Asynchronous execution allows an operation to proceed independently while subsequent work is issued before it completes.

How it is used
Separates CPU progress from GPU execution and coordinates asynchronous matrix work in producer-consumer pipelines.
How deep it goes
Explains CPU–GPU asynchrony and manual warpgroup synchronization, including race and deadlock risks, but not a general async programming model.
Examples
Contrasts host wall-clock timing with CUDA events and names warpgroup synchronization instructions for asynchronous matrix operations.
What you can do after
Evaluate/understand GPU timing with CUDA events and why asynchronous warpgroup operations require explicit synchronization.

Read how CUDA for LLMs explains asynchronous programming →

Grokking GPU Programming

Asynchronous execution allows an operation to proceed without requiring the caller to wait for its completion before continuing.

How it is used
Uses asynchronous CUDA kernel launches to separate GPU work from CPU waiting.
How deep it goes
Traces kernel launch, explicit synchronization, and blocking-copy behavior through a concrete execution sequence.
Examples
Uses a kernel that squares array elements with one GPU thread per element.
What you can do after
Apply it via CUDA by adding an explicit synchronization point to surface kernel errors during debugging.

Read how Grokking GPU Programming explains asynchronous programming →

Also covered in

What to know first

Related concepts

Questions about asynchronous programming

What is asynchronous programming?

Asynchronous programming structures operations so that the initiating execution can continue or yield control without synchronously waiting for each operation to complete.

Which Manning books explain asynchronous programming?

C# Concurrency: Asynchronous and multithreaded programming, Grokking Concurrency, Think Like a Software Engineering Manager, Rust Servers, Services, and Apps, Learn Docker in a Month of Lunches, Second Edition, Latency, JavaScript in Depth, F# in Action: A Revised Edition of Get Programming with F# and 29 more.

What should I know before learning asynchronous programming?

Manning books that teach asynchronous programming usually introduce thread, mean, queue and synchronous call first.

What is the difference between asynchronous programming and synchronous call?

Asynchronous programming structures operations so that the initiating execution can continue or yield control without synchronously waiting for each operation to complete. A synchronous call is an invocation in which the caller waits for the operation to complete or return a result before continuing.

What is asynchronous programming also called?

Asynchronous programming is also called async, asynchronous operation, asynchronous execution or asynchrony.

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.