Key vocabulary

Incremental & iterative development

Building a program in small pieces, testing each piece, then refining based on what you learn — rather than writing the whole thing at once.

Program design

Planning what a program should do before writing it: identifying inputs, outputs, and the steps needed, often with pseudocode, flowcharts, or comments.

Collaboration

Working with others (pair programming, code review, shared docs) to plan, write, and improve a program — a required part of the Create Task.

Debugging

Systematically finding and fixing errors: syntax errors (bad grammar), runtime errors (crashes while running), and logic errors (runs, but gives the wrong answer).

Input

Data a program receives from the user, a file, a sensor, or another program.

Output

Data a program produces: on-screen display, a file, a sound, or a signal to hardware.

The three error types you must be able to tell apart

Debugging strategies you'll be tested on

• Trace the code by hand — walk through it line by line, tracking each variable's value (this is exactly what MC "code tracing" questions ask you to simulate).
• Test with boundary/extreme cases — empty lists, 0, negative numbers, the first/last index.
• Isolate the problem — comment out or simplify code until the bug disappears, then add pieces back.
• Use print/DISPLAY statements to inspect a variable's value at a specific point in execution.
• Rubber-duck it — explain the code out loud, line by line; you often spot the bug mid-sentence.

Worked examples

if x = 5:
    print("five")
# SyntaxError: invalid syntax — should be ==

if x == 5:
    print("five")

nums = [1, 2, 3]
print(nums[5])
# IndexError: list index out of range

nums ← [1, 2, 3]
DISPLAY(nums[5])
// runtime error: index doesn't exist

def is_adult(age):
    return age > 18  # bug: excludes 18

def is_adult(age):
    return age >= 18

The Create Performance Task — rubric in plain English

• Program purpose & function — a video demo plus a written response explaining what your program does and how to use it.
• Data / input — your program must use at least one list (or other collection) to manage complexity, and that list must meaningfully affect the program's behavior.
• Procedural abstraction — you must write a student-developed procedure that has a parameter (that meaningfully changes what happens) and is called at least twice — once to test a different value, and once from within a conditional or loop your program uses.
• Algorithm implementation — the program must include a segment implementing an algorithm with sequencing, selection (if/else), and iteration (loops), all working together, and you must explain how it works.
• Testing — you must show evidence you tested your program, including at least one input that reveals a bug or unexpected behavior you had to address.

Key vocabulary

Bit

A single binary digit: 0 or 1. The smallest unit of data a computer stores.

Byte

A group of 8 bits. Can represent 2⁸ = 256 distinct values (0–255).

Binary number system

Base-2: every digit's place value is a power of 2 (…, 8, 4, 2, 1) instead of powers of 10.

Overflow error

Occurs when a calculated value is too large to be stored in the space allotted for it (e.g., adding 1 to the max value a fixed number of bits can hold).

Lossless compression

Compresses data so it can be perfectly reconstructed — no information is lost (e.g., ZIP, PNG).

Lossy compression

Compresses data by permanently discarding some information to save more space — the original can't be perfectly rebuilt (e.g., JPEG, MP3).

Metadata

"Data about data" — info describing a file without being its main content (e.g., a photo's timestamp, GPS location, camera model).

Data abstraction

Managing complexity by using a variable, list, or other structure to represent a collection of values as a single named object.

Binary conversion — the skill you must have cold

Each binary digit's place value doubles as you move left: 128, 64, 32, 16, 8, 4, 2, 1. To convert binary → decimal, add up the place values where there's a 1.

Why binary can represent anything

• Numbers — straightforward base-2 place value, as above.
• Text — each character maps to a binary number via an encoding scheme like ASCII (7-bit, English-centric, 128 characters) or Unicode (supports far more characters/languages/emoji, using more bits).
• Images — broken into a grid of pixels; each pixel's color is stored as binary numbers (e.g., RGB values 0–255 each).
• Sound — sampled at regular intervals (sampling rate); each sample's amplitude is stored as a binary number.
• This is digital data representation: any kind of information can be encoded as a sequence of bits if everyone agrees on the encoding scheme used to interpret it.

Compression trade-offs

Extracting information from data

Raw data alone often isn't useful — programs and people transform, filter, and combine it to find patterns, make predictions, and support conclusions. Key ideas:

• Large data sets can reveal patterns/trends that a small sample can't — but more data isn't automatically better if it's biased or poorly collected.
• Metadata (like geotags on photos or timestamps on posts) can be combined across many data points to infer things the data wasn't explicitly designed to reveal — this connects directly to privacy concerns in Big Idea 5.
• Data cleaning — fixing missing, duplicated, or inconsistent data before analyzing it, since bad input data produces unreliable conclusions ("garbage in, garbage out").

Worked examples

scores = [88, 92, 79, 95]
total = 0
for s in scores:
    total = total + s
average = total / len(scores)
print(average)

scores ← [88, 92, 79, 95]
total ← 0
FOR EACH s IN scores
{
  total ← total + s
}
average ← total / LENGTH(scores)
DISPLAY(average)

bits = "01101100"
value = int(bits, 2)
print(value)  # 108

// 0110 1100
// 64 + 32 + 8 + 4 = 108
DISPLAY(108)

Key vocabulary

Algorithm

A finite, well-defined sequence of steps for solving a problem or accomplishing a task.

Variable

A named location in memory that stores a value which can change while the program runs.

Sequencing

Statements execute one after another, in order, unless changed by selection or iteration.

Selection

Using a Boolean condition to decide which of two or more paths of statements to execute (if/else).

Iteration

Repeating a set of statements, either a set number of times or until a condition is met (loops).

Procedure (function)

A named group of programming instructions that may take parameters and may return a value; used to manage complexity by abstracting a task.

Parameter

A variable in a procedure's definition that receives a value (an argument) when the procedure is called.

Return value

The value a procedure sends back to the code that called it.

List (array)

An ordered collection of values, referenced by a single name, used to manage complexity when working with many related values.

Procedural abstraction

Hiding a procedure's internal implementation details behind its name — you can call it without knowing exactly how it works inside.

Undefined behavior / unexpected result

What happens when an algorithm is run on an input outside the range it was designed for.

1. Variables & assignment

A variable stores a value under a name. In pseudocode, assignment uses ←; in Python, =.

score = 0
name = "Ada"
score = score + 10

score ← 0
name ← "Ada"
score ← score + 10

2. Operators

remainder = 17 % 5
print(remainder)  # 2

remainder ← 17 MOD 5
DISPLAY(remainder)  // 2

3. Selection (conditionals)

if grade >= 90:
    letter = "A"
elif grade >= 80:
    letter = "B"
else:
    letter = "C or below"

IF (grade ≥ 90)
{
  letter ← "A"
}
ELSE
{
  IF (grade ≥ 80)
  {
    letter ← "B"
  }
  ELSE
  {
    letter ← "C or below"
  }
}

4. Iteration (loops)

for i in range(5):
    print("Hi")

REPEAT 5 TIMES
{
  DISPLAY("Hi")
}

x = 0
while not (x >= 10):
    x = x + 1

x ← 0
REPEAT UNTIL (x ≥ 10)
{
  x ← x + 1
}

colors = ["red", "blue"]
for c in colors:
    print(c)

colors ← ["red", "blue"]
FOR EACH c IN colors
{
  DISPLAY(c)
}

5. Lists — and the #1 exam gotcha

nums = []
for i in range(1, 6):
    nums.append(i * i)
print(nums)  # [1,4,9,16,25]

nums ← []
i ← 1
REPEAT UNTIL (i > 5)
{
  APPEND(nums, i * i)
  i ← i + 1
}
DISPLAY(nums)

6. Procedures / functions

def is_even(n):
    return n % 2 == 0

print(is_even(4))   # True
print(is_even(7))   # False

PROCEDURE is_even(n)
{
  RETURN (n MOD 2 = 0)
}

DISPLAY(is_even(4))
DISPLAY(is_even(7))

7. Robot / Karel-style commands

Some MC questions and simulations use a simplified "robot" acting on a grid.

REPEAT UNTIL (NOT CAN_MOVE(forward))
{
  MOVE_FORWARD()
}
ROTATE_RIGHT()

// Drive forward until you hit a wall,
// then turn right.

8. Classic algorithms

Linear search

def linear_search(lst, target):
    for i in range(len(lst)):
        if lst[i] == target:
            return i
    return -1

PROCEDURE linear_search(lst, target)
{
  i ← 1
  REPEAT UNTIL (i > LENGTH(lst))
  {
    IF (lst[i] = target)
    {
      RETURN (i)
    }
    i ← i + 1
  }
  RETURN (-1)
}

Binary search (list must be sorted first)

def binary_search(lst, target):
    lo, hi = 0, len(lst) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if lst[mid] == target:
            return mid
        elif lst[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

// Each check eliminates HALF the
// remaining list. For n items, that's
// about log2(n) checks — for 1,000,000
// items, ~20 checks instead of up to
// 1,000,000 for linear search.

Selection sort

def selection_sort(lst):
    for i in range(len(lst)):
        min_i = i
        for j in range(i+1, len(lst)):
            if lst[j] < lst[min_i]:
                min_i = j
        lst[i], lst[min_i] = lst[min_i], lst[i]

// Repeatedly find the smallest
// remaining value and swap it into
// its correct position, left to right.

9. Simulations & abstraction

• A simulation uses a program to imitate a real-world (or imagined) process — useful because it's often cheaper, safer, or faster than the real thing, but it's only as accurate as the assumptions built into it.
• Abstraction in programming means managing complexity by hiding detail: procedural abstraction hides implementation behind a name; data abstraction hides low-level representation behind a variable or list name.
• Every abstraction involves a trade-off — you gain simplicity but may lose some control, accuracy, or efficiency.

Key vocabulary

Computing device

Anything that can run a program: computers, phones, routers, embedded sensors, etc.

Computer network

A group of interconnected computing devices capable of sending and/or receiving data.

The Internet

A network of networks, connected by protocols that let devices from different networks and manufacturers communicate.

Protocol

An agreed-upon set of rules that specifies how data is formatted, transmitted, and interpreted between devices.

Bandwidth

The maximum amount of data that can be sent over a connection in a fixed amount of time, usually measured in bits per second.

Latency / bandwidth impact

Higher resolution video/audio and larger files require more bandwidth; too little bandwidth causes lag, buffering, or dropped data.

Fault tolerance

A system's ability to keep working, without total failure, when one of its parts fails.

Redundancy

Having multiple paths or backup components so that if one fails, another can take over — a key technique for fault tolerance.

Parallel computing

Using multiple processors simultaneously, within one machine, to divide up a task and solve it faster.

Distributed computing

Using multiple independent computers, connected over a network, to divide up a task and solve it collectively.

How the Internet actually works

1. Packets & packet switching

Data sent over the Internet is broken into small chunks called packets. Each packet is labeled with metadata (source address, destination address, sequence number) and can travel a different route across the network to reach the same destination.

• Why break data into packets? It lets many devices share the same network links fairly, lets packets reroute around failures/congestion, and lets the receiving end reassemble a large file even if pieces arrive out of order.
• At the destination, packets are reordered using their sequence numbers and reassembled into the original data.
• If a packet is lost, only that piece — not the whole transmission — needs to be resent.

2. IP addresses & DNS

• Every device on the Internet has an IP address — a unique numeric identifier used for routing.
• DNS (Domain Name System) translates human-friendly domain names (like codehs.com) into IP addresses, because typing numbers isn't practical for people.

3. Protocols you're responsible for

4. Fault tolerance — why the Internet rarely "goes down"

• The Internet has no central point of control — it's a distributed, redundant mesh of routers and links.
• If one router or connection fails, packets are automatically rerouted through a different path — this is fault tolerance through redundancy.
• This same idea (redundancy → fault tolerance) applies beyond networking: RAID storage, backup power systems, and distributed servers all trade extra cost/complexity for resilience.

5. Bandwidth in practice

6. Parallel vs. distributed computing

Cybersecurity

Cyberattack

A deliberate attempt to damage, disrupt, or gain unauthorized access to a computing system or network.

Malware

Software designed to harm a system, steal data, or gain unauthorized access (viruses, worms, ransomware, spyware).

Phishing

Tricking a person (via fake emails, sites, or messages) into revealing sensitive information like passwords.

Keylogging

Malware that records every keystroke a user types, capturing passwords and other private data.

Rogue access point

An unauthorized wireless access point set up to intercept traffic from unsuspecting users who connect to it.

DDoS attack

Overwhelming a server with traffic from many sources at once so it can't respond to legitimate requests.

Encryption

Encoding data so that only someone with the correct key can decode/read it, protecting it in transit or storage.

Symmetric encryption

Same key used to both encrypt and decrypt — the key must be shared secretly between parties beforehand.

Public key (asymmetric) encryption

A public key (shared openly) encrypts data; only the matching private key (kept secret) can decrypt it — solves the "how do we share a key safely" problem.

Multi-factor authentication

Requiring 2+ independent proofs of identity (e.g., password + phone code) so a stolen password alone isn't enough to break in.

Certificate Authority

A trusted organization that verifies a website's identity and issues it a digital certificate, which is what makes the padlock/HTTPS trustworthy.

Key vocabulary

Computing innovation

Any product or process created using computing that includes a program as an integral part of its functionality.

Beneficial effect

A positive impact of a computing innovation on individuals, society, the economy, or culture.

Harmful effect

A negative impact — note that the same innovation can have both beneficial and harmful effects depending on context and who's affected.

Digital divide

The gap between people who have reliable access to computing technology/the Internet and those who don't — driven by cost, infrastructure, geography, and policy.

Bias in computing

When an algorithm or data set systematically favors or disadvantages certain groups — often unintentionally, from unrepresentative training data or the assumptions of whoever built the system.

Crowdsourcing

Obtaining input, data, or work by soliciting contributions from a large group of people, typically online.

Citizen science

Crowdsourcing applied to scientific research — everyday people contribute data or processing power to real research projects.

PII (Personally Identifiable Information)

Information that can be used on its own or combined with other data to identify a specific individual (name, SSN, address, biometric data).

Digital footprint / metadata trail

The trace of data a person leaves through online activity, which can be aggregated to build a surprisingly detailed profile of them.

Intellectual property (IP)

Legal rights over creations of the mind — protected via copyright, patents, and licensing.

Open source

Software whose source code is made publicly available for anyone to view, use, modify, and redistribute (often under specific license terms).

Creative Commons license

A licensing framework that lets creators grant certain usage rights to the public while keeping some rights reserved.

Safe computing practices

Habits/tools that reduce risk to a person's devices, data, or identity — e.g., strong unique passwords, MFA, keeping software updated, avoiding unknown links/attachments.

Ideas the exam tests again and again

• Every computing innovation has trade-offs. Almost no MC question about a new technology has a purely "good" or purely "bad" correct answer — the strongest answer usually names both a benefit and a cost/risk.
• Bias often comes from data, not evil intent. A facial recognition system trained mostly on one demographic will perform worse on others — this is a data/training issue, and questions often ask you to identify the bias's source.
• The digital divide compounds other inequalities. Lack of Internet access affects education, job access, and civic participation — treat it as a systemic issue, not just "some people don't have WiFi."
• Crowdsourcing has both power and risk. It can gather huge data sets fast (Wikipedia, citizen science, real-time traffic data) but is also vulnerable to bad-faith or low-quality contributions.
• Legal ≠ ethical, and both matter. Sharing something that's technically legal can still raise privacy or fairness concerns the exam wants you to identify.
• Anonymization isn't foolproof. Even "anonymized" data can sometimes be re-identified by cross-referencing it with other data sets — a classic IOC scenario question.

Quick-reference: benefit vs. harm framing

Full syntax map

The 5 differences that trip people up

1. Indexing: Python starts at 0. Pseudocode starts at 1. Always re-check which one a question is using.
2. No elif: Pseudocode expresses "else if" chains as an IF nested inside an ELSE block — extra braces, same logic.
3. Blocks use { }, not indentation: Pseudocode's grouping is explicit brackets. Python relies purely on indentation — no braces at all.
4. REPEAT UNTIL vs. while: REPEAT UNTIL (cond) keeps looping until cond is true — logically the opposite phrasing of Python's while cond:, which loops while it's true.
5. Procedures always show RETURN(...) with parentheses in pseudocode, even though it behaves just like Python's return value.

Big Idea 1 — Creative Development

• 3 error types: syntax (won't run) · runtime (crashes) · logic (runs, wrong answer).
• Debug by tracing values by hand, testing boundary cases, isolating the failing section.
• Create Task needs: a list that affects behavior, a student-written procedure with a meaningful parameter called ≥2 ways, an algorithm using sequencing + selection + iteration together, and evidence of testing.

Big Idea 2 — Data

• Bit = 0/1. Byte = 8 bits = 256 possible values.
• Binary place values (left→right): 128, 64, 32, 16, 8, 4, 2, 1.
• Lossless = perfectly reversible, smaller savings (ZIP, PNG). Lossy = permanent quality loss, huge savings (JPEG, MP3).
• Metadata = data about data (timestamps, geotags) — can reveal more than intended when aggregated.

Big Idea 3 — Algorithms & Programming

• Python is 0-indexed. AP Pseudocode is 1-indexed. Check every time.
• Pseudocode has no elif — it's nested IF inside ELSE.
• REPEAT n TIMES = fixed count · REPEAT UNTIL (cond) = loops until cond true · FOR EACH x IN list = one pass per element.
• List ops: LENGTH, APPEND, INSERT, REMOVE.
• Procedures: PROCEDURE name(params) { RETURN(value) } — enables procedural abstraction.
• Binary search needs a sorted list; it's ~log₂(n) checks vs. linear search's up to n checks.

Big Idea 4 — Computer Systems & Networks

• Data travels as packets (independently routed, reassembled by sequence number).
• Protocols = agreed-upon rules (TCP = reliable delivery, IP = addressing/routing, HTTP/S = web transfer).
• Fault tolerance comes from redundancy — no single point of failure.
• Parallel computing = multiple processors, one machine. Distributed computing = multiple machines, one network. Neither gives perfectly proportional speedup (coordination overhead).
• Security is trade-offs, not guarantees: encryption, MFA, and certificates reduce risk — none eliminate it.

Big Idea 5 — Impact of Computing

• Nearly every innovation has both a beneficial and a harmful effect — name both when asked.
• Bias usually comes from unrepresentative data/design choices, not explicit intent.
• Digital divide = unequal access to computing/Internet, which compounds other inequalities.
• PII = info that can identify a specific person; anonymized data can sometimes still be re-identified.
• Legal ≠ ethical — both are testable angles on the same scenario.