AP Computer Science Principles Study Guide: 2027 Exam & Create Task

What AP Computer Science Principles teaches

AP Computer Science Principles (AP CSP) is an introductory college-level course about how computing works, how people build programs, and how technology changes the world. It is broader than a programming class. You will design a solution, represent and analyze data, reason about algorithms, examine the Internet, and weigh the benefits and harms of an innovation. The five big ideas are connected: a program may collect data, run an algorithm, communicate across a network, and create consequences for people who never helped design it.

College Board describes the course as comparable to a first-semester introductory computing course for non-computer-science majors. Prior coding experience is not required; high-school algebra is the recommended preparation. A willingness to test ideas and explain your reasoning matters more than memorizing one programming language. AP exam questions use the common AP CSP reference notation so students from different classroom languages can reason about the same algorithm.

AP CSP and AP Computer Science A are not substitutes. CSP examines the breadth of computing and accepts different programming languages for course projects. Computer Science A is a more focused study of programming with Java. If you are choosing between them, see Sly Academy's AP Computer Science A course hub and the AP subject overview. A student can take one or both, depending on interests, school sequence, and college credit policies.

The published College Board course framework for 2026–27 uses the Fall 2023 AP CSP Course and Exam Description. A revised framework is expected for the following 2027–28 school year, so avoid mixing future draft changes into preparation for the May 2027 exam. Your teacher may organize lessons differently from the order below, but all five big ideas belong in the course.

The five big ideas and their multiple-choice weights

The percentages describe approximate weighting within the multiple-choice section, not percentages of the entire AP score. Treat them as a guide to balanced practice rather than a prediction of exactly how many questions will appear. Algorithms and Programming is the largest individual share, but Impact of Computing and Data together are also substantial.

The course also develops six computational thinking practices: solution design, algorithm and program development, abstraction, code analysis, investigation of computing innovations, and responsible computing. The first five receive published multiple-choice weighting ranges; responsible computing is a course practice but is not separately assessed as a multiple-choice practice category. Ethical and societal content still appears within the fifth big idea.

Big Idea 1: Creative Development

Creative development begins with a purpose. A program has a function—what it does—and may serve a broader purpose—why a user needs it. A study planner might accept a list of assignments and deadlines, prioritize the nearest due date, and display a schedule. Its immediate function is ordering tasks; its purpose is helping a learner allocate time. When you describe a program, specify input, processing, output, and the intended user rather than writing only “it helps students.”

Development is iterative. A first design rarely anticipates every situation. Suppose the planner works for three assignments but fails when two have the same deadline. A useful iteration is to state expected behavior, add a test case, revise the comparison rule, and test again. This sequence is more informative than saying “I debugged the code.” Distinguish a syntax error that prevents code from running, a runtime error that occurs during execution, and a logic error that produces the wrong answer without crashing.

Collaboration can improve a project when team members compare approaches, review tests, and communicate design decisions. It can also introduce unclear ownership or incompatible changes if no one records the shared plan. For the scored Create task, follow the current collaboration and attribution rules in the official student handouts; the exam assesses what you can explain about your own work. Read the deeper guides on collaboration in program development and identifying and correcting errors.

A practical development journal

For each small program, record a one-sentence goal, one user action, a sketch of the algorithm, two ordinary tests, one boundary test, and the change made after testing. A boundary test tries a value near the limit: an empty list, a zero, a very large input, or a repeated value. Over time, this journal supplies concrete explanations for “how I developed and tested my program” questions.

Big Idea 2: Data, binary, and information

Computers store information as bits, each of which has one of two values. A sequence of bits can represent a number, character, image, audio sample, or instruction only when an encoding convention tells the system how to interpret it. The pattern 01000001, for example, can be treated as a binary integer or as a character under a particular text encoding. The bits do not carry meaning by themselves.

In positional binary, each place has twice the value of the place to its right. The binary number 10110 equals 16 + 4 + 2 = 22 in decimal. To convert a nonnegative decimal integer to binary by repeated division, record successive remainders when dividing by 2, then read those remainders in reverse order. These are explanations of whole-number representation, not a claim that every number or media file is stored by the same simple method. The binary numbers guide develops the place-value reasoning further.

Compression reduces the number of bits needed to represent information. Lossless methods allow exact reconstruction; lossy methods discard some information to reduce file size further. A text document that must be recovered character for character needs lossless handling. A photograph may tolerate some perceptual loss, depending on intended use. Neither label by itself tells you whether an output will be acceptable: consider the data, the degree of compression, and the purpose. Review lossless and lossy compression with examples you can explain without memorized slogans.

Data analysis begins by asking where data came from. A dataset may be incomplete, biased toward people with access to a service, or measured with error. A chart can reveal a pattern, but correlation alone cannot establish a causal relationship. Imagine a school app showing that students who open more practice questions earn higher scores. That observation does not prove the app caused the improvement: study habits, prior preparation, and access to devices could influence both.

Programs can help filter, transform, and visualize large datasets, yet scale does not guarantee truth. A useful program might count how often a bus arrives late by route and time of day. Its result is only as reliable as the timestamps and the definition of “late.” Start with the using programs with data guide, then practice stating one insight and one limitation for every graph you create.

Big Idea 3: Algorithms and Programming

An algorithm is a finite set of steps for a task; a program implements instructions that a computer can execute. A good algorithm is precise enough that you can trace its behavior for a given input. AP CSP emphasizes three basic structures: sequencing, selection, and iteration. Sequencing determines order; selection chooses a path based on a condition; iteration repeats steps. A complex-looking program often becomes manageable when you identify those structures and track how variables change.

Consider a list of quiz scores and a procedure that counts scores at or above a threshold. The procedure starts a counter at zero, visits each score, increases the counter when the score meets the rule, then returns the total. Ask what happens if the list is empty, if a score equals the threshold, or if a score appears twice. Each case tests a different assumption. When you get an exam question wrong, make a small trace table showing variable values after each iteration.

PROCEDURE CountMeetingGoal(scores, goal)
  count ← 0
  FOR EACH score IN scores
    IF score ≥ goal
      count ← count + 1
  RETURN count

For [72, 90, 90, 65] and a goal of 90, the result is 2. The repeated 90 is counted twice because the loop processes each element. With an empty list, the result is 0 because the body never runs. This example illustrates parameters, a list, iteration, selection, and a return value without relying on one classroom language. Use the official reference sheet for the exact notation you will see.

Variables, Booleans, and conditionals

A variable stores a value that may change as a program runs. An assignment replaces the old value; it is not an algebraic equality statement. If count ← count + 1, the new value is one greater than the previous one. A Boolean expression evaluates to true or false. Conditions such as score ≥ goal and combinations using AND, OR, or NOT decide whether a statement executes. For nested conditionals, trace the outer decision first and evaluate the inner one only when the outer branch is taken.

Be careful with inclusive boundaries. “At least 90” includes 90, while “greater than 90” does not. That single symbol can change the outcome. Practice translating ordinary language into a precise condition, then test the boundary value. The Boolean expressions guide is a useful prerequisite before timed tracing drills.

Lists and abstraction

A list groups multiple values so a program can treat a collection as one data abstraction. Instead of maintaining separate variables for every quiz score, a list allows the same procedure to process any number of scores. This manages complexity when the program would otherwise need repeated, hard-coded statements. That is a stronger explanation than merely saying “a list stores data.” On Create-task written responses, connect the list's role to a concrete reduction in complexity in your own program.

List indexing and list traversals are frequent error sources. Determine whether the reference notation counts positions from 1, as AP CSP pseudocode does, or from 0, as many classroom languages do. Do not silently transfer one convention to the other. In a traversal, identify whether the loop visits values, positions, or a range of positions. The lists and data abstraction lesson provides additional examples.

Procedures, parameters, and testing

A procedure names a reusable block of behavior. A parameter allows callers to supply a value, so the same procedure can work for different inputs. In the counting example, goal is a parameter; changing it does not require copying the entire algorithm. Procedural abstraction manages complexity by moving a meaningful operation behind a clear interface. Its benefit is not simply that the code has a name; it helps a programmer reason about the operation without repeatedly reading its implementation.

Test a procedure with typical, boundary, and unusual inputs, and state the expected result before running it. For a score counter, test a mixed list, an empty list, every score exactly at the threshold, and every score below it. If you cannot predict the output, revisit the specification. If the observed output differs from the prediction, trace the code and fix the first divergence. Review the developing procedures guide.

Searching, simulations, and limits

Some algorithms are faster than others for the same problem. Binary search repeatedly narrows the relevant half of a sorted list; without sorted order, its logic does not apply. A linear search checks entries one by one and can work on an unsorted list. Efficiency questions are about matching the algorithm to its conditions and reasoning about work as input size grows, not performing a full college-level complexity proof.

Simulations use a model to explore a process, often when direct real-world experimentation is expensive, dangerous, or slow. A weather model, traffic model, or infection-spread model depends on assumptions and input quality. Its output can help compare scenarios, but it is not a guaranteed prediction of reality. Vary one assumption, observe how results change, and articulate one limitation. The simulations lesson extends core tracing.

Big Idea 4: Computer Systems and Networks

The Internet is a network of networks, not one centrally controlled machine. Devices communicate by following agreed protocols, and information is broken into packets that can travel across a network. An IP address helps route traffic to a destination; the Domain Name System connects human-friendly names to addresses. Understanding these roles is more useful than memorizing a list of acronyms. If a page fails to load, the problem might involve the device, a name lookup, a network path, or the server—different layers with different symptoms.

Packet routing illustrates a trade-off. Packets can take different paths and may arrive out of order; protocols help a recipient reassemble information and detect or address failures. Redundant paths can make a network fault tolerant because communication may continue when one connection fails. Fault tolerance does not mean failures are impossible or that all data will always arrive instantly. It means the design includes ways to continue or recover when some components fail. Explore how the Internet works and network fault tolerance.

Parallel computing divides work among processors that operate at the same time. Distributed computing spreads work across connected machines. These designs can improve performance or resilience, but coordination and communication also have costs. If a task has one unavoidable sequential step, adding processors cannot make that step disappear. Ask which parts can run independently, what information must be exchanged, and what happens if a machine fails.

A practical exercise is to trace a request from entering a website name to receiving a page. Identify the name lookup, packet routing, server response, and browser rendering as distinct operations. Then describe what a redundant route could help with and what it could not. An alternate network path, for example, will not fix a server that has no copy of the requested file.

Big Idea 5: Impact of Computing

Computing innovations can produce benefits and harms at the same time, and those effects can differ among groups. A health reminder app might help a patient follow a treatment schedule while collecting private information that requires careful protection. A navigation service might reduce travel time for drivers while redirecting traffic through residential streets. A useful analysis identifies a specific mechanism, a stakeholder, a plausible benefit or harm, and a trade-off. Generic statements such as “technology is good and bad” do not explain enough.

The digital divide refers to unequal access to computing devices, connectivity, skills, and opportunities to use technology effectively. A service offered only through a fast smartphone connection can exclude people who have limited data plans, shared devices, disabilities, or inconsistent broadband. Saying a tool is “available online” does not prove that everyone can actually benefit. The digital divide guide helps you examine access as a design question.

Bias can enter a computing system through data selection, labels, assumptions, feedback loops, or the way outcomes are measured. Suppose a model recommends advanced classes using records from schools that historically had unequal opportunities. Even if its code treats each record the same way, the training data may reflect those inequalities. Ask whose data are missing, what counts as success, how errors are distributed, and whether affected people can contest a decision. Read how computing bias can arise.

Privacy and security are related but distinct. Privacy concerns what information is collected, used, and shared. Security concerns protections against unauthorized access or alteration. Encryption can protect data in transit or storage, but it does not automatically resolve whether a company should have collected the data or how long it should retain it. A privacy policy alone cannot prevent a poorly protected database from being compromised. Connect safeguards to specific threats: stronger authentication, limited data collection, access controls, and transparent choices solve different parts of a problem.

Responsible computing also includes intellectual property, accessibility, and environmental costs. A shared code library may save development time but come with licensing obligations. An app may work for one user yet be inaccessible to someone relying on assistive technology. A data-intensive service may consume energy and hardware resources. Describe practical alternatives and their costs. Continue with the safe computing guide.

AP Computer Science Principles 2027 exam format

The end-of-course exam is scheduled for Friday, May 14, 2027, Session 1. It is fully digital in Bluebook. The entire end-of-course sitting lasts three hours: 120 minutes for 70 multiple-choice questions and 60 minutes for two written-response questions containing four prompts. The multiple-choice portion contributes 70% of the overall AP score; the Create performance task and related written responses contribute the remaining 30%. College Board publishes these as assessment weights, not as a promise that a particular raw score will earn a particular AP score.

Plan for a little less than two minutes per multiple-choice question on average, but do not force equal time on every question. A short concept question may take seconds; tracing a longer algorithm may take more. For a two-answer multiple-select item, select exactly the required number. Practice reading what a question asks before reading answer options, and inspect conditions such as “always,” “best,” “can,” and “must.” These words often determine whether a superficially plausible option is actually correct.

Use the official AP CSP exam-format page and AP exam reference information when checking logistics. Bluebook test previews help you become comfortable with the interface, but your AP coordinator remains the source for testing location, start time, device rules, and accommodations.

A better multiple-choice review method

After each practice set, record the concept tested, your chosen answer, the correct answer, and the reasoning that separates them. Classify an error as a concept gap, an indexing mistake, an overlooked condition, a misread question, or a timing problem. Then revisit the concept and solve a fresh problem. Merely rereading an answer explanation can create a false sense of mastery because you recognize the solution after seeing it. Explain it aloud or reconstruct a trace table without looking.

The Create performance task and Personalized Project Reference

The Create task is not a short essay completed on exam day. During the course, you develop a program of your choice and submit three components through the AP Digital Portfolio: program code, a video of the program running, and a student-authored Personalized Project Reference (PPR). College Board provides at least nine hours of in-class time for this work. By April 30, 2027 at 11:59 p.m. ET, each component must be submitted as final. An uploaded draft that has not been finalized is not the same as a final submission. Check portfolio status with your teacher well before the deadline.

Choose a project small enough that you can implement, test, and explain every important part. A complex-looking app is not automatically stronger. A clear program with meaningful input, visible output, a student-developed procedure, and a list used for a genuine purpose is easier to test and defend than a large copied project you do not understand. Make a plan early: user need, input, output, data you will store, procedure behavior, tests, video demonstration, and final PPR captures. Verify the current official student handouts before deciding whether your program and PPR meet detailed requirements.

Your PPR is a set of code screenshots used as a reference during the end-of-course written-response section. The official materials identify list and procedure code segments as central. Select screenshots that are readable and actually support explanations of how a list manages complexity, how a procedure with a parameter works, and how its algorithm uses sequencing, selection, and iteration. Do not depend on tiny, crowded images that you will struggle to read under timed conditions. The current student instructions govern comments, formatting, attribution, and which material may appear in the PPR; do not rely on an older online checklist.

The written-response section contains two questions with four prompt categories: program design/function/purpose; algorithm development; errors and testing; and data/procedural abstraction. Practice answering each category with specific evidence from your own code. For a testing prompt, name an input and expected behavior, describe what the program actually produced, and explain how the test helps verify or reveal an error. For a complexity prompt, state what the list or procedure replaces or simplifies in your program. Vague phrases such as “it makes code easier” rarely show enough understanding.

College Board's 2026–27 policy allows generative AI as a supplementary aid to understand coding, assist code development, and debug. It also warns that generated code can be wrong, biased, inefficient, or too complex to explain. You remain responsible for understanding every submitted part and for following current attribution and collaboration requirements. Ask AI to explain a concept or help isolate an error if permitted, then independently test the result; do not let a tool replace your ability to explain your project on exam day. Read the official AP AI guidance and Digital Portfolio instructions.

A realistic AP CSP study plan

A good plan alternates conceptual reading with small experiments and explanation. Four hours of passive videos do less for tracing than thirty minutes of working through an algorithm, testing an edge case, and correcting a mistaken assumption. Keep three notebook sections: concepts and examples, program experiments, and error review. Each week, revisit a concept from an earlier big idea so the course does not become five disconnected chapters.

This eight-week pattern can be compressed or stretched. If the Create deadline is closer than eight weeks away, prioritize a functioning, well-tested program and the required final submissions. If multiple-choice accuracy is strong but written explanations are vague, explain your code aloud. If you can describe concepts but fail tracing questions, practice with smaller programs until every variable change is visible.

A 30-minute weekly maintenance routine

1. Trace one short algorithm with a list and conditional by hand.
2. Convert one whole number across bases and explain place values.
3. Describe one computing innovation with a benefit and harm for different stakeholders.
4. Run one new test on your Create project and record expected and observed outcomes.
5. Review an official released written-response prompt, then explain what evidence a strong answer would need.

Official released prompts and scoring materials are available in the AP CSP exam questions archive. Use the latest available scoring guidelines and treat older examples cautiously if task instructions have changed. No study guide can guarantee a score; the best indicator is whether you can apply an idea to a new situation and explain why your answer works.