AP Computer Science Principles Study Guide

Core Principles of the Advanced Placement Program

• Clarity and Transparency: The AP program provides public course frameworks and sample assessments to ensure teachers and students have clear expectations for demanding work.

• Encounter with Evidence: Students are encouraged to develop as independent thinkers by drawing their own conclusions based on evidence and the scientific method.

• Opposition to Censorship: AP respects intellectual freedom; topics required by college-level curricula (such as evolution in biology) must be taught for the course to maintain the AP designation.

• Opposition to Indoctrination: Students are expected to analyze multiple perspectives. No points are awarded on exams for agreeing with a specific viewpoint. The focus is on assessing the credibility of sources and drawing independent conclusions.

• Open-Minded Approach to Histories and Cultures: Disciplines ground the study of nationalities, religions, and ethnicities in primary sources, allowing students to evaluate evidence for themselves.

• Respect and Diversity: Classrooms are expected to cultivate respectful debate. Students are encouraged to evaluate arguments rather than one another.

• Informed Choice: AP courses are a choice for parents and students. While experts and professors define college-level content, parents determine if their child enrolls based on available course descriptions.

About the AP Computer Science Principles (CSP) Course

• Course Equivalent: AP CSP is equivalent to an introductory, college-level breadth course in computer science.

• Prerequisites:     * Successful completion of a first-year high school algebra course.     * Strong foundation in basic linear functions, composition of functions, and problem-solving strategies.     * Ability to use a Cartesian $(x, y)$ coordinate system.     * Prior computer science experience is not required.

• Course Goals:     * Introduce the breadth of the field of computer science.     * Learn to design and evaluate solutions through algorithm and program development.     * Explain how computing innovations and systems (like the Internet) work.     * Explore potential impacts of computing and contribute to an ethical, collaborative culture.

• Programming Language Flexibility: The course does not designate a specific language. Teachers choose the most appropriate language(s) for their students.

Computational Thinking Practices and Skills

• Practice 1: Computational Solution Design: Design and evaluate computational solutions for a purpose.     * Skills include investigating the task ($1.A$), designing an approach ($1.B$), explaining collaboration effects ($1.C$), and evaluating options ($1.D$).

• Practice 2: Algorithms and Program Development: Develop and implement algorithms.     * Skills include representing algorithmic processes without code ($2.A$) and implementing/applying algorithms ($2.B$).

• Practice 3: Abstraction in Program Development: Develop programs incorporating abstractions.     * Skills include generalizing data through variables ($3.A$), using abstraction to manage complexity ($3.B$), and explaining how it manages complexity ($3.C$).

• Practice 4: Code Analysis: Evaluate and test algorithms and programs.     * Skills include explaining how code functions ($4.A$), determining results of code ($4.B$), and identifying/correcting errors ($4.C$).

• Practice 5: Computing Innovations: Investigate computing innovations.     * Skills include explaining how systems work ($5.A$), generating knowledge from data ($5.B$), describing impacts ($5.C$ and $5.D$), and evaluating legal/ethical factors ($5.E$).

• Practice 6: Responsible Computing: Contribute to an inclusive, safe, and ethical culture.     * Skills include collaborating ($6.A$), using safe methods ($6.B$), and acknowledging intellectual property ($6.C$). Note: Practice 6 is not assessed on the multiple-choice exam.

Course Content Big Ideas

• Big Idea 1: Creative Development (CRD) [10–13% weighting]: Focuses on the iterative design process, including investigating, designing, prototyping, and testing. Collaboration is highlighted as a tool to avoid bias and incorporate diverse perspectives.

• Big Idea 2: Data (DAT) [17–22% weighting]: Explores how data is represented digitally through bits ($0$ and $1$), how $8$ bits form a byte, and how digital data approximates analog data through sampling. Covers number bases (binary base $2$ vs. decimal base $10$), data compression (lossless vs. lossy), and extracting information/metadata.

• Big Idea 3: Algorithms and Programming (AAP) [30–35% weighting]: Covers variables, assignments, data abstraction (lists), and mathematical expressions (using operators like $, -, \times, /, \text{MOD}$). Discusses Boolean logic (NOT, AND, OR), selection (conditionals/nested conditionals), and iteration (loops). Includes binary search, simulations, and algorithmic efficiency (polynomial vs. exponential time).

• Big Idea 4: Computer Systems and Networks (CSN) [11–15% weighting]: Details how computer systems and networks (the Internet) facilitate data transfer using protocols (IP, TCP, UDP, HTTP). Covers pathing, routing, bandwidth, and packets. Discusses fault tolerance through redundancy and the efficiency of sequential, parallel, and distributed computing.

• Big Idea 5: Impact of Computing (IOC) [21–26% weighting]: Analyzes beneficial and harmful effects of technology, the digital divide, computing bias, crowdsourcing, and legal/ethical concerns (intellectual property, Open Source, Creative Commons). Addresses safe computing, including PII (Personally Identifiable Information), authentication (MFA), encryption (Symmetric vs. Public Key), and threats (malware, phishing, rogue access points).

The AP Computer Science Principles Exam Structure

• Section I: End-of-Course Multiple-Choice Exam (70% total weight):     * Duration: $120$ minutes.     * Format: $70$ total questions.     * $57$ single-select questions.     * $5$ single-select questions based on a reading passage about a computing innovation.     * $8$ multi-select questions (select two answers).

• Section II: Create Performance Task (30% total weight):     * Class Time: At least $9$ hours of dedicated in-class time.     * Components:         * Program Code: A PDF containing all student-developed code.         * Video: A one-minute ($1$ minute) video showing input, functionality, and output.         * Personalized Project Reference: A student-authored document with code segments for the list and procedure used in the task.     * Written Response: $2$ questions ($60$ minutes) administered during the end-of-course exam where students respond to prompts using their Personalized Project Reference.

Reference Sheet Programming Constructs

• Assignment and Input:     * $a \leftarrow ext{expression}$: Evaluates expression and assigns to $a$.     * $ext{DISPLAY(expression)}$: Displays value followed by a space.     * $ext{INPUT()}$: Accepts value from user.

• List Operations:     * $ext{aList}[i]$: Accesses element at index $i$ (indexing starts at $1$).     * $ext{INSERT(aList, i, value)}$: Shifts elements and inserts value at index $i$.     * $ext{APPEND(aList, value)}$: Adds value to end of list.     * $ext{REMOVE(aList, i)}$: Removes element at index $i$.     * $ext{LENGTH(aList)}$: Returns the number of elements.

• Iteration and Selection:     * $ext{REPEAT n TIMES}$: Repeats specific code $n$ times.     * $ext{REPEAT UNTIL (condition)}$: Repeats until condition is true.     * $ext{FOR EACH item IN aList}$: Traverses a list sequentially.     * $ext{IF (condition)}$: Standard selection construct.

• Robot Commands:     * $ext{MOVE\_FORWARD()}$: Moves one square.     * $ext{ROTATE\_LEFT()}$ and $ext{ROTATE\_RIGHT()}$: $90$-degree turns.     * $ext{CAN\_MOVE(direction)}$: Boolean check for open squares.

Performance Task Academic Integrity

• Plagiarism Policy: Using code, media, or information created by others or generative AI without acknowledgment results in a score of $0$.

• Generative AI Use: Permitted for understanding principles and assistance in development, but students must be able to explain all co-written code in the written response section.

• Collaboration: Allowed during ideation and program development/debugging only. Collaboration is forbidden during the creation of the video and the Personalized Project Reference.