Sequential processing is the simplest way to run work: finish one task, then begin the next. Think of one washing machine handling white clothes, dark clothes, sheets, and towels in that order. Loads do not overlap because one machine is busy until its current load ends. In a program, the same pattern means ordered instructions run one at a time on one processing unit. section 2.2 section 2.14
The laundry sequence makes blocking visible: while one load uses the only machine, the next load must wait. section 2.2
A task is a logically independent piece of work, from one CPU instruction to writing a file or rotating an image. Sequential processing arranges tasks as a chain: task two follows task one, with no overlapping time periods. This is especially appropriate when a later task needs an earlier task’s result. The ordering removes a common concern: when the next operation starts, the preceding one has already finished. section 2.2 section 13.1
Turns in Tic-Tac-Toe
A game turn naturally has serial steps: accept a player’s move, check for a win or tie, then switch players. The next move cannot be checked before it exists, and giving one player two turns breaks the game’s rules. Dependencies in the algorithm therefore require sequential processing. section 2.3
Sequential processing is clear and predictable, and any program can use it. It needs no communication or synchronization between separate executing tasks. Its trade-off is limited scaling: adding processors does not make a single serial chain run simultaneously. Speeding it up instead depends on faster resources, whose performance has physical limits; unused resources may also reduce efficiency. section 2.4 section 2.10
Use sequential processing when order is part of correctness:
- A step consumes the output of the preceding step, so it must wait for that dependency. section 2.14
- The algorithm imposes an unbreakable order, as in alternating game turns. section 2.3
- The work cannot be decomposed into independent tasks with the same result in arbitrary order. section 2.8
Checking password combinations
An exhaustive password search can generate one number combination, compute its cryptographic hash, compare it with the target, and continue to the next combination until it finds a match. This one-by-one approach is easy to express, but a large search may take too long because only one task is processed at a time. Independent ranges of combinations motivate a parallel redesign. section 2.10 section 2.8
Sequential processing is not the same as concurrency. Concurrent programs divide work into independent tasks that may run in any order with the same result; parallel execution is physically simultaneous work on multiple processing resources. A single processor can also rapidly interleave tasks and appear simultaneous while still executing tasks serially at a physical level. section 13.1 section 6.8
