liveBook · Manning

Sequential processing

Also called sequential execution, serial execution

Sequential processing is the execution of operations one after another in a defined order, without overlapping their execution.

How 11 Manning books explain it

Grokking Concurrency

Serial or sequential execution is execution in which tasks run one after another, with a later task waiting for the preceding task to complete.

How it is used
Introduces serial execution as a starting point for understanding concurrency and parallel execution.
How deep it goes
Defines tasks and serial execution, then explains dependencies, trade-offs, and contrasts with parallelism and multitasking.
Examples
Uses laundry loads, tic-tac-toe turns, and a Python password-hash search to illustrate sequential work.
What you can do after
Evaluate when task dependencies require ordering and when independent work may be a candidate for parallel execution.

Read how Grokking Concurrency explains sequential processing →

Learn Concurrent Programming with Go

Sequential execution is the execution of operations in an ordered flow without overlapping concurrent progress.

How it is used
Explains ordered work and deliberately serialized critical sections within concurrent programs.
How deep it goes
Connects sequential regions to scalability, mutex scope, scheduling, and observed runtime, but does not develop formal execution models.
Examples
Uses construction dependencies, a narrow transport road, and Go RFC letter-frequency workers with oversized and focused mutex regions.
What you can do after
Diagnose excessive serialization and place mutexes around shared updates without blocking independent downloads.

Read how Learn Concurrent Programming with Go explains sequential processing →

Distributed Machine Learning Patterns

A workflow pattern in which dependent processing proceeds in coordinated order, with an operation waiting for required preceding work to complete.

How it is used
Orders dependent machine-learning workflow steps when downstream work requires preceding outputs.
How deep it goes
Defines blocking step order and contrasts it with concurrent synchronous and nonblocking asynchronous execution.
Examples
Uses ingestion before training and uneven model-training durations that delay selection and serving.
What you can do after
Evaluate whether dependent steps must wait or can proceed through synchronous or asynchronous execution.

Read how Distributed Machine Learning Patterns explains sequential processing →

AI Agents in Action

Sequential execution is the performance of actions or tasks one after another in a specified order.

How it is used
Coordinates agents or actions by completing tasks one after another, including when later steps depend on earlier results.
How deep it goes
Explains ordered execution through agent-task iteration and planning exercises, without detailing scheduling internals.
Examples
Uses a CrewAI coding crew and a planning agent that retrieves Wikipedia information and saves it to a file.
What you can do after
Apply it via CrewAI's Process.sequential setting to run a coding crew's assigned tasks in order.

Read how AI Agents in Action explains sequential processing →

Effective Behavior-Driven Development

Executing scenarios sequentially rather than concurrently against a service.

How it is used
Prevents scenarios using a shared service from interfering through simultaneous changes to its state.
How deep it goes
Compares selective and broad restrictions on parallel execution, noting the feedback-speed trade-off without specifying implementation steps.
Examples
Illustrates parallel interference with two scenarios modifying a pizza menu and identifies serial execution as the chosen strategy for WIMP.
What you can do after
Apply serial execution selectively to scenarios that share a service, while recognizing its cost to parallel feedback.

Read how Effective Behavior-Driven Development explains sequential processing →

Grokking Simplicity

A sequential action is an action that is ordered to occur in sequence with other actions on the same execution timeline.

How it is used
Uses timeline diagrams to establish action ordering and diagnose bugs caused by multiple execution timelines.
How deep it goes
Defines sequential placement, decomposes actions, and gives a three-step diagramming process, but stops short of language-independent execution internals.
Examples
Uses atomic variable updates, left-to-right argument evaluation, and cost and shipping AJAX requests as ordering examples.
What you can do after
Diagnoses ordering bugs with timeline diagrams and evaluates when coordination can make parallel work both faster and correct.

Read how Grokking Simplicity explains sequential processing →

Microservices Patterns, Second Edition

Sequential execution runs saga steps one after another, starting each step after the preceding step completes.

How it is used
Coordinates saga steps by starting each after its predecessor completes.
How deep it goes
Defines sequential ordering but does not detail its implementation mechanics.
What you can do after
Evaluate saga step ordering alongside timeout handling and response timing.

Read how Microservices Patterns, Second Edition explains sequential processing →

Build an AI Agent (From Scratch)

A sequential workflow executes agents in a fixed order, passing each agent's output context to the next agent.

How it is used
Orchestrates specialized agents through predictable, step-by-step workflows such as research, writing, and review.
How deep it goes
Explains workflow structure and run() mechanics, including input branching, context passing, and execution-state resets.
Examples
Uses researcher, writer, and editor agents to demonstrate a blog-writing pipeline.
What you can do after
Build it from scratch by implementing an Agent-compatible SequentialWorkflow with ordered execution and context handoff.

Read how Build an AI Agent (From Scratch) explains sequential processing →

Fast Python: High performance techniques for large datasets

How it is used
Frames ordinary Python execution as a baseline for considering techniques that use available CPU resources.
How deep it goes
Defines sequential execution and contrasts it with concurrency and parallelism, without detailing an implementation.
Examples
Uses a task-execution model to contrast sequential, concurrent, and parallel behavior.
What you can do after
Evaluate sequential execution as an architecture choice while recognizing its limits for using multicore CPU resources.

Read how Fast Python: High performance techniques for large datasets explains sequential processing →

Functional Programming in C#, Second Edition

Sequential processing is the handling of operations or messages one at a time in a defined sequence.

How it is used
Uses agents to process messages in order and protect state updates from concurrent writes.
How deep it goes
Explains ActionBlock-backed agents and queued state updates, without detailing Dataflow internals.
Examples
Uses an ActionBlock-backed stateful agent and currency-rate agents that handle requests per currency pair.
What you can do after
Apply sequential processing with agents to serialize state updates while allowing independent agents to handle work concurrently.

Read how Functional Programming in C#, Second Edition explains sequential processing →

Grokking GPU Programming

Sequential execution performs computational steps one at a time rather than concurrently.

How it is used
Sets a single-core CPU baseline for contrasting data-parallel GPU work and parallel reduction.
How deep it goes
Defines one-at-a-time execution and illustrates a 1,000-element loop, while qualifying the step count as an unvectorized baseline.
Examples
Doubles 1,000 array values in order and uses sequential CPU code as a reduction baseline.
What you can do after
Understand how one-at-a-time CPU execution differs from GPU-style parallel work.

Read how Grokking GPU Programming explains sequential processing →

Also covered in

What to know first

Related concepts

Questions about sequential processing

What is sequential processing?

Sequential processing is the execution of operations one after another in a defined order, without overlapping their execution.

Which Manning books explain sequential processing?

Grokking Concurrency, Learn Concurrent Programming with Go, Distributed Machine Learning Patterns, AI Agents in Action, Effective Behavior-Driven Development, Grokking Simplicity, Microservices Patterns, Second Edition, Build an AI Agent (From Scratch) and 3 more.

What should I know before learning sequential processing?

Manning books that teach sequential processing usually introduce parallelism, thread, workflow and concurrency first.

What is the difference between sequential processing and parallelism?

Sequential processing is the execution of operations one after another in a defined order, without overlapping their execution. Parallelism is the execution of multiple independent tasks or computational operations at the same time rather than sequentially.

What kinds of sequential processing are there?

Kinds of sequential processing include workflow.

What is sequential processing a kind of?

Sequential processing is a kind of action. An action is a choice or operation selected or performed by an actor that can affect a system, environment, or process.

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.