Review AP CSP Unit 4 to understand how the Internet transmits data through packets, how redundancy keeps networks running when parts fail, and how parallel and distributed computing speed up programs. These concepts appear across roughly 10 multiple-choice questions and do not appear in the Create performance task.
Use the topic guides, key terms, and practice questions linked on this page to work through every official 4.1-4.3 concept before exam day.
Unit 4 explains the physical and logical infrastructure behind the Internet and modern computing. You will trace how data moves from sender to receiver as packets, examine why the Internet keeps working even when devices fail, and compare sequential, parallel, and distributed computing models by calculating execution time and speedup.
The Internet is a network of interconnected networks that routes data as packets using open protocols like IP, TCP, and HTTP. Redundancy through multiple paths makes it fault-tolerant. Parallel computing splits a program across simultaneous operations; distributed computing splits it across multiple devices. Both improve speed, but efficiency is always limited by the remaining sequential portion.
Data travels as packets that each carry a chunk of data plus metadata for routing and reassembly. Packets can arrive in order, out of order, or not at all. IP handles addressing, TCP ensures reliable delivery, UDP prioritizes speed, and HTTP is the protocol the World Wide Web uses on top of the Internet.
The Internet is fault-tolerant because it is built with redundancy: more than one path exists between most connected devices. If a device or link fails, routing dynamically finds an alternate path. A system with no alternate path has a single point of failure and is vulnerable to total outage.
Sequential computing runs one step at a time; total time equals the sum of all steps. Parallel computing runs some steps simultaneously; total time equals the sequential portion plus the longest parallel task. Distributed computing spreads work across multiple devices to handle problems too large or slow for one machine. Speedup is measured as sequential time divided by parallel time.
Every concept in Unit 4 connects to one design principle: systems should keep working and grow without breaking. Open protocols let any device join the Internet. Dynamic routing and redundancy keep data flowing when parts fail. Parallel and distributed models let programs scale beyond what a single processor or machine can handle. Understanding these trade-offs, including why adding more parallel processors eventually stops helping, is the core reasoning skill this unit tests.
How computing devices form networks, how the Internet routes packets using open protocols like IP, TCP, UDP, and HTTP, and how the World Wide Web differs from the Internet itself.
How redundancy, especially multiple paths between devices, makes the Internet fault-tolerant, and how to identify single points of failure in a network diagram.
How sequential, parallel, and distributed computing models compare, how to calculate execution time and speedup, and why the sequential portion of a program limits efficiency gains.
AP Computer Science Principles Big Idea 4 review: the Internet, fault tolerance, and parallel computing. 11-15% of the exam, key vocab, and practice links.
This snapshot uses Fiveable practice activity to show where students tend to miss questions and which review moves are worth prioritizing first.
Across 10k multiple-choice practice attempts for this unit.
Practice activity included in this snapshot.
Review Parallel and Distributed Computing with attention to how the concept appears in AP-style source and evidence questions.
Review The Internet with attention to how the concept appears in AP-style source and evidence questions.
Review Fault Tolerance with attention to how the concept appears in AP-style source and evidence questions.
The Internet is a computer network made of interconnected networks that communicate using open, standardized protocols. Any computing device, including computers, tablets, servers, routers, and smart sensors, can connect as long as it can run a program and reach an Internet-connected device. Data is broken into packets that each carry a data chunk and metadata. Packets travel from sender to receiver along dynamically chosen routes and are reassembled at the destination. The Internet is distinct from the World Wide Web: the Web is a system of linked pages and files that runs on top of the Internet using HTTP.
Can you explain why packets from the same message might arrive out of order, and which protocols (IP, TCP, UDP, HTTP) handle which jobs?
| Protocol | Layer / Purpose | Key characteristic |
|---|---|---|
| IP | Addressing and routing packets | Identifies sender and receiver addresses |
| TCP | Reliable data delivery | Ensures ordered, complete packet delivery |
| UDP | Fast, lightweight delivery | No guaranteed order or delivery; lower overhead |
| HTTP | Web communication | Protocol the World Wide Web uses; runs over the Internet |
The Internet is engineered to be fault-tolerant: it can keep functioning even when individual devices or connections fail. The main mechanism is redundancy, which means including extra components or paths so that if one fails, others take over. Network redundancy specifically means having more than one path between connected devices. When a link or device goes down, routing automatically directs subsequent packets along a different route. A system with only one path between two points is vulnerable because that single connection is a point of failure. Adding redundancy costs more resources but increases reliability.
Given a network diagram, can you identify which connections are redundant and which device or link removal would cause a complete failure?
| Scenario | Fault-tolerant? | Reason |
|---|---|---|
| Two paths exist between A and B | Yes | If one path fails, data reroutes through the other |
| Only one path exists between A and B | No | Failure of that path cuts off all communication |
| Extra router added as backup | Yes | Redundant component takes over if primary fails |
Sequential computing runs operations one at a time; total time is the sum of every step. Parallel computing breaks a program into smaller operations and runs some simultaneously on multiple processors; total time equals the sequential portion plus the longest parallel task. Distributed computing uses multiple separate devices to run a program, enabling problems too large or slow for one machine. Speedup is calculated as sequential time divided by parallel time. Efficiency gains from parallelism are always limited by the portion of the program that must remain sequential, a constraint described by Amdahl's Law. At some point, adding more parallel processors yields no meaningful improvement.
If a task has 4 steps that can run in parallel (each taking 2 seconds) and 1 sequential step taking 3 seconds, what is the total parallel execution time and the speedup compared to running all 5 steps sequentially?
| Model | How it works | Total time formula | Key benefit |
|---|---|---|---|
| Sequential | One operation at a time | Sum of all steps | Simple, predictable |
| Parallel | Some steps run simultaneously on one system | Sequential portion + longest parallel task | Faster for divisible problems |
| Distributed | Multiple devices each handle part of the program | Depends on coordination and longest task | Handles problems too large for one machine |
Try AP-style multiple-choice questions and written prompts after you review the notes.
A timed, AP-style test built only from unit 4 questions — multiple choice plus free response, scored with AI feedback. Use the standard format or build your own.
| Term | Definition |
|---|---|
| Computer network | A group of interconnected computing devices capable of sending or receiving data. The Internet is a computer network made of many interconnected networks. |
| Routing | The process of finding a path from sender to receiver across a network. On the Internet, routing is dynamic and not fixed in advance. |
| Bandwidth | The maximum amount of data that can be transmitted over a network connection in a fixed amount of time, measured in bits per second. |
| TCP | Transmission Control Protocol; ensures reliable, ordered delivery of data packets across the Internet. |
| HTTP | HyperText Transfer Protocol; the protocol used by the World Wide Web to transmit data between clients and servers. |
| World Wide Web | A system of linked pages, programs, and files that uses HTTP and runs on top of the Internet. It is not the same as the Internet. |
| Redundancy | The inclusion of extra components or paths so a system can keep functioning if primary components fail. |
| network redundancy | Having more than one path between connected devices so data can reroute around a failed link or device. |
| Scalability | The capacity of a system to change in size and scale to meet new demands. The Internet was designed to be scalable so new devices can join easily. |
| Sequential Computing | A model where operations run one at a time in order; total execution time equals the sum of all steps. |
| Amdahl's Law | The principle that efficiency gains from parallel computing are limited by the sequential portion of a program; adding more parallel processors eventually yields diminishing returns. |
| Sender | The device that initiates and transmits data across a network toward a receiver. |
| Receiver | The device that receives and reassembles data transmitted by a sender. |
| Computing devices | Physical artifacts that can run a program, including computers, tablets, servers, routers, and smart sensors. |
The Internet is the physical and logical network infrastructure. The World Wide Web is one service that runs on it. HTTP is a Web protocol, not the Internet itself. Exam questions often test whether you can keep these separate.
Parallel execution time is the sequential portion plus the longest single parallel task, not the sum of all parallel tasks. If four tasks each take 2 seconds and run simultaneously, they contribute 2 seconds total, not 8.
Amdahl's Law says the sequential fraction of a program is a hard ceiling on speedup. Once the parallel portion is fully optimized, adding more processors does nothing for the sequential steps.
A network is only fault-tolerant if there are multiple paths between devices. A chain of devices with only one path between each pair has single points of failure even though it has many devices.
TCP guarantees ordered, complete delivery but has more overhead. UDP is faster with less overhead but does not guarantee delivery or order. Choosing between them depends on whether reliability or speed matters more for the application.
Multiple-choice questions often present a diagram of connected devices and ask you to identify whether the network is fault-tolerant, locate a single point of failure, or trace a valid path from sender to receiver after a link is removed. Practice reading these diagrams and applying the definitions of redundancy and fault tolerance directly to the visual.
Questions give a task broken into sequential and parallel steps with time values and ask you to calculate total parallel execution time or speedup. Know the formulas cold: parallel time = sequential portion + longest parallel task; speedup = sequential time / parallel time. Questions also ask you to reason about why adding more processors stops improving performance.
Questions ask you to match protocols (IP, TCP, UDP, HTTP) to their functions, explain what packet metadata is used for, or distinguish the Internet from the World Wide Web. A common task is reading a scenario about data transmission and identifying which protocol property (reliability, speed, addressing) applies.
Describe how data is broken into packets with metadata, routed dynamically across the Internet, and reassembled at the destination, including what happens when packets arrive out of order or not at all.
The Internet is the underlying network infrastructure. The Web is a system of linked pages and files that uses HTTP and runs on top of the Internet.
Know which protocol handles addressing (IP), reliable ordered delivery (TCP), fast low-overhead delivery (UDP), and Web communication (HTTP).
Given a network diagram, identify redundant paths, explain how rerouting works when a link fails, and recognize which configurations have a single point of failure.
Apply the formulas: parallel time = sequential portion + longest parallel task; speedup = sequential time / parallel time.
State that the sequential portion of a program caps efficiency gains, so adding more parallel processors eventually yields no meaningful speedup (Amdahl's Law).
Describe when each model is appropriate, including that distributed computing handles problems too large or slow for a single machine.
Read the 4.1 topic guide on the Internet. Sketch a diagram showing a sender, multiple routers, and a receiver. Label where routing decisions happen, what a packet contains, and which protocol (IP, TCP, UDP, HTTP) applies at each layer. Write one sentence distinguishing the Internet from the World Wide Web.
Read the 4.2 topic guide on fault tolerance. Draw two small network diagrams: one with redundant paths and one with a single point of failure. For each, explain what happens when one link is removed. Use the key terms redundancy, fault-tolerant, and network redundancy in your explanation.
Read the 4.3 topic guide on parallel and distributed computing. Work through at least three execution-time problems: identify the sequential portion, identify the parallel tasks, apply the parallel time formula, and calculate speedup. Then write a one-paragraph explanation of why the sequential portion limits efficiency gains.
Without notes, write a comparison of sequential, parallel, and distributed computing that includes the time formula for each, one benefit, and one limitation. Check your answer against the 4.3 topic guide and the comparison table in the review notes above.
Work through the 25+ available practice questions for Unit 4. Flag any question involving packet routing, network diagrams, or execution-time calculations that you miss, and return to the relevant topic guide section. Use the AP score calculator to estimate where your current performance puts you.
Open the individual guides for Unit 4 when you want a closer review of one topic.
Use AP-style practice after you review the notes so you can check what you understand.
Practice free-response reasoning and compare your answer with scoring guidance.
Watch past review streams filtered to Unit 4 when you want a video walkthrough.
Open the Fiveable one-page unit review, then explore visual cheatsheets for a quick refresher.
Estimate your broader AP score goal after you review the course and exam format.
Print the unit cheatsheets ($3) or unit exams ($5) for Unit 4. Yours to keep, no subscription needed.
get printablesAP CSP Unit 4: Computer Systems and Networks covers 3 topics: **4.1 The Internet** (how data travels through packets and protocols), **4.2 Fault Tolerance** (how networks stay reliable when parts fail), and **4.3 Parallel and Distributed Computing** (how splitting tasks across devices speeds up processing). See AP CSP Unit 4 for full coverage.
The AP CSP Unit 4 progress check on AP Classroom includes both MCQ and FRQ parts drawn from all three unit topics: The Internet, Fault Tolerance, and Parallel and Distributed Computing. MCQ questions test how packets route and how networks handle failure. FRQ questions ask you to explain or analyze computing scenarios from those same topics. For matched practice, visit AP CSP Unit 4.
AP CSP Unit 4 FRQs most often draw from 4.1 The Internet and 4.3 Parallel and Distributed Computing, asking you to explain how data moves through a network, describe fault-tolerant design, or compare sequential vs. parallel processing. Practice by writing out full explanations in your own words, then checking that you named specific concepts like packets, routing, and parallel speedup. Find practice prompts at AP CSP Unit 4.
For AP CSP Unit 4 practice questions, including multiple-choice and practice test sets, head to AP CSP Unit 4. You'll find MCQ questions covering The Internet, Fault Tolerance, and Parallel and Distributed Computing. Mixing MCQ drills with short written explanations is the best way to prep for both the progress check and the end-of-course exam.
Start AP CSP Unit 4 by building a clear picture of how the Internet moves data through packets, then move to Fault Tolerance so you understand why redundant paths matter. Finish with Parallel and Distributed Computing, focusing on when parallelism actually speeds things up vs. when it doesn't. Draw diagrams for network paths, write out your own fault-tolerant network example, and test yourself with MCQs at AP CSP Unit 4 after each topic.