AP CSP Standards Reference

What this is. A locally built index of the AP Computer Science Principles framework — Practices, Big Ideas, Topics, Learning Objectives, and Essential Knowledge — for linking from standards-alignment work (AP CSP Course and Exam Description, effective Fall 2023 (V.1)). What this is not. Every sentence of description below is an original paraphrase, not College Board's text. Only the AP-assigned codes are reproduced as-is. Scope. This copy shows only what Working in Python carries.

Computational Thinking Practices

Code	Name	MCQ weight
#P1	Computational Solution Design	18–25%
#P2	Algorithms and Program Development	20–28%
#P3	Abstraction in Program Development	7–12%
#P4	Code Analysis	12–19%
#P5	Computing Innovations	28–33%
#P6	Responsible Computing	Create PT only (not on MCQ)

#CRD Big Idea 1: Creative Development (10–13% MCQ)

#1.1 Collaboration

Working with other people, and giving them credit, changes how a computing project turns out.

#CRD-1.A Explain how collaborating with others makes a computing innovation better than one person could make alone.

#CRD-1.A.1 A computing innovation always has software running as a core piece of what it does.
#CRD-1.A.2 A computing innovation might be a physical device, a piece of software, or just an idea about how computing gets used -- it doesn't have to be a physical thing.
#CRD-1.A.3 When the people building something bring different backgrounds and skills to the table, the result usually reflects that range of perspectives.
#CRD-1.A.4 Bringing in people with different viewpoints is one way to keep bias from creeping into a computing innovation.
#CRD-1.A.5 Talking with and listening to the people who will use a computing innovation is a key part of building it well.
#CRD-1.A.6 Feedback from potential users helps developers see a program's purpose from more than one angle and shape it around what those users actually need.

#CRD-1.B Explain how a team, not just one person, is often behind a given computing innovation.

#CRD-1.B.1 Web-based tools let programmers share work and comment on each other's ideas and files even when they aren't in the same room.
#CRD-1.B.2 Pair programming is one common pattern teams use for working together on code.

#CRD-1.C Show good interpersonal habits when working with a team.

#CRD-1.C.1 Teams that collaborate well tend to practice skills such as clear communication, reaching agreement as a group, resolving disagreements, and negotiating.

#1.2 Program Function and Purpose

A program exists to do something for someone, and describing what it does means naming its inputs, its outputs, and the behavior that connects them.

Covered in Chapter 1 (Welcome), Chapter 5 (Conditionals and Recursion)

Chapter 1 frames programs generally; Chapter 5's 'Keyboard input' section is the book's only real input-handling content. The CED's event-driven-programming framing (CRD-2.C.5, CRD-2.C.6) has no counterpart -- this book's programs are run-to-completion scripts, not event loops.

#CRD-2.A Describe what a given computing innovation is meant to accomplish.

#CRD-2.A.1 Computing innovations exist either to solve a problem or to let someone express a creative interest.
#CRD-2.A.2 Knowing why a computing innovation exists makes it easier for developers to actually build it.

#CRD-2.B Explain what a program or a piece of it actually does when it runs.

#CRD-2.B.1 A program -- also called software -- is a set of statements that carries out a specific job when a computer runs it.
#CRD-2.B.2 A code segment is just part of a program: a smaller group of statements within the larger whole.
#CRD-2.B.3 A program has to keep working correctly across a range of different inputs and circumstances, not just one case.
#CRD-2.B.4 A program's behavior is what it does while running, usually described in terms of how someone interacts with it.
#CRD-2.B.5 You can describe a program at a high level -- just what it accomplishes -- or in more detail, including how the code produces that result.

#CRD-2.C Recognize what counts as input to a given program.

#CRD-2.C.1 Inputs are data fed into a computer for a program to work with, and they can take forms like touch, sound, images, or text.
#CRD-2.C.2 An event ties an action to input data that gets passed along to a program.
#CRD-2.C.3 Pressing a key, clicking a mouse, launching a program, or any other defined action can trigger an event that changes the program's flow.
#CRD-2.C.4 What a program outputs is typically shaped by the input it receives.
#CRD-2.C.5 Event-driven programs run their statements in response to triggers, not strictly in a fixed top-to-bottom order.
#CRD-2.C.6 Input isn't limited to a human user -- it can also come from another program.

#CRD-2.D Recognize what counts as output from a given program.

#CRD-2.D.1 Outputs are data a program sends out to some device, and like inputs, they can be tactile, audio, visual, or text.
#CRD-2.D.2 What a program outputs usually depends on its input, or on values it has stored internally from before.

#1.3 Program Design and Development

Building a program well means planning before writing, documenting while writing, and being willing to revise.

Covered in Chapter 4 (Functions and Interfaces)

Chapter 4's 'A development plan' and 'Docstrings' sections are a direct match for CRD-2.E/F/G. CRD-2.H (acknowledging code taken from another source) has no counterpart anywhere in the book -- a real gap, not just a light topic.

#CRD-2.E Build a program by following some kind of development process.

#CRD-2.E.1 A development process can be planned out step by step, or it can be more open-ended and exploratory.
#CRD-2.E.2 Several development processes exist, but they tend to share common phases: investigating and reflecting, designing, prototyping, and testing.
#CRD-2.E.3 An iterative process means going back and revising earlier work based on feedback, test results, or reflection, sometimes more than once.
#CRD-2.E.4 An incremental process means splitting a problem into smaller pieces and confirming each piece works before folding it into the whole program.

#CRD-2.F Design both a program and how a user will interact with it.

#CRD-2.F.1 Designing a program starts with investigating what it actually needs to do.
#CRD-2.F.2 That investigation helps clarify the constraints on the program along with the needs and interests of the people who'll use it.
#CRD-2.F.3 Investigation can take forms like surveys, testing with users, interviews, or just watching people directly.
#CRD-2.F.4 A program's requirements spell out how it should function, which can include how users are expected to interact with it.
#CRD-2.F.5 A specification is the document that lays out a program's requirements.
#CRD-2.F.6 The design phase of development is where you figure out how to meet a given specification.
#CRD-2.F.7 Design work can include brainstorming, sketching out plans and storyboards, breaking the program into modules and components, drawing diagrams of the interface layout, and planning how the program will be tested.

#CRD-2.G Write documentation that explains what a code segment or program is for.

#CRD-2.G.1 Documentation is written text that explains what a code segment, event, procedure, or program does and how it came to be built that way.
#CRD-2.G.2 Comments are documentation embedded in the code for human readers; they have no effect on how the program actually runs.
#CRD-2.G.3 Documentation should be written all along the way a program is developed, not just at the end.
#CRD-2.G.4 Good documentation makes it easier to build and maintain correct programs, whether you're working alone or with a team.
#CRD-2.G.5 Some programming environments don't support comments at all, so documentation has to happen some other way.

#CRD-2.H Give credit for code segments that came from somewhere else.

#CRD-2.H.1 Any code segment built by a group or borrowed from another source deserves acknowledgment.
#CRD-2.H.2 That acknowledgment usually lives in the program's documentation and should name where the code came from or who wrote it.

#1.4 Identifying and Correcting Errors

Programs fail in a few recognizable ways, and testing with well-chosen inputs -- including edge cases -- is how those failures get found before a user does.

Covered in Chapter 1 (Welcome), Chapter 2 (Variables and Statements), Chapter 3 (Functions), Chapter 4 (Functions and Interfaces), Chapter 5 (Conditionals and Recursion), Chapter 6 (Return Values), Chapter 7 (Iteration and Search), Chapter 8 (Strings and Regular Expressions), Chapter 9 (Lists), Chapter 10 (Dictionaries), Chapter 11 (Tuples), Chapter 12 (Text Analysis and Generation), Chapter 13 (Files and Databases)

Every chapter in the book carries a 'Debugging' section, confirmed by header scan. That is the strongest and most consistent alignment of any Big Idea 1 topic; Chapter 7's doctest material additionally matches CRD-2.J's testing-with-defined-inputs framing well.

#CRD-2.I Find and fix a mistake in an algorithm or program.

#CRD-2.I.1 A logic error is a flaw in the algorithm's or program's reasoning that makes it behave wrong even though it runs.
#CRD-2.I.2 A syntax error happens when code breaks the grammar rules of the programming language.
#CRD-2.I.3 A run-time error shows up while the program is actually executing, and different languages define their own kinds of these.
#CRD-2.I.4 An overflow error happens when a computer tries to store or handle a number bigger, or smaller, than its allowed range.
#CRD-2.I.5 Good ways to track down and fix errors include using test cases, tracing through code by hand, using visualizations, using a debugger, or adding extra output to see what's happening.

#CRD-2.J Pick inputs and matching expected outputs to verify that an algorithm or program works correctly.

#CRD-2.J.1 Testing means running a program on chosen inputs and checking whether it produces the outcomes you expect, then using what you learn to fix the algorithm or program.
#CRD-2.J.2 Good test inputs should include cases right at or just past the smallest and largest values a program is expected to handle.
#CRD-2.J.3 You need to know a program's requirements before you can choose test inputs that make sense.

#DAT Big Idea 2: Data (17–22% MCQ)

#2.1 Binary Numbers

Computers store everything as bits, and binary place-value works the same way decimal place-value does, just base 2 instead of base 10.

Covered in Interlude B (Representing Data, outline only)

Carried by the interlude between chapters 7 and 8 ('Representing Data', Interlude B): bits, place value, binary/decimal/hex conversion by hand and via bin()/int(s, 2)/format(). As of 2026-08-17 Interlude B exists only as an outline (section headings, vocabulary, standards claims) -- no drafted prose or exercises yet; see CHAPTER_MANIFEST.md's Interludes section and AUDIT.md's 2026-08-17 handoff. Previously logged as carried by CS50T Multimedia; that supplement was dropped after year one and never taught again, so the assignment was stale -- removed 2026-08-09 per teacher confirmation. The Pico/MicroPython unit's I2C chapter (source/rpi-pico-2e ch.14, 'Digital communication protocols') remains a secondary, partial touchpoint (hexadecimal as byte notation) alongside Interlude B's fuller treatment.

Out of scope: specific range limitations for real numbers are outside course/exam scope (EK DAT-1.B.3)

#DAT-1.A Show how information gets encoded as sequences of bits.

#DAT-1.A.1 A data value can live in a variable, sit inside a list, stand alone as a constant, or move into and out of a function as an argument or return value.
#DAT-1.A.2 Every piece of data a computer works with ultimately breaks down into bits at the hardware level.
#DAT-1.A.3 A bit is just a binary digit, one of two possible values, 0 or 1.
#DAT-1.A.4 Eight bits grouped together make one byte.
#DAT-1.A.5 Abstraction means stripping away details that don't matter right now so the important idea stands out on its own.
#DAT-1.A.6 Combining bits in different patterns lets them stand for higher-level things like numbers, letters, or colors.
#DAT-1.A.7 An identical string of bits can mean completely different things depending on how a program interprets it.
#DAT-1.A.8 Analog data vary continuously rather than in fixed steps -- think of a runner's position over a race or the volume of a song rising and falling.
#DAT-1.A.9 Turning a continuous, real-world signal into digital data is itself a form of abstraction.
#DAT-1.A.10 Sampling captures an analog signal by measuring it at evenly spaced moments in time, and each of those measurements gets converted into stored bits.

#DAT-1.B Describe what can go wrong when a fixed number of bits is used to hold a value.

#DAT-1.B.1 When a language stores integers in a fixed number of bits, there's a ceiling on how large or small those numbers can get, and exceeding it can cause overflow or similar errors.
#DAT-1.B.2 Some languages sidestep that limit by letting integers grow as large as available memory allows, which is true of the pseudocode language used on the exam.
#DAT-1.B.3 Real numbers face a similar bit-width limit, which can produce rounding errors, since many real numbers can only be stored as approximations.

#DAT-1.C Convert positive integers between base 10 and base 2, and put binary numbers in order.

#DAT-1.C.1 Data can be written out in different number bases, binary and decimal among them.
#DAT-1.C.2 Base 2 has only two digits to work with, 0 and 1.
#DAT-1.C.3 Base 10 uses ten digits, 0 through 9.
#DAT-1.C.4 Just like in decimal, where a binary digit sits determines what it's worth -- multiply the digit by the value of its place.
#DAT-1.C.5 Each position's place value is the base raised to that position's power, counting positions from 0 at the rightmost digit and increasing going left.

#2.2 Data Compression

Compression trades off file size against fidelity; lossless keeps everything, lossy throws some of it away for a bigger size reduction.

Covered in Interlude B (Representing Data, outline only)

Carried by the interlude between chapters 7 and 8 ('Representing Data', Interlude B): the lossless/lossy contrast, taught as the choice the exam actually tests rather than as definitions, plus student-written run-length encoding as the lossless worked example. As of 2026-08-17 Interlude B exists only as an outline -- no drafted prose or exercises yet; see CHAPTER_MANIFEST.md's Interludes section and AUDIT.md's 2026-08-17 handoff. Previously logged as carried by CS50T Multimedia; removed 2026-08-09 per teacher confirmation that supplement hasn't been taught since year one. The Pico I2C chapter (see 2.1's note) still doesn't touch compression at all.

#DAT-1.D Weigh different compression algorithms against each other to pick the right one for a given situation.

#DAT-1.D.1 Compressing data shrinks the number of bits needed to store or send it.
#DAT-1.D.2 A smaller bit count doesn't automatically mean the data carries less information.
#DAT-1.D.3 How much compression shrinks a file depends on both how much repetition was in the original data and which algorithm is used.
#DAT-1.D.4 Lossless compression cuts down the bit count while still allowing the original data to be rebuilt exactly.
#DAT-1.D.5 Lossy compression can shrink data much further, but what comes back out is only close to the original, not identical.
#DAT-1.D.6 Because lossy methods don't have to preserve every detail, they typically achieve smaller sizes than lossless methods.
#DAT-1.D.7 When getting back the exact original matters most, lossless compression is the right choice.
#DAT-1.D.8 When shrinking size or speeding up transmission matters most, lossy compression is typically preferred.

#2.3 Extracting Information from Data

Raw data becomes information once a program finds the patterns in it, and real data sets are rarely clean enough to do that without some processing first.

Covered in Chapter 12 (Text Analysis and Generation), Chapter 13 (Files and Databases)

Chapter 12 (word frequencies, Markov analysis) and Chapter 13 (file/database work) are a strong match. Metadata specifically (DAT-2.B) has no direct counterpart.

#DAT-2.A Explain what kinds of information a person can pull out of a data set.

#DAT-2.A.1 Information is what you get once facts and patterns have been pulled out of raw data.
#DAT-2.A.2 Data can reveal trends, expose connections, and point toward solutions to problems.
#DAT-2.A.3 Processing data can turn up a correlation between two variables, but correlation alone doesn't prove one causes the other -- that takes further investigation.
#DAT-2.A.4 One data source is often not enough to support a conclusion, so multiple sources may need to be combined.

#DAT-2.B Explain what can be learned from metadata rather than the data itself.

#DAT-2.B.1 Metadata describes data -- for a photo, that might mean when it was taken or how large the file is, rather than the picture itself.
#DAT-2.B.2 Editing or removing metadata leaves the underlying data untouched.
#DAT-2.B.3 Metadata helps people locate, sort, and keep track of information.
#DAT-2.B.4 Extra context from metadata can make a data set more useful.
#DAT-2.B.5 Metadata gives data a structure it can be organized around.

#DAT-2.C Recognize the obstacles that come up when working with data.

#DAT-2.C.1 What can be done with data is limited by the skills of the people involved and the tools available to them.
#DAT-2.C.2 Data sets, big or small, come with recurring headaches: missing entries, bad values, needing cleanup, or needing to be merged with other sources.
#DAT-2.C.3 Data collected from free-text entry tends to come out inconsistent, since different people abbreviate, spell, and capitalize things differently.
#DAT-2.C.4 Cleaning data standardizes it -- swapping equivalent spellings or abbreviations for one consistent form -- without changing what it means.
#DAT-2.C.5 Bias frequently comes from what kind of data gets collected or where it comes from, and piling on more data of the same kind won't fix it.
#DAT-2.C.6 How much can be learned from a data set is tied to its size.
#DAT-2.C.7 A single machine may struggle to process very large data sets, which is where parallel computing comes in.
#DAT-2.C.8 A system's ability to scale matters, since its computing capacity shapes what data can be stored and processed.

#2.4 Using Programs with Data

Programs that read, combine, and rewrite data files let a person do with a data set what would be impractical by hand.

Covered in Chapter 12 (Text Analysis and Generation), Chapter 13 (Files and Databases)

Chapter 13's file, YAML, and shelve work carries this directly.

#DAT-2.D Use a program as the tool for pulling information out of data.

#DAT-2.D.1 Running data through a program is one way to turn it into information.
#DAT-2.D.2 Insights drawn from data can be communicated through tables, diagrams, written explanations, and other visual formats.
#DAT-2.D.3 Search tools make locating specific information much faster.
#DAT-2.D.4 Filtering tools help surface relevant information and spot patterns within a data set.
#DAT-2.D.5 Spreadsheet-style programs make it easier to organize data and notice trends in it.
#DAT-2.D.6 Common data operations include applying a change to every item in a set, keeping only items that meet some condition, combining or comparing values across a set, and turning a data set into a chart or graph.

#DAT-2.E Describe how running data through programs generates insight and knowledge.

#DAT-2.E.1 Getting insight from data is often a back-and-forth process, where a program gets run repeatedly and adjusted along the way.
#DAT-2.E.2 Writing programs to filter and clean up messy data is itself a way of gaining understanding from it.
#DAT-2.E.3 Merging separate data sources, grouping similar items, and sorting data into categories are all techniques programs use to extract meaning.
#DAT-2.E.4 Converting or reshaping digital information into a different form can itself reveal new understanding.
#DAT-2.E.5 Running data through a transformation can bring hidden patterns to the surface.

#AAP Big Idea 3: Algorithms and Programming (30–35% MCQ)

#3.1 Variables and Assignments

A variable is a named place to keep a value, and assignment is how that name gets pointed at a value.

Covered in Chapter 2 (Variables and Statements)

#AAP-1.A Store a value in a variable so a program can refer to it by name.

#AAP-1.A.1 A variable acts like a labeled container in a program; at any given moment it holds one value, though that value itself might be a list or other structure bundling several values together.
#AAP-1.A.2 Picking clear, descriptive variable names makes code easier to read and makes it obvious what each name is standing in for.
#AAP-1.A.3 Many languages sort data into types -- numbers, Booleans, lists, strings, and so on -- and a variable references data of some particular type.
#AAP-1.A.4 Certain values fit one data type more naturally than another.

#AAP-1.B Figure out what a variable holds after an assignment statement runs.

#AAP-1.B.1 Assignment is the mechanism a program uses to change what value a variable is currently holding.
#AAP-1.B.2 The reference sheet's assignment arrow works by first evaluating the expression on the right, then storing a copy of that result in the variable named on the left.
#AAP-1.B.3 A variable always reflects only its most recent assignment; for instance, if b is set equal to a and a is changed afterward, b keeps the old value it copied, not the new one.

#3.2 Data Abstraction

Grouping related values under one name lets a program treat a collection as a single thing instead of tracking each part separately.

Covered in Chapter 9 (Lists), Chapter 10 (Dictionaries), Chapter 11 (Tuples)

Lists (Chapter 9), dictionaries (Chapter 10), and tuples (Chapter 11) are all worked examples of this LO. The linked-list exclusion is moot here -- the book never implements one.

Out of scope: linked lists are outside course/exam scope (EK AAP-1.D.6)

#AAP-1.C Use a variable to hold an entire list or string of values.

#AAP-1.C.1 A list is simply an ordered run of elements, written out as comma-separated values inside brackets.
#AAP-1.C.2 Each individual value inside a list is called an element, and every element has its own index.
#AAP-1.C.3 Indexing -- numbering positions with natural numbers -- is the usual way to point at a particular spot in a list or string.
#AAP-1.C.4 A string is likewise just an ordered run, but of characters rather than arbitrary elements.

#AAP-1.D Build a data abstraction out of a list, and explain how that abstraction keeps a program simpler.

#AAP-1.D.1 Data abstraction draws a line between what a data type looks like from the outside and how it is actually built underneath.
#AAP-1.D.2 By giving a whole collection of data one name, a data abstraction hides the underlying representation and keeps the program easier to reason about.
#AAP-1.D.3 Lists are the tool this course uses to build data abstractions.
#AAP-1.D.4 Programs built around a good data abstraction tend to be simpler to write and maintain going forward.
#AAP-1.D.5 A single data abstraction can hold elements of more than one type at once.
#AAP-1.D.6 Bundling several related values into one list lets a program treat them as though they were a single item; some languages call this same structure an array instead.
#AAP-1.D.7 The reference sheet's list notation covers writing out a list of values directly, writing empty brackets to start with nothing, and assigning one variable's list contents to another, which copies the values rather than linking them.
#AAP-1.D.8 On the reference sheet, list indices start at 1 and run through the list's length; asking for an index outside that range is an error that stops the program.

#3.3 Mathematical Expressions

Arithmetic and comparison operators combine into expressions the same way in code as they do on paper, with the same rules about order of operations.

Covered in Chapter 1 (Welcome), Chapter 2 (Variables and Statements)

#AAP-2.A Describe an algorithm that runs its steps in order, without writing it in any particular programming language.

#AAP-2.A.1 An algorithm is just a finite recipe of steps aimed at one specific task.
#AAP-2.A.2 Algorithms don't have to be written in a programming language at all -- plain language, diagrams, and pseudocode all work.
#AAP-2.A.3 To actually run on a computer, an algorithm eventually gets translated into some programming language.
#AAP-2.A.4 Sequencing, selection, and iteration are the only building blocks needed to construct any algorithm.

#AAP-2.B Turn a step-by-step algorithm into a sequence of code statements.

#AAP-2.B.1 Sequencing just means running each instruction in the order it was written.
#AAP-2.B.2 A statement is one piece of code that carries out a single action.
#AAP-2.B.3 An expression can be built from a plain value, a variable, an operator, or a call to a procedure that hands back a value.
#AAP-2.B.4 Evaluating any expression collapses it down to exactly one resulting value.
#AAP-2.B.5 Order-of-operations rules, set by the language, govern the sequence in which expressions get evaluated.
#AAP-2.B.6 Statements written in sequence run in the order they appear, top to bottom.
#AAP-2.B.7 Writing an algorithm clearly and readably matters, not just writing one that works.

#AAP-2.C Work out what an expression using arithmetic operators evaluates to.

#AAP-2.C.1 The common arithmetic operators -- add, subtract, multiply, divide, and modulus -- show up in nearly every language.
#AAP-2.C.2 The reference sheet's MOD operator gives the remainder of dividing one non-negative integer by a positive one; 17 MOD 5, for example, comes out to 2.
#AAP-2.C.3 The reference sheet lists +, -, *, /, and MOD as the operators for doing arithmetic on two values -- for instance, 17 / 5 comes out to 3.4.
#AAP-2.C.4 Standard math order-of-operations rules apply, and MOD is treated with the same precedence as multiplication and division.

#3.4 Strings

Text is data too, and a string is handled as a sequence of characters that can be measured, sliced, and searched.

Covered in Chapter 1 (Welcome), Chapter 8 (Strings and Regular Expressions)

#AAP-2.D Work out what an expression that manipulates strings evaluates to.

#AAP-2.D.1 Concatenation is just gluing two or more strings together, end to end, into one new string.
#AAP-2.D.2 A substring is any piece cut out of a larger, existing string.

#AAP-2.E Write and evaluate expressions that compare two variables, expressions, or values with relational operators.

#AAP-2.E.1 A Boolean is a value that can only ever be true or false.
#AAP-2.E.2 The reference sheet's relational operators -- equals, not-equals, greater-than, less-than, greater-or-equal, less-or-equal -- compare two things and always produce a Boolean; two equal values compared with equals, for example, come out true.

#3.5 Boolean Expressions

An expression that evaluates to true or false is what a program's decisions are built on.

Covered in Chapter 5 (Conditionals and Recursion)

#AAP-2.F Write and evaluate expressions that combine Boolean values with logical operators.

#AAP-2.F.1 The reference sheet's logical operators -- NOT, AND, OR -- each take Boolean input and produce a Boolean result.
#AAP-2.F.2 NOT flips a condition: the result is true exactly when the condition is false, and false when the condition is true.
#AAP-2.F.3 AND requires both of its two conditions to be true for the whole expression to come out true.
#AAP-2.F.4 OR requires just one of its two conditions, or both, to be true for the whole expression to come out true.
#AAP-2.F.5 Logical operators work on operands that can themselves be a whole Boolean expression or just one bare Boolean value.

#3.6 Conditionals

An if-statement lets a program take one path or another depending on whether a condition holds.

Covered in Chapter 5 (Conditionals and Recursion)

#AAP-2.G Describe an algorithm that branches based on a condition, without writing it in a programming language.

#AAP-2.G.1 Selection is what decides, based on whether a condition is true or false, which part of an algorithm actually runs.

#AAP-2.H Write conditional statements and figure out what they do.

#AAP-2.H.1 An if-statement changes the normal top-to-bottom flow of a program by choosing which statements run based on a Boolean condition.
#AAP-2.H.2 The reference sheet's plain IF form runs its block only when the condition is true, and does nothing at all when the condition is false.
#AAP-2.H.3 The reference sheet's IF/ELSE form runs one block when the condition is true and a different block when it is false, so one branch or the other always executes.

#3.7 Nested Conditionals

Putting one conditional inside another lets a program handle more than two possible outcomes.

Covered in Chapter 5 (Conditionals and Recursion)

#AAP-2.I Write nested conditional statements and figure out what they do.

#AAP-2.I.1 Nesting a conditional means putting one if-statement inside the body of another.

#3.8 Iteration

Repeating a block of statements, either a fixed number of times or until some condition changes, is how a program does the same kind of work over and over.

Covered in Chapter 3 (Functions), Chapter 7 (Iteration and Search)

IMPORTANT COVERAGE GAP, not a light-topic judgment call: the exam reference sheet gives this topic two pseudocode forms -- REPEAT n TIMES (definite, matches Python's `for`) and REPEAT UNTIL(condition) (indefinite/condition-controlled, matches Python's `while`). This edition of the book has no `while` loop anywhere -- confirmed by scanning every code cell in chapters 1-13, zero hits outside prose mentions of the English word 'while'. Indefinite iteration is instead handled through recursion (Chapter 5, Chapter 6), which is a real substitute conceptually but is not the same pseudocode construct on the exam, and does not produce the REPEAT UNTIL-specific edge cases the CED calls out (AAP-2.K.4 infinite loop from a condition that never becomes true; AAP-2.K.5 zero-iteration when the condition is already true) since Python's recursion has no direct exam-reference-sheet form of its own. Whether this is closed with a short while-loop supplement or left as recursion-covers-it-in-spirit is a real pedagogical call, not something to resolve while indexing the standard.

#AAP-2.J Describe an algorithm that repeats steps, without writing it in a programming language.

#AAP-2.J.1 Iteration is the part of an algorithm that runs again and again, either a set number of times or until some condition is satisfied.

#AAP-2.K Write iteration statements and figure out what they produce or do.

#AAP-2.K.1 An iteration statement breaks the normal top-to-bottom flow by running a set of statements over and over, possibly zero times, until some stopping condition is reached.
#AAP-2.K.2 The reference sheet's REPEAT n TIMES form runs its block a fixed number of times, n.
#AAP-2.K.3 The reference sheet's REPEAT UNTIL(condition) form keeps running its block, checking the condition before each pass, until that condition finally comes out true.
#AAP-2.K.4 A REPEAT UNTIL loop runs forever if its ending condition can never become true.
#AAP-2.K.5 Because REPEAT UNTIL checks its condition before running the block, the loop body can end up never executing at all if the condition already holds on the first check.

#3.9 Developing Algorithms

Building an algorithm from scratch usually means starting with a rough version and refining it in small, testable steps.

Covered in Chapter 6 (Return Values), Chapter 7 (Iteration and Search)

Chapter 6's 'Incremental development' section is a direct match; Chapter 7 builds a linear-search function the same way.

#AAP-2.L Compare two or more algorithms to see whether they actually produce the same outcome.

#AAP-2.L.1 Different-looking algorithms can still accomplish the exact same task.
#AAP-2.L.2 Conversely, algorithms that look almost identical can still produce different results or side effects.
#AAP-2.L.3 Certain conditional statements have an equivalent Boolean expression that does the same job.
#AAP-2.L.4 The reverse also holds: certain Boolean expressions have an equivalent conditional statement.
#AAP-2.L.5 More than one algorithm can be written to solve the very same problem.

#AAP-2.M Build new algorithms, including by combining or adapting ones that already exist.

#AAP-2.M.1 A new algorithm can start from scratch, or be built by combining or tweaking algorithms that already exist.
#AAP-2.M.2 Familiar algorithms, like finding the max or min of some numbers, computing a sum or average, checking whether one integer divides another evenly, or routing a robot through a maze, are useful raw material for building something new.
#AAP-2.M.3 Reusing already-correct algorithms as building blocks saves development time, cuts down on testing, and makes it easier to track down errors.

#3.10 Lists

A list holds an ordered sequence of values that a program can step through one at a time.

Covered in Chapter 9 (Lists)

Out of scope: traversing two lists at once with a shared index (parallel traversal) is outside course/exam scope (EK AAP-2.O.1)

#AAP-2.N A student should be able to write and evaluate expressions that read or change list elements using indexing and the standard list procedures.

#AAP-2.N.1 The reference sheet defines the core list operations: read an element by its index (the first element is index 1), copy an element into a variable, store a value into an element, copy one element's value into another, insert a value at a given index (shifting later values right and growing the list by one), append a value at the end, remove a value at a given index (shifting later values left and shrinking the list by one), and find the current length of a list.
#AAP-2.N.2 Any list procedure has to follow the syntax rules of whatever language it's written in.

#AAP-2.O A student should be able to write loops that step through a list and figure out what an algorithm that walks a list produces.

#AAP-2.O.1 Walking through a list can touch every element, or it can stop after covering just some of them.
#AAP-2.O.2 A loop is the tool used to move across a list's elements.
#AAP-2.O.3 The reference sheet's FOR EACH item IN aList construct runs its block once for every element of aList, setting item to each value in turn from first to last.
#AAP-2.O.4 Recognizing common loop-based patterns, such as finding the largest or smallest value, or totaling or averaging a list of numbers, gives you building blocks for writing new algorithms.
#AAP-2.O.5 Linear (or sequential) search steps through a list one element at a time until it finds the target or runs out of elements.

#3.11 Binary Search

Searching a sorted collection by repeatedly cutting the remaining range in half finds a value in far fewer steps than checking every element.

Out of scope: specific implementations of the binary search algorithm are outside course/exam scope (EK AAP-2.P.1)

#AAP-2.P A student should be able to work out how many steps a binary search takes and explain what conditions binary search needs to work.

#AAP-2.P.1 Binary search checks the middle of a sorted list and throws away the half that can't contain the target, repeating that halving until the value turns up or nothing is left to check.
#AAP-2.P.2 Binary search only works if the data is already sorted.
#AAP-2.P.3 On sorted data, binary search usually beats linear search for speed.

#3.12 Calling Procedures

Calling a function hands control to a separate block of code and, often, gets a value back in return.

Covered in Chapter 3 (Functions), Chapter 6 (Return Values)

#AAP-3.A A student should be able to write a call to a procedure and predict what that call does or returns.

#AAP-3.A.1 A procedure is a named chunk of code that can accept parameters and hand back a result.
#AAP-3.A.2 Different languages use different words, like function or method, for the same idea of a procedure.
#AAP-3.A.3 Parameters are the variables a procedure expects as input; arguments are the actual values supplied for those parameters at the call site.
#AAP-3.A.4 Calling a procedure pauses the caller, runs the procedure's own statements, and then hands control back to right after the call once the procedure finishes or hits a return.
#AAP-3.A.5 The reference sheet's procName(arg1, arg2, ...) notation calls a procedure and matches each argument to the corresponding parameter in order.
#AAP-3.A.6 The reference sheet's DISPLAY(expression) prints the value of expression and adds a trailing space.
#AAP-3.A.7 The reference sheet's RETURN(expression) statement sends control back to the caller and passes along the value of expression.
#AAP-3.A.8 Writing result <- procName(arg1, arg2, ...) on the reference sheet stores whatever the procedure returns into result.
#AAP-3.A.9 The reference sheet's INPUT() procedure reads a value typed by the user and gives it back as its result.

#3.13 Developing Procedures

Writing a function well means giving it parameters general enough to be reused, and a name and docstring that explain what it does without exposing how.

Covered in Chapter 3 (Functions), Chapter 4 (Functions and Interfaces)

#AAP-3.B A student should be able to explain how wrapping code in procedures keeps a program manageable.

#AAP-3.B.1 Procedural abstraction is naming a process so that it can be used just by knowing what it does, without needing to know how it's built inside.
#AAP-3.B.2 A big problem's solution can be assembled from procedures that each solve one smaller piece of it.
#AAP-3.B.3 Modularity is the practice of splitting a program into separate, smaller subprograms.
#AAP-3.B.4 Instead of copying code around, a procedure can pull out the shared behavior into one general version, which cuts down on repetition and complexity.
#AAP-3.B.5 Parameters let one procedure serve many different inputs instead of needing a separate version for each case.
#AAP-3.B.6 Breaking code into procedures also makes it easier to read.
#AAP-3.B.7 Because callers only depend on what a procedure does, its inner workings can be rewritten, say to run faster or use less memory, without warning anyone, as long as its outward behavior doesn't change.

#AAP-3.C A student should be able to write their own procedures as a way of managing a program's complexity.

#AAP-3.C.1 The reference sheet's PROCEDURE procName(parameter1, parameter2, ...) { block } form defines a procedure, with any number of parameters, that runs the given block when called.
#AAP-3.C.2 Adding a RETURN(expression) inside that same procedure form makes it hand back a value, with RETURN able to fire at any point in the block and immediately hand control back to the caller.

#3.14 Libraries

Importing a library brings in code someone else already wrote and tested, so a program can use it without reimplementing it.

Covered in Chapter 2 (Variables and Statements), Chapter 4 (Functions and Interfaces), Chapter 8 (Strings and Regular Expressions)

Chapter 2 introduces `import`; Chapter 4 (jupyturtle) and Chapter 8 (`re`) are the book's main worked examples of using an imported library.

#AAP-3.D A student should be able to pick a suitable library or piece of existing code when building a new program.

#AAP-3.D.1 A library bundles up procedures that other programs can call on.
#AAP-3.D.2 Code you reuse can come from inside your own project or from an outside source such as a library.
#AAP-3.D.3 Relying on libraries makes it easier to build a complicated program.
#AAP-3.D.4 An API describes how a library's procedures are meant to behave and be called.
#AAP-3.D.5 You need a library's or API's documentation to know what it offers and how to use it correctly.

#3.15 Random Values

A program can introduce controlled unpredictability by drawing values from a random-number generator instead of computing them.

Covered in Chapter 12 (Text Analysis and Generation)

#AAP-3.E A student should be able to write expressions that produce random values and reason about what those expressions might return.

#AAP-3.E.1 The reference sheet's RANDOM(a, b) returns a random whole number between a and b, inclusive, with every value in that range equally likely.
#AAP-3.E.2 Because a program calls a random number generator, running it more than once can give different outcomes each time.

#3.16 Simulations

A simulation stands in for a real process that would be too slow, risky, or expensive to run for real, trading some realism for repeatability.

#AAP-3.F A student should be able to explain how a computer can stand in for something in the real world, and weigh a simulation against the real thing it models.

#AAP-3.F.1 A simulation is a simplified stand-in for a more complicated real object or process, built for one particular purpose.
#AAP-3.F.2 A simulation tracks a changing situation by updating a set of values that represent its current state.
#AAP-3.F.3 Simulations copy real events so people can study them and draw conclusions without the limits the real world imposes.
#AAP-3.F.4 Turning something real into a simulation means leaving out details or simplifying how it behaves.
#AAP-3.F.5 Whatever real-world elements a simulation's designer chooses to include or leave out can bias the result.
#AAP-3.F.6 Simulations earn their keep when the real version would be impractical to run, for instance because it's too big, too small, too fast, too slow, too costly, or too dangerous.
#AAP-3.F.7 Running simulations helps people form hypotheses about a phenomenon and then sharpen them.
#AAP-3.F.8 A simulation can use a random number generator to mimic the unpredictability found in the real world.

#3.17 Algorithmic Efficiency

Algorithms that solve the same problem are not equally fast, and how an algorithm's running time grows with input size is what separates a practical solution from an impractical one.

Out of scope: formal/mathematical (Big-O) analysis of algorithms is outside course/exam scope (EK AAP-4.A.3)

Out of scope: specific heuristic solutions are outside course/exam scope (EK AAP-4.A.9)

#AAP-4.A A student should be able to distinguish algorithms that finish in a reasonable amount of time from those that don't, and recognize when a heuristic makes more sense than an exact solution.

#AAP-4.A.1 A problem describes a task in general terms, while an instance of that problem pins down specific input, so sorting is the problem but sorting the list (2, 3, 1, 7) is one instance of it.
#AAP-4.A.2 A decision problem just wants a yes or no answer, while an optimization problem asks you to find the best solution out of many candidates.
#AAP-4.A.3 Efficiency measures roughly how much computing power an algorithm needs, usually described in terms of how the input size affects it.
#AAP-4.A.4 Figuring out an algorithm's efficiency relies on formal or mathematical reasoning.
#AAP-4.A.5 One informal way to gauge efficiency is to count how many times a given statement or set of statements actually runs.
#AAP-4.A.6 Two algorithms that both correctly solve the same problem can still differ in efficiency.
#AAP-4.A.7 An algorithm counts as running in reasonable time if its growth is polynomial or slower (constant, linear, squared, cubed, and so on), while exponential or factorial growth counts as unreasonable.
#AAP-4.A.8 When a problem has no efficient algorithm, an exact answer in reasonable time isn't possible, so people settle for an approximate one instead.
#AAP-4.A.9 A heuristic gives up the guarantee of the best possible answer in exchange for being practical, useful when methods guaranteed to find the optimal solution would take too long.

#3.18 Undecidable Problems

Some yes-or-no problems have no algorithm that can always answer correctly, no matter how much time is allowed.

Out of scope: determining whether a given problem is undecidable is outside course/exam scope (EK AAP-4.B.2)

#AAP-4.B A student should be able to explain why some problems in computer science can't be decided algorithmically at all.

#AAP-4.B.1 A decidable problem is a yes/no problem that some algorithm can always answer correctly, like asking whether a given number is even.
#AAP-4.B.2 An undecidable problem is a yes/no problem that no algorithm can be built to always answer correctly.
#AAP-4.B.3 Even a problem that's undecidable overall might still have particular cases that some algorithm can solve, just not every case.

#CSN Big Idea 4: Computer Systems and Networks (11–15% MCQ)

#4.1 The Internet

The internet moves data between computers by breaking it into pieces and routing each piece independently through a shared network of devices.

#CSN-1.A Describe how networked devices cooperate to move data from one point to another.

#CSN-1.A.1 Any physical device capable of running software counts as a computing device -- laptops, phones, servers, routers, and embedded sensors are all examples.
#CSN-1.A.2 When several computing devices and pieces of software work together toward one goal, that combination is called a computing system.
#CSN-1.A.3 A computer network is simply a set of computing devices linked together so they can exchange data.
#CSN-1.A.4 Because it is made of connected devices working toward a purpose, a network itself counts as a kind of computing system.
#CSN-1.A.5 A path is the unbroken chain of directly linked devices that data travels along to get from a sender to a receiver.
#CSN-1.A.6 Figuring out which path data should take from source to destination is what routing means.
#CSN-1.A.7 A network's bandwidth caps how much data can move through it within a set period of time.
#CSN-1.A.8 Bandwidth is typically expressed as a rate, in bits per second.

#CSN-1.B Describe the properties that let the Internet function as a single, connected network.

#CSN-1.B.1 The Internet is really a network of networks, held together by shared, publicly documented protocols rather than ones any single company owns.
#CSN-1.B.2 Getting online requires linking your device to some other device that already has a connection to the Internet.
#CSN-1.B.3 A protocol is a shared rulebook that every party agrees to follow so a system behaves predictably.
#CSN-1.B.4 Because the Internet's protocols are public rather than proprietary, it is easy for anyone to add new devices to it.
#CSN-1.B.5 Data on the Internet usually is not routed along a path chosen ahead of time -- the route tends to be worked out on the fly.
#CSN-1.B.6 Scalability describes a system's ability to grow and handle new demand without breaking down.
#CSN-1.B.7 Scalability was a deliberate design goal of the Internet from the start.

#CSN-1.C Describe how information travels across the Internet in packet form.

#CSN-1.C.1 Data crossing the Internet moves as a stream that gets broken into smaller pieces, each wrapped up as a packet.
#CSN-1.C.2 Along with a piece of the actual data, each packet carries extra information used for routing it to its destination and for putting it back together afterward.
#CSN-1.C.3 There is no guarantee packets arrive in the order they were sent, or that they arrive at all.
#CSN-1.C.4 IP, TCP, and UDP are examples of protocols commonly used to move data across the Internet.

#CSN-1.D Explain how the World Wide Web differs from, and depends on, the Internet.

#CSN-1.D.1 The Web is a collection of interlinked pages, programs, and files.
#CSN-1.D.2 HTTP is one of the protocols the Web relies on.
#CSN-1.D.3 The Web runs on top of the Internet rather than being a separate network of its own.

#4.2 Fault Tolerance

A system built from unreliable parts can still be reliable overall if it is designed to keep working when some of those parts fail.

#CSN-1.E Using the Internet as an example, explain what makes a system fault-tolerant, why that matters, and where such a system might still be vulnerable.

#CSN-1.E.1 Engineers built the Internet with fault tolerance in mind, using abstraction layers for moving and routing data.
#CSN-1.E.2 Redundancy means building in extra components so a system can absorb the loss of some parts without failing outright.
#CSN-1.E.3 Building more than one route between the same two devices is one concrete way to give a network backup capacity.
#CSN-1.E.4 When part of the Internet fails, later traffic can usually be rerouted around the failure instead.
#CSN-1.E.5 A system that keeps working even after some of its parts fail is called fault-tolerant -- a valuable trait, since large systems tend to fail unpredictably and often in clusters, and fault tolerance lets people keep using the network anyway.
#CSN-1.E.6 Building in redundancy usually costs extra resources, but it buys fault tolerance in exchange.
#CSN-1.E.7 Having multiple possible routes between two points makes the Internet more dependable and better able to grow to serve more devices and people.

#4.3 Parallel and Distributed Computing

Splitting a problem across multiple processors or machines can finish it faster than one processor working alone.

#CSN-2.A Compare sequential, parallel, and distributed approaches to solving a problem, and judge how efficient each one is.

#CSN-2.A.1 Sequential computing runs a program's operations one after another, in order.
#CSN-2.A.2 Parallel computing splits a program into smaller sequential pieces, several of which run at the same time.
#CSN-2.A.3 Distributed computing spreads a single program's work across multiple separate devices.
#CSN-2.A.4 One way to judge which of two solutions is more efficient is to compare how long each one takes to finish the same task.
#CSN-2.A.5 A sequential solution's total running time is just the sum of the time each of its steps takes.
#CSN-2.A.6 A parallel solution's running time is its sequential steps added to whichever parallel branch takes the longest.
#CSN-2.A.7 The speedup of a parallel solution comes from dividing how long the task takes sequentially by how long it takes running in parallel.

#CSN-2.B Weigh the advantages and drawbacks of using parallel or distributed computing.

#CSN-2.B.1 A parallel-computing solution is made up of both a portion that runs in parallel and a portion that runs sequentially.
#CSN-2.B.2 Solutions built around parallel computing generally scale up better than ones that stay purely sequential.
#CSN-2.B.3 Distributed computing can make a problem solvable at all when one computer lacks the time or storage to handle it alone.
#CSN-2.B.4 Distributed computing can also solve much larger problems considerably faster than a single computer working alone could.
#CSN-2.B.5 As more of a solution gets parallelized, the leftover sequential portion increasingly limits how much faster it can go -- past a certain point, adding more parallel work stops helping much.

#IOC Big Idea 5: Impact of Computing (21–26% MCQ)

#5.1 Beneficial and Harmful Effects

A computing innovation can end up used in ways its creators never intended, for better and for worse.

#IOC-1.A Show that a single outcome of a computing innovation can be seen as helpful in one respect and damaging in another.

#IOC-1.A.1 Computing innovations don't appear on their own -- someone builds them.
#IOC-1.A.2 As new computing tools appear, people often change how they get everyday tasks done.
#IOC-1.A.3 Some consequences of an innovation only show up after it's already in use, not before.
#IOC-1.A.4 The same outcome might strike one person as a benefit and another as a problem -- or even seem like both to the same person.
#IOC-1.A.5 Progress in computing has sparked new creative work in fields well outside computing itself, like medicine, engineering, communication, and art.

#IOC-1.B Describe how a computing innovation can end up affecting things well outside what it was built for.

#IOC-1.B.1 Tools built for one purpose often get repurposed later -- the Web began as a way for scientists to trade information quickly, targeted ads help companies but can be exploited, and machine learning has driven progress in medicine and business while also enabling discrimination.
#IOC-1.B.2 How an innovation gets used can end up hurting society, the economy, or culture.
#IOC-1.B.3 A conscientious programmer thinks ahead about ways their creation might be repurposed and weighs the good and bad that could follow.
#IOC-1.B.4 No programmer can foresee every possible use of what they build.
#IOC-1.B.5 Sometimes an innovation's side effects turn out to be good, spurring progress in unrelated areas.
#IOC-1.B.6 Once a program spreads to a huge audience quickly, its effects can grow far beyond what its creator ever intended or could control.

#5.2 Digital Divide

Unequal access to computing and the internet, across geography, income, and other lines, shapes who benefits from computing innovations.

#IOC-1.C Identify the factors that leave some groups with less access to computing than others.

#IOC-1.C.1 How available the internet is differs by income level, location, demographic group, and from one country to another.
#IOC-1.C.2 The term "digital divide" names the gap in access to devices and internet connectivity that tracks income, geography, or demographics.
#IOC-1.C.3 This gap shows up at both the individual level and the level of whole communities.
#IOC-1.C.4 It raises fairness and power questions that play out at both a local and a worldwide scale.
#IOC-1.C.5 Choices made by individual people, companies, and governments all shape how wide this gap gets.

#5.3 Computing Bias

Software can reproduce and amplify existing human biases, whether through the data it learns from or the assumptions built into its logic.

#IOC-1.D Show how bias can find its way into a computing innovation.

#IOC-1.D.1 A system can inherit human prejudice either from the logic its developers coded in or from patterns already present in the data it was trained on.
#IOC-1.D.2 It's on programmers to actively work to strip bias out of their algorithms rather than let existing human biases carry through.
#IOC-1.D.3 Bias can creep in at any stage of building software, not just one.

#5.4 Crowdsourcing

Gathering small contributions from very large numbers of people, over the internet, can solve problems no small group could tackle alone.

#IOC-1.E Describe how large numbers of people can work together on a problem via computing.

#IOC-1.E.1 When information and public data are easy to reach, it becomes easier to spot problems, build solutions, and share what was found.
#IOC-1.E.2 Scientific research increasingly draws on volunteers scattered across many locations rather than a single lab.
#IOC-1.E.3 Citizen science is research where non-experts, spread out and using their own devices, help gather the data.
#IOC-1.E.4 Crowdsourcing means pulling in contributions or information from a big pool of people online.
#IOC-1.E.5 What people can accomplish grows when computing lets them team up.
#IOC-1.E.6 Crowdsourcing has created new ways to collaborate, including linking a business idea or a cause directly with people willing to fund it.

#5.5 Legal and Ethical Concerns

Digitizing information raises questions of ownership and proper credit that copying on paper never had to answer at the same scale.

#IOC-1.F Describe legal and ethical questions raised by how computing gets used.

#IOC-1.F.1 Something made on a computer belongs, as intellectual property, to whoever made it or the organization behind it.
#IOC-1.F.2 Because digital material is so easy to copy and spread, questions of who owns it, what it's worth, and how it can be used become harder to settle.
#IOC-1.F.3 Protecting intellectual property takes deliberate effort.
#IOC-1.F.4 Passing off someone else's uncredited work as your own is plagiarism, and it can carry legal risk.
#IOC-1.F.5 Some licensing models -- Creative Commons, open-source software, and open-access publishing -- exist specifically to let creators legally share and let others build on their work.
#IOC-1.F.6 Anything you use that someone else created should be credited to them.
#IOC-1.F.7 These open licensing models have widened how much digital content people can freely reach.
#IOC-1.F.8 Just like any other technology, computing can be turned toward harming people, and that raises legal and ethical red flags.
#IOC-1.F.9 Computing often gets tangled up in social and political disputes, which brings its own legal and ethical baggage.
#IOC-1.F.10 Unequal access to computing is itself an ethical issue.
#IOC-1.F.11 Specific flashpoints include software that unlocks access to streaming media, algorithms carrying built-in bias, and devices that continuously track and analyze people's activity.

#5.6 Safe Computing

Personal data collected online carries real risk, and encryption and authentication are the main tools for limiting who can get at it.

Out of scope: specific mathematical procedures for encryption/decryption are outside course/exam scope (EK IOC-2.B.5)

#IOC-2.A Explain the privacy dangers that come from gathering and keeping personal data on computers.

#IOC-2.A.1 Personally identifiable information (PII) is any data that can identify or be tied back to a specific person -- things like a Social Security number, age, race, phone number, medical records, financial details, or biometric data.
#IOC-2.A.2 A search engine can keep a log of what a user has searched for over time.
#IOC-2.A.3 A website can track who has visited its pages and when.
#IOC-2.A.4 Location data can be gathered by the devices, sites, and networks a person uses.
#IOC-2.A.5 Technology makes it possible to gather and use information involving people, groups, and organizations -- sometimes to their benefit, sometimes not.
#IOC-2.A.6 A record of past searches can be used to recommend sites or target ads at a person.
#IOC-2.A.7 Separate bits of personal data -- location, cookies, browsing history -- can be combined to build a detailed picture of one person.
#IOC-2.A.8 Personal data shared online can also be used to make a person's online experience more tailored to them.
#IOC-2.A.9 Stored personal information can streamline checkout when someone shops online.
#IOC-2.A.10 When companies or governments collect and organize personal information, that data can be misused if privacy safeguards aren't in place.
#IOC-2.A.11 Content posted online can travel and be reused far past its original context in damaging ways -- an email gets forwarded, a tweet gets retweeted, a social post gets seen by a future employer.
#IOC-2.A.12 Personal information can be exploited for stalking, identity theft, or planning other crimes.
#IOC-2.A.13 Content is hard to fully remove once it's been posted online.
#IOC-2.A.14 Software can log a person's movements -- where they went, the route taken, and how long they stayed.
#IOC-2.A.15 What people post on social media can be pieced together with other sources to infer private facts about them that were never directly shared.

#IOC-2.B Explain both how computing systems can be defended and how they can be attacked.

#IOC-2.B.1 Verifying who someone is -- through strong passwords or multifactor checks -- keeps devices and data safe from people who shouldn't have access.
#IOC-2.B.2 A good password is one the account owner can recall easily but that someone who knows them well still couldn't guess.
#IOC-2.B.3 Multifactor authentication requires proving your identity with several independent pieces of evidence, typically drawn from at least two of: something you know, something you have, and something you are.
#IOC-2.B.4 Because multifactor authentication needs two or more separate steps, an attacker has to defeat every layer, not just one, to break in.
#IOC-2.B.5 Encryption scrambles data so only authorized parties can read it, and decryption reverses that; symmetric encryption uses one shared key for both directions, while public-key encryption uses a published key to lock the message and a private key, held only by the recipient, to unlock it.
#IOC-2.B.6 Certificate authorities vouch for who owns a given encryption key by issuing digital certificates, and the whole system rests on trusting those authorities.
#IOC-2.B.7 Antivirus and anti-malware software helps catch and block infections before they take hold.
#IOC-2.B.8 A computer virus is malicious code that can duplicate itself and sneak onto a machine without permission, often by riding along inside a legitimate program and then running on its own.
#IOC-2.B.9 Malware is any software written to harm a system or seize some control over how it operates.
#IOC-2.B.10 Every real system has some flaw an attacker could exploit, which is why installing regular updates matters -- they patch those weaknesses.
#IOC-2.B.11 Users can limit what data an app is allowed to collect by checking and adjusting its permission settings.

#IOC-2.C Describe the methods attackers use to break into computing systems without permission.

#IOC-2.C.1 Phishing tricks a person into handing over personal details, which an attacker can then use to break into things like bank accounts or email.
#IOC-2.C.2 Keylogging secretly records every key a user presses, letting an attacker capture passwords and other private information.
#IOC-2.C.3 Traffic on a public network can be intercepted, read, or altered in transit -- a rogue access point is one way that happens.
#IOC-2.C.4 A rogue access point is a fake wireless hotspot that lets an attacker slip into a network that's supposed to be secure.
#IOC-2.C.5 A dangerous link can be hidden so it looks harmless on a webpage or in an email.
#IOC-2.C.6 Unwanted emails, attachments, links, or forms can compromise a system's security, and they may come either from a stranger or from a trusted contact whose own account has been hijacked.
#IOC-2.C.7 Free downloads from sketchy freeware or shareware sites are a common way malware sneaks onto a machine.