Must-know sheet

Computer Science Principles must-know sheet

The terms, pseudocode rules, binary and internet facts, and Create task tips you should know cold for AP Computer Science Principles, organized by the five Big Ideas. Start with what's new for May 2027. The real exam gives you the exam reference sheet of pseudocode instructions, so this sheet focuses on how that code actually behaves, the patterns you'll trace, and everything else the reference sheet doesn't cover.

What's new: recent changes to the course and exam

Units 1, 2, 3, 4, 5

May 2027: no changes to the course or the exam format: The course description from fall 2023 is still the current one. College Board's only update since then (August 2025) rewrote its introduction, not any topic, skill or exam detail, and College Board lists no others coming. Your Create task is due by 11:59 p.m. ET on April 30, 2027, and the exam is on May 14, 2027.
Since May 2024: the written responses happen on exam day: You don't write answers when you submit your Create task. You submit your code, a video and your Personalized Project Reference (PPR), then answer 2 questions (4 prompts) about your own code on exam day, with your PPR in front of you. Practice materials that have you submit written responses (labeled 3a to 3d) with your program use the old format.
The whole exam is in Bluebook: Both the multiple-choice questions and the written responses are taken in the Bluebook app, and your answers are submitted automatically when time runs out. The exam reference sheet is in Bluebook, and schools also get printed copies. Try Bluebook's test preview before exam day.
AI tools on the Create task: allowed, with credit: You may use AI tools to learn, to help write code and to debug, much like getting help from a partner. Mark any AI-written code with a comment such as "This code was generated using" and the tool's name, check that it works, and be ready to explain it on exam day. Using it without credit is plagiarism and scores 0 on the whole Create task, written responses included.

The exam and the five Big Ideas

Units 1, 2, 3, 4, 5

Multiple choice: 70 questions in 120 minutes, 70% of your score: Every question has 4 choices: 57 have one answer, 5 go with one reading passage about a computing innovation, and 8 say "Select two answers." On those 8, pick exactly two, and check each choice on its own. There's no penalty for guessing, so answer everything.
Create task plus 2 written-response questions: 30% of your score: You build a program in class (at least 9 hours), submit the code, a video and your Personalized Project Reference by 11:59 p.m. ET on April 30, 2027, then answer 2 questions (4 prompts) about your own program in a 60-minute section of the exam on May 14, 2027. It's scored on 6 one-point rows: video, program requirements, WR1, WR2(a), WR2(b) and WR2(c).
The exam reference sheet is provided: You get College Board's sheet of pseudocode instructions (assignment, operators, IF, REPEAT, list procedures, procedures and the robot) in Bluebook and on paper. You don't need to memorize the syntax, but you do need to know how each instruction behaves; the pseudocode sections below cover the traps. No calculator is allowed.
Big Idea 1: Creative Development (10–13%): Collaboration, a program's purpose and function, the development process, documentation, and finding and fixing errors.
Big Idea 2: Data (17–22%): Bits and binary, overflow and round-off, compression, metadata, cleaning data and using programs to find patterns.
Big Idea 3: Algorithms and Programming (30–35%): The biggest share of the exam: variables, lists, expressions, conditionals, loops, procedures, searching, simulations, efficiency and undecidable problems. Expect lots of code tracing.
Big Idea 4: Computer Systems and Networks (11–15%): How the internet works, fault tolerance, and sequential, parallel and distributed computing.
Big Idea 5: Impact of Computing (21–26%): Good and bad effects, the digital divide, bias, crowdsourcing, legal and ethical issues, and safe computing. The 5 reading-passage questions are about a computing innovation, so this material matters there too.

Creative development: teams, purpose and process

Unit 1

Computing innovation: Anything that has a program as an essential part of how it works. It can be physical (a self-driving car), software (a photo editor) or an idea (online shopping).
Why diverse teams help: People with different backgrounds and skills notice needs and problems one person would miss, and that helps keep bias out of what they build. Talking with users (surveys, interviews, user testing, watching people use it) shows what they really need.
How teams work together: Pair programming (one person types while the other reviews, then you swap) and online tools for sharing code and feedback. Good teams use communication, consensus building, conflict resolution and negotiation.
Purpose vs. function: Purpose is why the program exists: the problem it solves or the creative interest it pursues. Function is what it actually does when it runs, often described by how a user interacts with it.
Input and output: Input is data sent to a program (typed text, a click, a sensor reading, a file, another program); output is data sent from the program to a device (text, sound, an image, movement). Output usually depends on the input or on values the program has stored.
Events and event-driven programs: An event is an action like a click, a key press or the program starting. In an event-driven program, code runs when its event happens rather than straight from top to bottom.
Iterative vs. incremental development: Iterative: build, get feedback, test or reflect, then go back and revise, possibly revisiting earlier steps. Incremental: break the problem into small pieces and make sure each piece works before adding it to the whole.
Design phase: Investigation first finds the requirements (what the program must do, including user interactions); the specification is that full list of requirements. Design can include brainstorming, storyboarding, splitting the program into modules, sketching the user interface and planning how you'll test it.
Documentation and comments: Documentation describes what a code segment, procedure or program does and how it was developed. Comments are documentation inside the code; people read them and they don't change how the program runs. Document as you go, not just at the end.
Giving credit for code: Acknowledge any code written by someone else or with a partner, ideally in a comment that names the source or author. On the Create task, code or media you didn't write (including AI-generated code) must be credited, or the whole task can score 0.

Errors and testing

Units 1, 2, 3

Syntax error: The code breaks the language's rules, like a missing bracket or a misspelled command, so it won't run at all.
Logic error: The program runs but gives the wrong result or behaves unexpectedly, like using < where you meant ≤, or starting a maximum at 0 when every value is negative.
Run-time error: A mistake that shows up while the program is running. On the exam, the classic one is a list index below 1 or above LENGTH(aList), which stops the program with an error.
Overflow error: A number is outside the range the program can hold. With 3 bits the biggest whole number is 7 (111), so 7 + 1 overflows. In the exam's pseudocode, whole numbers are limited only by the computer's memory, so overflow only comes up in questions about a fixed number of bits.
Ways to find errors: Test cases, tracing by hand, visualizations, debuggers and adding extra DISPLAY statements to see values as the program runs.
Choosing test inputs: Pick inputs whose correct output you already know, and cover each possible outcome. Include values at the edges and just past them: the smallest and largest allowed values, an empty list, a list of one item, and a value that isn't in the list.
Tracing tip: Make a table with a column for each variable and a row for each step or loop pass, and update it line by line. Don't guess what the code "means"; do exactly what it says.

Bits, binary and data representation

Unit 2

Bit and byte: A bit (binary digit) is a 0 or a 1, and a byte is 8 bits. Everything a computer stores is bits at the lowest level.
Same bits, different meanings: Bits are grouped to stand for numbers, letters, colors, sounds and more. The same bit pattern can mean different things depending on how the program reads it.
Binary place values: From the right, the places are 1, 2, 4, 8, 16, 32, 64, 128 (each is 2 raised to the position, starting at position 0). Add up the places that hold a 1: 101101 is 32 + 8 + 4 + 1 = 45, and 11010 is 16 + 8 + 2 = 26.
Decimal to binary: Take the biggest place value that fits, write a 1 there, subtract, and repeat; every place you skip gets a 0. For 45: 32 fits (13 left), 16 doesn't, 8 fits (5 left), 4 fits (1 left), 2 doesn't, 1 fits, giving 101101.
Comparing binary numbers: If they have the same number of digits, the first place from the left where they differ decides: the one with the 1 there is bigger (1100 is 12, more than 1011, which is 11). Otherwise convert both to decimal.
n bits give 2ⁿ values: With n bits you can represent 2ⁿ different values, from 0 up to 2ⁿ − 1 for whole numbers. 8 bits give 256 values (0 to 255). Each extra bit doubles the number of values; it doesn't just add one.
How many bits do you need?: Find the smallest n with 2ⁿ at least the number of values. 26 letters need 5 bits (2⁵ = 32); 1,000 values need 10 bits (2¹⁰ = 1,024).
Fixed bits limit numbers: When a language uses a fixed number of bits for whole numbers, their range is limited and overflow can happen. Real numbers (decimals) stored in fixed bits are often only approximations, which causes round-off errors.
Analog vs. digital data: Analog data changes smoothly over time, like the volume of a song or the temperature through a day. Sampling measures it at regular intervals and stores each sample in bits, so the digital version only approximates the original; using digital data this way is an example of abstraction.
Abstraction: Reducing complexity by focusing on the main idea and hiding details that don't matter right now. Bits standing for a color, a list standing for many values and a procedure standing for many steps are all abstractions.

Compression and working with data

Unit 2

Compression: Reduces the number of bits needed to store or send data. Fewer bits doesn't always mean less information. How much it saves depends on how much repetition the data has and on the method used.
Lossless compression: The original can be rebuilt exactly. Choose it when quality or getting the exact original back matters most, like text, code, spreadsheets or medical images.
Lossy compression: Throws away some detail, so only an approximation can be rebuilt, but it usually makes files much smaller than lossless can. Choose it when small size or fast sending matters most, like streaming video or photos for a website.
Information vs. data: Information is the facts and patterns you pull out of data. Combining data from several sources is often needed to reach a conclusion.
Correlation is not causation: Data can show two things rising or falling together, but that doesn't prove one causes the other. More research is needed to know why.
Metadata: Data about data, like a photo's date, location or file size. It helps you find, organize and manage data, and changing or deleting metadata doesn't change the data itself.
Cleaning data: Making data uniform without changing its meaning, like turning "CA," "Calif." and "california" into one spelling. Data can also be incomplete or invalid, and data typed into open fields often isn't uniform.
Bias in data: Bias often comes from what kind of data was collected or where it came from. Collecting more of the same data doesn't remove it.
Big data needs more computing power: Bigger data sets can reveal more, but they can be too large for one computer to process, so they may need parallel or distributed systems. Scalability (a system's ability to grow to meet demand) matters.
What programs do with data: Filter it (keep only the items that match a condition), transform it (change every item, like converting units), combine or compare it (a total, the highest value), and visualize it in tables and charts to spot patterns. Clustering and classifying data are also ways to gain insight.

Pseudocode rules that trip people up

Unit 3

a ← expression stores a copy: The right side is worked out first, then stored in a, replacing what was there. A variable holds only its most recent value, and changing one variable later doesn't change another that was copied from it:x ← 5 y ← x x ← x + 3 DISPLAY(y)This displays 5, not 8.
= compares, ← assigns: a = b is a true-or-false test, not a way to store a value. The comparison operators are =, ≠, >, <, ≥ and ≤.
DISPLAY adds a space: Each DISPLAY shows its value followed by a space, all on one line, so DISPLAY(1) then DISPLAY(2) shows 1 2. Answer choices list the outputs separated by spaces.
/ is ordinary division: 9 / 4 is 2.25 and 7 / 2 is 3.5; nothing is rounded or cut off.
a MOD b is the remainder: 20 MOD 6 is 2, 12 MOD 3 is 0 and 4 MOD 7 is 4 (a smaller number MOD a bigger one is just the smaller number). MOD ranks with * and /, worked left to right: 3 + 10 MOD 4 * 2 is 3 + (2 × 2) = 7.
RANDOM(a, b) includes both ends: It returns a whole number from a to b, each equally likely. RANDOM(5, 10) has 6 possible values: 5, 6, 7, 8, 9 and 10.
Lists start at index 1: aList[1] is the first element and aList[LENGTH(aList)] is the last. Any index below 1 or above LENGTH(aList) stops the program with an error, so watch for off-by-one mistakes.
INSERT, APPEND, REMOVE, LENGTH: INSERT(aList, i, value) puts value at index i and shifts later items right; APPEND(aList, value) adds to the end; REMOVE(aList, i) deletes index i and shifts later items left; LENGTH(aList) is the number of items. Starting from nums ← [10, 20, 30], INSERT(nums, 2, 15) gives [10, 15, 20, 30], then REMOVE(nums, 1) gives [15, 20, 30].
aList ← bList copies the list: On the exam this makes aList a separate copy, so later changes to bList don't change aList.
REPEAT n TIMES vs. REPEAT UNTIL (condition): REPEAT n TIMES runs its block exactly n times. REPEAT UNTIL checks its condition before each pass and stops as soon as it's true, so the body may run 0 times, and it loops forever if the condition can never become true.
REPEAT UNTIL off-by-one check: Count the passes carefully. The loop below displays 1 2 3 4; with REPEAT UNTIL (i = 4) it would display only 1 2 3.i ← 1 REPEAT UNTIL (i > 4) { DISPLAY(i) i ← i + 1 }
FOR EACH item IN aList: item takes each element's value in order, from first to last. It's a copy of the value, not its index, so assigning to item doesn't change the list; use an index variable when you need positions or want to change elements.
RETURN leaves the procedure at once: Nothing after a RETURN in that procedure runs, even inside a loop. A procedure without RETURN still runs its steps, but it doesn't give back a value to store.
AND, OR, NOT: a AND b is true only when both are true; a OR b is true when at least one is true (including both); NOT flips true and false. NOT (x > 5) is the same as x ≤ 5, not x < 5.
Flipping AND and OR: NOT (a AND b) is the same as (NOT a) OR (NOT b), and NOT (a OR b) is the same as (NOT a) AND (NOT b). Check "which is equivalent" questions with a quick truth table.
The robot: MOVE_FORWARD() moves one square the way the robot faces; ROTATE_LEFT() and ROTATE_RIGHT() turn it 90° in place; CAN_MOVE(direction) is true if the square to its left, right, front or back is open. If the robot tries to move into a blocked square or off the grid, it stays put and the program stops.

Pseudocode patterns to know

Unit 3

Swap two variables: You need a temporary variable; a ← b then b ← a leaves both equal to b's old value.temp ← a a ← b b ← temp
Sum and average of a list: Start the total at 0 and add each item; the average is the total divided by LENGTH(numList).total ← 0 FOR EACH num IN numList { total ← total + num } average ← total / LENGTH(numList)
Maximum (or minimum) of a list: Start with the first element, not 0, so the answer is right even when every value is negative. For the minimum, flip > to <.maxVal ← numList[1] FOR EACH num IN numList { IF (num > maxVal) { maxVal ← num } }
Count the items that match: Start a counter at 0 and add 1 each time the condition is true.count ← 0 FOR EACH item IN aList { IF (item = target) { count ← count + 1 } }
Filter into a new list: Make an empty list and APPEND only the items that pass the test. This keeps the even numbers:evens ← [] FOR EACH num IN numList { IF (num MOD 2 = 0) { APPEND(evens, num) } }
Even, odd and "divides evenly": n MOD 2 = 0 means n is even and n MOD 2 = 1 means odd (for whole numbers 0 or more). n MOD d = 0 means d divides n evenly, so 12 MOD 3 = 0 is true.
Linear search that returns a position: Check each item in order and stop as soon as you find it; returning −1 (or false) signals "not found."PROCEDURE findIndex(aList, target) { index ← 1 FOR EACH item IN aList { IF (item = target) { RETURN(index) } index ← index + 1 } RETURN(-1) }
"All" checks: return true only after the loop: Return false as soon as one item fails, but return true only once the loop has checked every item. Putting RETURN(true) in an ELSE inside the loop is a common logic error: it decides after the first item.PROCEDURE allPositive(numList) { FOR EACH num IN numList { IF (num ≤ 0) { RETURN(false) } } RETURN(true) }
Removing items while going through a list: After REMOVE, the next item slides into the same index, so only move on when you didn't remove anything. Always adding 1 skips items: on [5, 5, 2] it would leave a 5 behind.i ← 1 REPEAT UNTIL (i > LENGTH(aList)) { IF (aList[i] = target) { REMOVE(aList, i) } ELSE { i ← i + 1 } }
Conditionals that do the same thing: Different code can give the same result. A nested IF (x > 0) around IF (x < 10) acts like one IF (x > 0 AND x < 10), and IF (x > 5) that sets result to true, ELSE false, can be replaced by result ← (x > 5). Check with values at and next to each boundary (like 0, 1, 9 and 10).
Building from algorithms you know: New algorithms are often existing ones combined or modified: maximum and minimum, sum and average, divisibility with MOD, and finding a robot's path through a maze. Reusing correct pieces saves time and makes errors easier to find.

Variables, lists, procedures and abstraction

Unit 3

Algorithm: sequencing, selection and iteration: An algorithm is a finite set of steps that does a specific task. Every algorithm can be built from three things: sequencing (steps run in the order they're written), selection (an IF decides which steps run) and iteration (a loop repeats steps). Algorithms can be written in plain language, diagrams, pseudocode or a programming language.
Variable: A named abstraction that holds one value at a time, though that value can be a list. Meaningful names like score make code easier to read. Common types are numbers, Booleans, strings and lists.
Strings: A string is an ordered sequence of characters. Concatenation joins strings end to end ("sun" and "flower" make "sunflower"), and a substring is part of a string. Any other string procedure you need is explained in the question.
List, element and index: A list is an ordered sequence of elements; each element has a unique index, starting at 1 on the exam. A list lets many related values be treated as one value with one name.
Data abstraction: Giving a collection of data one name (a list) so you can use it without dealing with every separate value. It makes a program easier to write, and easier to change: if the number of items changes, the code that loops through the list still works.
Procedure, parameter, argument: A procedure is a named group of instructions that may take parameters and return a value; other languages call it a function or method. Parameters are the input variables in the definition, and arguments are the actual values in a call, like total ← addUp(3, 5).
What a call does: A call pauses the program, runs the procedure's steps, then continues right after the call, using the returned value if there is one.
Procedural abstraction: You can use a procedure knowing only what it does, not how. Parameters let one procedure handle many inputs instead of copying similar code, and the inside can be changed (say, made faster) without changing the code that calls it, as long as it still does the same job.
Modularity: Splitting a program into separate procedures that each solve a smaller subproblem. It makes code easier to read, test, fix and reuse.
Libraries and APIs: A library is a collection of procedures someone else has written that you can use in new programs. Its API (application program interface) specifies how each procedure behaves and how to call it, and its documentation is how you learn to use it.

Searching, efficiency and what can't be solved

Unit 3

Linear (sequential) search: Checks each element in order until it finds the value or runs out. It works on any list, sorted or not; the worst case checks every element.
Binary search: Checks the middle of a sorted list and throws away the half that can't hold the value, repeating until it's found or nothing is left. The data must be sorted first. It's usually much faster than linear search on large lists.
How many checks binary search needs: Each check throws away about half of what's left, so doubling the list adds just one check. In the worst case that's at most 7 checks for 100 items, 10 for 1,000 and 20 for 1,000,000, against 100, 1,000 and 1,000,000 for a linear search.
Efficiency: How much time or memory an algorithm uses as its input grows, measured informally by counting how many times a statement runs. Different correct algorithms for the same problem can have very different efficiencies.
Reasonable vs. unreasonable time: Steps that grow like a polynomial or slower (constant, n, n², n³) are reasonable. Steps that grow exponentially or faster (2ⁿ, n!) are unreasonable: by n = 20, 2ⁿ is over 1,000,000 while n³ is 8,000.
Heuristic: When finding the best answer would take unreasonable time, a heuristic finds an answer that's good enough but not guaranteed to be the best.
Problem vs. instance: A problem is a general task, like sorting; an instance is that task with specific input, like sorting [2, 3, 1, 7].
Decision vs. optimization problem: A decision problem has a yes-or-no answer (Is there a path from A to B?). An optimization problem looks for the best answer (What's the shortest path from A to B?).
Decidable vs. undecidable: A decision problem is decidable if some algorithm gives the right answer for every input. It's undecidable if no algorithm can always give a correct yes or no, though some instances may still be solvable. You won't be asked to work out whether a given problem is undecidable.

Random values and simulations

Unit 3

Each run can differ: A program that uses RANDOM may give a different result each time, so for "which outputs are possible" questions, list every possible value and check each choice.
Probability with RANDOM: Count the values that work and divide by how many values there are. RANDOM(1, 100) ≤ 30 is true 30% of the time, a handy way to make something happen with a set chance.
Two rolls are not one big range: RANDOM(1, 6) + RANDOM(1, 6) gives 2 to 12, but 7 is the most likely total (1 in 6) and 2 is rare (1 in 36). RANDOM(2, 12) makes all 11 totals equally likely, so it doesn't simulate two dice.
Simulation: A program that models a real system or event, often with random values to copy real-world variety. It's most useful when real experiments would be too big, small, fast, slow, expensive or dangerous, and it helps people form and refine hypotheses.
Simulations simplify, and can be biased: Building one means leaving out details, which makes it workable but less exact. The choices about what to include or leave out can add bias, so results only approximate the real world.

The internet, fault tolerance and parallel computing

Unit 4

Computing device, system and network: A computing device is a physical thing that can run a program (computer, phone, server, router, smart sensor). A computing system is devices and programs working together, and a network is a system of connected devices that can send and receive data.
Path and routing: A path is a chain of directly connected devices from the sender to the receiver. Routing is finding that path; on the internet it's usually dynamic, decided as data travels rather than set in advance.
Bandwidth: The most data a connection can send in a fixed amount of time, usually measured in bits per second.
The internet: A network of networks that use open (nonproprietary) protocols, so anyone can connect new devices. It was designed to be scalable: able to grow to meet new demand.
Protocol: An agreed-upon set of rules for how a system behaves. Because internet protocols are open, any manufacturer's devices can communicate.
Packets: Data is sent as a stream of chunks, each in a packet with metadata used to route it and put the data back together. Packets can arrive in order, out of order or not at all.
IP, TCP and UDP: Common internet protocols. IP handles addressing and getting packets to the right destination; TCP makes sure all packets arrive and are put back in order, resending any that are lost; UDP sends packets faster without checking that they arrived, which suits live video or games.
The Web is not the internet: The World Wide Web is a system of linked pages, programs and files that runs on the internet and uses HTTP. Email, games and video calls use the internet without being the Web.
Redundancy and fault tolerance: Redundancy means extra parts, like more than one path between two devices. If a device or connection fails, data is sent another way, so the system keeps working; that's fault tolerance. Redundancy costs more resources but makes the internet more reliable and helps it scale.
Counting failures on a network diagram: To ask whether two devices can still communicate, remove the failed connections or devices and look for any remaining path. To find the fewest failures that cut them off, look for the smallest set of connections that every path must use.
Sequential computing: Operations run one at a time, in order. Its time is the sum of all the steps.
Parallel computing: The program is split into smaller tasks, some of which run at the same time on different processors. Its time is the time of the steps that must run in order plus the longest of the tasks running side by side.
Distributed computing: Several devices work on one program. It can solve problems too big for one computer, because of the time or storage they'd need, and handles big problems much faster.
Speedup = sequential time ÷ parallel time: Tasks of 20, 30, 40 and 50 seconds take 140 seconds one after another. On two processors the best split is 50 + 20 and 40 + 30, so 70 seconds, and the speedup is 140 ÷ 70 = 2. Add a 10-second step that must come first: 150 ÷ 80 = 1.875.
Splitting tasks on two processors: Try to balance the two processors' totals. A processor can only run one task at a time, so the parallel time is the larger of the two totals, plus any steps that must run in order.
Limits of parallel computing: Parallel solutions scale better than sequential ones, but the part that must run in order always limits the speedup. At some point, adding more processors no longer helps much.

Impact of computing on people and society

Unit 5

Effects can be good and bad: One innovation can help some people and harm others, and the same effect can look good to one person and bad to another. Not every effect is planned, and fast, wide sharing can make the effects bigger than the creator intended.
Unintended uses: People use innovations in ways the creators never planned. The Web was first meant for scientists to share information; targeted ads help businesses but can be misused; machine learning and data mining drive discoveries but have also been used to discriminate. Responsible programmers think about possible misuse, but can't foresee everything.
Digital divide: The gap in access to computing devices and the internet, based on things like income, location (for example, rural vs. urban) and age. It exists between countries and within communities, raises issues of equity and access, and is affected by the actions of individuals, organizations and governments.
Computing bias: Programs can reflect human biases, either written into the algorithm or present in the data, and bias can enter at any stage of development. Programmers should reduce it, for example by testing with varied data and users.
Crowdsourcing: Getting ideas, information, work or money from a large number of people over the internet, like crowdfunding or a shared map that users update.
Citizen science: Research done partly or fully by many people, many of them not scientists, who contribute data using their own devices, like reporting bird sightings with a phone app.
Intellectual property and plagiarism: What you create on a computer is your (or your organization's) intellectual property. Digital work is easy to copy, which makes protecting it hard. Using someone else's work without permission and passing it off as your own is plagiarism and can have legal consequences; always cite work you use.
Creative Commons: A public copyright license a creator uses to let others share, use and build on their work freely.
Open source and open access: Open source: programs made freely available that anyone can share and change. Open access: research published online with no barriers to reading it and few limits on using it. Both, like Creative Commons, widen access to digital information.
Legal and ethical concerns: Examples include software for downloading and streaming media, algorithms that include bias, and devices that collect data by constantly monitoring people. Using computing to harm individuals or groups raises both legal and ethical concerns.

Privacy and safe computing

Unit 5

Personally identifiable information (PII): Information that identifies or describes you, like your Social Security number, age, race, phone number, medical or financial information, or fingerprints and other biometric data.
Your data gets collected and combined: Search engines, websites, apps and devices can record your searches, visits and location. Separate pieces like location, cookies and browsing history can be combined to learn a lot about you, and once something is online it's hard to delete.
Why PII is shared anyway: It can make online experiences better (useful suggestions) and buying things easier (saved details). It can also be used to stalk you, steal your identity or plan other crimes.
Strong password: Easy for you to remember but hard for anyone else to guess, even someone who knows you.
Multifactor authentication: You need at least two separate kinds of evidence to get in: something you know (a password), something you have (a phone or key), or something you are (a fingerprint). Each extra step is another layer an attacker must break.
Encryption and decryption: Encryption encodes data so only authorized people can read it; decryption decodes it. You only need the ideas on the exam, not the math.
Symmetric vs. public key encryption: Symmetric encryption uses one key both to lock and to unlock. Public key encryption uses a public key to lock and a separate private key to unlock, so anyone can send you a secret message, but only your private key can read it.
Certificate authorities: Trusted organizations that issue digital certificates confirming who owns an encryption key, so you know a secure website is really who it says it is.
Malware and viruses: Malware is software meant to damage a computer or take control of it. A virus is malware that copies itself and gets in without permission, often attached to a normal-looking program. Antivirus and malware scanners, software updates (which fix security flaws) and avoiding untrustworthy free downloads all help.
Phishing: A trick, usually a fake email, message or website, to get you to hand over personal information like passwords or bank details. Malicious links can be disguised, and messages can even come from a friend whose account was hacked.
Keylogging: A program that records every key you press to steal passwords and other private information.
Rogue access point: A wireless access point that gives unauthorized access to a network. Data sent over public networks can be intercepted, read and changed this way.
App permissions: Check which permissions programs have, like location or contacts, and turn off what they don't need.

Create task and written-response tips

Units 1, 3

Program requirements: Your program needs input, output, a list (or other collection) that stores data and is actually used, and a procedure you wrote with at least one parameter that affects what it does. That procedure must contain sequencing, selection and iteration, and the program must call it.
Personalized Project Reference (PPR): Screenshots of your own code: the procedure and a call to it, and the list being filled with data and then used. No comments or course notes allowed in it, or the task can score 0. It's the only code you'll see on exam day, so make it readable (10-point text or larger).
Video: Show your program running: input, at least one feature working, and output. It can be at most 1 minute long and 30 MB, with no voice narration (captions are fine) and nothing that identifies you.
WR1: design, function and purpose: Asks about your program as a whole: its purpose, how it works, its inputs and outputs, how you developed it, or its documentation. In 2026 it asked for a piece of documentation and how another programmer could use it to understand a particular code segment, so an answer about only the user earned nothing.
WR2(a): algorithm development: Asks how an algorithm in your procedure works, such as what its conditions or loops do with given values. In 2026 it asked about the first loop in the Procedure section of your PPR: name the variable(s) and the exact values that make it stop and explain why, or explain how it stops if no variable controls it.
WR2(b): errors and testing: Asks about finding and fixing errors, or about test inputs and the results you'd expect. In 2026 it asked for a call with specific argument values (not just "a big number") that makes your procedure behave incorrectly, what goes wrong and why; if no accepted argument can break it, you explain why that's true.
WR2(c): data and procedural abstraction: Asks how your list or your procedure manages complexity. For a list: one loop can handle any number of items instead of a separate variable and line of code for each. In 2026 it also asked how the code that uses your list would have to change without the list, or why it couldn't work without it. For a procedure: one set of steps is reused with different arguments.
How to earn each point: The wording changes each year, but the four categories stay the same. Each prompt is all-or-nothing: answer every part it asks for, about your own code, using its real variable and procedure names. Read the whole prompt twice, and make sure what you write matches what your code actually does.
Use your own code honestly: You can work with a partner on the program, but the video, PPR and written responses must be yours alone. Credit any code you didn't write, including code from AI tools, and be ready to explain every line.