AP CSP Big Idea 3 Notes: Mastering Procedures, Algorithms, and Modeling

Procedure

A named block of code that performs a specific task and can be called (reused) throughout a program.

Abstraction

A way to think about what code does without focusing on how it does it; a procedure name can serve as an abstraction for its underlying steps.

Decomposition

Breaking a large problem into smaller parts, often by creating separate procedures for each subtask.

DRY (Don’t Repeat Yourself)

A programming principle that emphasizes avoiding repeated code by writing logic once (often in a procedure) and reusing it.

Parameter

A placeholder variable in a procedure definition that represents an input the procedure will receive.

Argument

The actual value passed into a procedure when it is called.

Return value

A value sent back by a procedure to the code that called it, often used when the procedure computes a result.

Side effect

A change a procedure makes to something outside itself (e.g., displaying output, updating a list, changing a global variable) instead of or in addition to returning a value.

Local variable

A variable created inside a procedure that generally cannot be accessed outside that procedure.

Scope

The region of a program where a variable can be accessed/used; local variables and parameters typically have scope limited to their procedure.

Selection (IF statement)

A control structure that chooses different actions based on a condition (e.g., IF a score is ≥ 60, count it as passing).

Iteration (looping)

A control structure that repeats steps, such as REPEAT loops or FOR EACH loops that process list elements.

P-I-O-T (Purpose, Inputs, Output, Tests)

A mnemonic for designing procedures: state the Purpose, choose Inputs (parameters), define Output (return/effects), and create Tests (normal and edge cases).

Library

A collection of prewritten code (procedures/functions/classes/constants) that programmers can use instead of implementing everything from scratch.

API (Application Programming Interface)

The “contract” for using a library or service—describes what procedures exist, what inputs they take, what outputs they return, and how to use them correctly.

Mutate (in-place modification)

To change an existing data structure (like a list) directly, rather than returning a new modified copy.

Algorithmic efficiency

How the resources needed by an algorithm grow as input size grows, commonly considering time (steps) and space (memory).

Scalability

How well an algorithm or program continues to work as the input size becomes much larger (e.g., 10 items vs. 10 million).

Linear search

A search algorithm that checks items one by one until it finds the target or reaches the end; works on sorted or unsorted lists.

Binary search

A search algorithm that repeatedly cuts the search range in half to find a target; requires the list to be sorted and typically needs efficient access to the middle element.

Nested loops

A loop inside another loop; often scales poorly because work can grow quickly (e.g., doubling list size can quadruple pair checks).

Undecidable problem

A problem for which no algorithm can be written that always produces a correct yes/no answer for every possible input (a proven limitation, not just “hard”).

Halting Problem

The classic undecidable problem: given a program and an input, determine whether the program will eventually stop or run forever; no algorithm can solve this correctly for all programs/inputs.

Simulation

A computational process that models a real or hypothetical system by representing its state, applying update rules, and repeatedly iterating over time steps to observe outcomes.

Probabilistic (stochastic) simulation

A simulation that uses randomness to model uncertainty or variation; results vary across runs, and more trials typically produce more stable estimates.