Asynchronous programming
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.
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.
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 busy, I/O-heavy servers responsive by letting independent tasks progress while operations wait.
- How deep it goes
- Works through communication, control flow, futures, and a prototype server, but stops short of production-ready error handling.
- Examples
- Uses burger orders to explain futures and a pizza server to show long work offloaded from an event loop.
- What you can do after
- Build it from scratch as a prototype server that combines an event loop, a thread pool, and 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
- Hides waiting time and keeps systems responsive when I/O or other slow operations cannot readily be shortened.
- How deep it goes
- Explains event-loop dispatch, callbacks, futures, and operational pitfalls, but does not provide a complete asynchronous server implementation.
- Examples
- Uses socket servers, database queries, and asynchronous file reads to contrast blocking with overlapping work.
- What you can do after
- Apply it via Rust async/await or event-loop handlers to overlap I/O with other work without blocking handlers.
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
- Applies asynchronous workflows to external I/O, background tasks, parallel jobs, and high-throughput web requests.
- How deep it goes
- Explains blocking, thread reuse, Task and Async workflows, parallel execution, and shared-state safety without resolving all async complexities.
- Examples
- Uses profile retrieval, JSON over HTTP, order processing, ticket booking, database queries, and web-server requests.
- What you can do after
- Apply it via Task, task { }, let!, do!, and parallel combinators at application I/O boundaries.
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
- Keeps a server responsive to many clients when requests involve slow input and little processing.
- How deep it goes
- Develops the server-design problem through blocking and asynchronous architectures, without specifying an API or measured throughput.
- Examples
- Contrasts a client taking 1 ms or 1 h to send input with a server receiving MapReduce data and code.
- What you can do after
- Build it from scratch: scaffold a server that receives client requests without making slow input block every connection.
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 →
.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.
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
- Handles waiting operations, especially I/O, while other tasks make progress.
- How deep it goes
- Explains interleaving, nonblocking I/O, task overhead and selection trade-offs; identifies runtimes and futures without detailing their internals here.
- Examples
- Contrasts network services and high-volume request clients with sequential CLI tools, and uses a database-backed REST API as an application.
- What you can do after
- Build it from scratch: an async Rust REST API with database-backed CRUD operations.
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 →
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 →
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.
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 →
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.
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 →
Related concepts
- queueuses · A queue is an ordered collection that holds items for retrieval or processing, typically removing them in the order they were added.
- background processinguses · Background processing is the execution of work independently of the immediate interactive or request-handling flow, so foreground activity need not wait for its completion.
- synchronous callcontrasts with · A synchronous call is an invocation in which the caller waits for the operation to complete or return a response before continuing.
- concurrencyuses · Concurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
- blockingcontrasts with · Execution behavior in which an operation prevents its calling execution flow from progressing until required work, an event, a resource, or a condition is ready or complete.
- event-driven architectureused by · Event-driven architecture is a software architectural style in which components communicate or initiate processing by producing and responding to events.
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.