Ap Csp Create Task Examples 2024

The Create Task used to be the part of AP Computer Science Principles where you could actually breathe. You built something, wrote about it, hit submit, and moved on with your life No workaround needed..

Then the College Board changed the rules for the 2024 exam.

Now you're not just submitting code and a video. You're building a Personalized Project Reference — screenshots of specific code segments, annotated and organized — that you'll bring into the actual exam. And the written responses? Those happen during the test, timed, with only your PPR to help you That's the part that actually makes a difference..

If you're teaching this for the first time under the new format, or you're a student trying to reverse-engineer what "good" looks like, the examples floating around the internet are... hit or miss. Some are from the old format. Some miss the new requirements entirely. And almost none show the PPR the way it actually needs to work.

Let's fix that.

What Is the AP CSP Create Task in 2024

Let's talk about the Create Task is the performance task component of AP Computer Science Principles. Think about it: it counts for 30% of your total exam score. The other 70% comes from the multiple-choice section No workaround needed..

Starting with the 2024 exam administration, the task has three submitted components:

1. Program Code — your complete, runnable project
2. Video — a 1-minute demonstration of your program running
3. Personalized Project Reference (PPR) — a PDF with screenshots of four specific code segments, each labeled and annotated

You get 12 hours of in-class time to complete everything. That clock starts when your teacher says go.

Here's the part that trips people up: the written responses (3a, 3b, 3c, 3d) are no longer submitted with the task. That said, you'll have your PPR printed in front of you. That's it. You answer them on exam day, during the multiple-choice section. No internet, no notes, no full codebase.

The Four Required Code Segments

Your PPR must contain screenshots of these four things, clearly labeled:

Miss one? Automatic point deduction. The scoring guidelines are ruthless about this Which is the point..

Why the 2024 Format Changes Everything

The old Create Task let you write paragraphs explaining your thinking. You could clarify confusion in your written responses. You could say "this loop iterates through the list" even if your code was messy And that's really what it comes down to..

Now? The PPR screenshots have to stand alone. Consider this: your code is your explanation. The annotations you add — those little text boxes pointing to lines of code — are the only bridge between what you built and what the reader sees Easy to understand, harder to ignore..

And on exam day, you're answering questions like:

• "Describe the procedure's parameter and what it represents"
• "Explain how the list manages data in your program"
• "Identify the selection and iteration statements in your algorithm"

If your PPR doesn't make those obvious, you're guessing under time pressure Worth keeping that in mind. Turns out it matters..

Real talk: most students don't fail because they can't code. They fail because their PPR is confusing, their video doesn't show the right features, or they picked a project that technically works but doesn't cleanly demonstrate the requirements.

How to Build a Create Task That Actually Scores

Let's walk through what a solid 2024 Create Task looks like from the ground up. And not a toy example. A real project structure that hits every requirement without gymnastics Which is the point..

Pick a Project Type That Naturally Fits

Stop trying to force a calculator or a rock-paper-scissors game to do heavy lifting. The best projects for this task share three traits:

• Data lives in a list — high scores, inventory, contacts, playlist, flashcards
• A procedure transforms that data — search, filter, sort, calculate, update
• The user triggers it — button click, menu selection, text input

Good fits: task manager, quiz app, recipe organizer, budget tracker, flashcard deck. Bad fits: pure animation, single-calculation tools, anything without persistent data No workaround needed..

Design the Procedure First

This is the backbone. Your PROCEDURE screenshot needs to show:

• A procedure definition with at least one parameter
• Sequencing — statements executing in order (this is automatic, but visible)
• Selection — an if / else or switch / case
• Iteration — a for loop, while loop, or for each

Write this procedure before you build the rest of the app. Make sure it does something meaningful with the list.

Example structure (pseudocode-ish):

PROCEDURE filterTasksByStatus(taskList, targetStatus)
    filteredList ← empty list
    FOR EACH task IN taskList
        IF task.status = targetStatus
            APPEND task TO filteredList
        END IF
    END FOR
    RETURN filteredList
END PROCEDURE

That's it. One parameter (targetStatus), uses the list (taskList), has selection (IF), has iteration (FOR EACH), returns a result. The CALL screenshot will show you invoking this with an argument like "complete" or "pending".

Build the List Early

Your LIST screenshot needs to show the list being used — not just declared. Good moments to capture:

• Adding an item to the list
• Removing an item
• Accessing an element by index
• Passing the list as an argument

Don't just screenshot the declaration tasks ← []. That proves nothing. Practically speaking, show APPEND newTask TO tasks or tasks[2]. status ← "done" Still holds up..

The Video: 60 Seconds, No Fluff

You have one minute. The rubric checks for:

• Input being provided
• Output being displayed
• Program functionality demonstrated

Narrate it. Also, "Here I'm adding a new task... now I'm filtering to show only completed tasks... the list updates to show three items." Don't assume the viewer knows what they're looking at.

Record in landscape. Now, keep the cursor visible. No background music. No "um" every three seconds — do a second take.

The PPR: This Is Where Points Live or Die

You get one PDF page per code segment. Four pages total. Each

page must follow a strict format: Screenshot, Label, and Explanation.

1. The Screenshot

The image must be clear, high-resolution, and relevant. If you are documenting a procedure, the screenshot must capture the entire block of code, including the parameters and the return statement. If you are documenting a list, show the list being modified. Avoid taking screenshots of your entire desktop; crop tightly to the code editor to ensure readability.

2. The Label

Every screenshot needs a descriptive title (e.g., Figure 1: Procedure for sorting high scores). This makes your report professional and allows you to reference specific segments in your text.

3. The Explanation (The Most Important Part)

This is where most students lose points. You cannot simply say, "This is my list." You must explain why this code is necessary for your project's logic. Use technical terminology:

• Instead of saying "It goes through the list," say "The iteration allows the program to traverse every element in the array."
• Instead of saying "It checks if the number is big," say "The selection statement evaluates the integer against a threshold to determine the next action."
• Instead of saying "It gives me the result," say "The procedure returns a new list to the main program loop."

Final Checklist Before Submission

Before you hit "upload," run through this checklist to ensure you haven't missed a single requirement:

• [ ] The "Four Page" Rule: Do you have exactly four pages, one for each required segment (List, Procedure, Call, and Video Link)?
• [ ] Parameter Check: Does your procedure screenshot clearly show a parameter being passed in?
• [ ] Logic Check: Does your procedure contain all three required elements: sequencing, selection, and iteration?
• [ ] Video Check: Is your video under 60 seconds, recorded in landscape, and narrated clearly without background noise?
• [ ] The "So What?" Test: In your explanations, did you explain how the code works, rather than just what it is?

By following this structure, you transform a simple coding project into a professional technical report. You aren't just showing that your code works; you are proving that you understand the underlying computational logic that makes it work.