Sequential computing is a computational model in which operations are performed in order, one at a time (EK CSN-2.A.1). On the AP CSP exam, a sequential solution's total time equals the sum of all its steps, which is the baseline you compare parallel and distributed solutions against.
Sequential computing is the default way a program runs. The computer executes one operation, finishes it, then moves to the next. No overlap, no shortcuts. Think of one cashier checking out a line of customers, one at a time. The CED defines it exactly that way in EK CSN-2.A.1, and EK CSN-2.A.5 gives you the math that matters: a sequential solution takes as long as the sum of all its steps. If a program has three tasks that take 30, 40, and 50 seconds, the sequential version takes 120 seconds, full stop.
That sum rule is why sequential computing is the measuring stick for everything else in Topic 4.3. Parallel computing breaks a program into smaller sequential pieces and runs some of them at the same time. Distributed computing spreads work across multiple devices. Both of those models are defined relative to the plain, one-thing-at-a-time sequential model, so you can't reason about either one without nailing this term first.
Sequential computing lives in Topic 4.3 (Parallel and Distributed Computing) in Unit 4: Computer Systems and Networks, under learning objective AP Comp Sci P 4.3.A, which asks you to compare solutions across sequential, parallel, and distributed models and determine their efficiency. It also feeds into AP Comp Sci P 4.3.B, because EK CSN-2.B.1 says every parallel solution still contains a sequential portion. That sequential portion is the speed limit. No matter how many processors you add, the part that must run in order never gets faster, which is why parallel solutions scale better than sequential ones but never become infinitely fast. On the exam, almost every efficiency calculation in Topic 4.3 starts with the sequential time and asks how much faster a parallel or distributed alternative could be.
Keep studying AP Computer Science Principles Unit 4
Parallel Computing (Unit 4)
Parallel computing is literally built out of sequential pieces. EK CSN-2.A.2 says a parallel program is broken into smaller sequential operations, some running simultaneously. The sequential portion that can't be split is what caps the speedup, so adding more processors gives smaller and smaller gains.
Multithreading (Unit 4)
Multithreading is one way real systems escape the one-at-a-time model. Each thread is its own little sequential stream of instructions, and the system runs several threads at once. It's a concrete implementation of the parallel idea Topic 4.3 describes.
Instruction Pipelining (Unit 4)
Pipelining shows that even a 'sequential' processor cheats a little. It overlaps the stages of consecutive instructions, like an assembly line, so the hardware stays busy. The program still behaves as if instructions ran in order, which is the contract sequential computing promises.
Sequential computing shows up in multiple-choice questions, usually in a compare-and-compute role. Expect stems like 'which scenario must rely on sequential computing' (tasks where each step depends on the previous result), 'what is a limitation of sequential computing when processing large datasets' (it can't scale by adding processors), and 'if the dataset doubles, what happens to a sequential algorithm's execution time' (with one processor doing everything in order, the time roughly doubles). The other common move is a timing calculation. You're given step times and asked to compare the sequential total (just add the steps) against a parallel version (longest path through the simultaneous parts plus the sequential portion). The speedup is sequential time divided by parallel time. There's no FRQ on the current AP CSP exam, so this is purely MCQ territory, but the efficiency comparisons are a reliable Unit 4 question type.
Sequential computing does one operation at a time, so total time is the sum of every step. Parallel computing splits the program into smaller sequential chunks and runs some at the same time, so total time is driven by the longest chunk plus whatever must stay sequential. The trap answer on MCQs is assuming parallel is always faster in proportion to the number of processors. It isn't, because the sequential portion never shrinks (EK CSN-2.B.1), and some tasks (where step 2 needs step 1's output) can't be parallelized at all.
Sequential computing is a computational model where operations are performed in order, one at a time (EK CSN-2.A.1).
A sequential solution takes as long as the sum of all of its steps, so to find its run time you just add every operation's time together.
You compare the efficiency of sequential, parallel, and distributed solutions by comparing the time each takes to do the same task (EK CSN-2.A.4).
Tasks where each step depends on the result of the previous step cannot be effectively parallelized and must run sequentially.
Every parallel solution still contains a sequential portion, and that portion limits how much speedup you can get no matter how many processors you add.
Parallel solutions scale better than sequential ones, which is why sequential computing struggles with very large datasets.
It's the computational model where a program's operations run in order, one at a time (EK CSN-2.A.1). Each instruction finishes before the next one starts, so the total run time is the sum of all the steps.
Add up the time of every step. If a program has tasks taking 30, 40, and 50 seconds, the sequential solution takes 120 seconds. That sum is the baseline you compare parallel solutions against on MCQs.
No. If a task's steps each depend on the previous step's result, parallelizing buys you nothing, and the sequential version is just as fast. Parallel only wins when at least some operations can genuinely run at the same time.
Sequential runs one operation at a time, so time equals the sum of all steps. Parallel breaks the program into smaller sequential pieces and runs some simultaneously, so time depends on the longest simultaneous chunk plus the part that must stay sequential.
Yes. It's part of Topic 4.3 under learning objective AP Comp Sci P 4.3.A, and it appears in multiple-choice questions that ask you to compare run times, identify tasks that can't be parallelized, or predict how a sequential algorithm's time grows when input size doubles.
Connect this key term to the AP exam workflow: review the course, practice questions, and check related study tools.
Review units, study guides, and course resources.
Check this vocabulary in multiple-choice context.
Apply key concepts in written AP responses.
Estimate the exam score you are working toward.
Review the highest-yield facts before practice.
Put the full course together before test day.