AP Computer Science Principles
A broad first course in computing organized by the five big ideas of the College Board's AP Computer Science Principles course: creative development, data, algorithms and programming, computer systems and networks, and the impact of computing. It uses free texts and a free block or text programming tool the student chooses, and it builds the Create performance task that counts toward the AP score. The student must register for the exam through a school or an approved testing site, and whether a score earns college credit or placement is each college's decision.
- Big Idea 1: Creative Development · weeks 1 to 3
- Big Idea 3: Algorithms and Programming · weeks 4 to 14
- Big Idea 2: Data · weeks 15 to 20
- Big Idea 4: Computer Systems and Networks · weeks 21 to 25
- Big Idea 5: Impact of Computing · weeks 26 to 29
- Create performance task · weeks 30 to 32
- Exam skills and practice exam · weeks 33 to 36
Free texts
- AP Computer Science Principles course page, College Board. The official five big ideas, their share of the exam score and the Create performance task due date, read in weeks 1 and 33. Free to read; College Board materials, not reusable. (checked 2026-11-09)
- AP Computer Science Principles course resources, College Board AP Central. Links to the free Course and Exam Description (with the exam pseudocode reference sheet and Create task rules), Course at a Glance and course overview PDFs. Free to read. (checked 2026-11-09)
- The Beauty and Joy of Computing (BJC), University of California, Berkeley, and Education Development Center. A full AP CS Principles curriculum in the free Snap! block language, with labs and a no-programming unit on social effects of computing. Content is Creative Commons Attribution-NonCommercial-ShareAlike 4.0. (checked 2026-11-09)
- Introduction to Computer Science, OpenStax. A free college text; chapters 1 to 3, 5, 6, 8, 11 and 14 support data, algorithms, systems, networks and responsible computing. Creative Commons Attribution-NonCommercial-ShareAlike; read online or download a PDF. (checked 2026-11-09)
- AP Computer Science Principles, Khan Academy. Free videos, articles and practice for the course, used for extra explanations. The page loads; its unit titles were not read by our checker, so the student picks lessons by topic. (checked 2026-11-09)
Study it week by week
Big Idea 1: Creative Development (weeks 1 to 3)
Week 1: What computing is and what the course covers
Learn
- What computing is and what the course covers
- The five big ideas
- Setting up a programming tool
- Collaboration and feedback
Do
- Read the College Board course page and the five big ideas; Beauty and Joy of Computing, the first lab: set up the free Snap! editor and make a sprite move and speak.
- OpenStax Introduction to Computer Science, chapter 1 (Introduction to Computer Science), read and answer the review questions.
- Start a project log: one dated entry per work session, saved for the whole year.
Week 2: Program purpose and function
Learn
- Program purpose and function
- Iterative and incremental development
- Pair programming
- Documenting code
Do
- Beauty and Joy of Computing, a lab that builds a small game or drawing in steps; write the program's purpose in one sentence before starting.
- Work with a family member or friend as a pair: one writes, one reads aloud, then swap, and record one thing each learned.
- Add a comment to every block or procedure that says what it does.
Week 3: Testing and debugging
Learn
- Testing and debugging
- Kinds of errors
- Test cases
- Acknowledging sources
Do
- OpenStax Introduction to Computer Science, chapter 2 (Computational Thinking and Design Reusability), the sections on decomposition and abstraction.
- Break a working program on purpose in three ways, then write which kind of error each is and how you found it.
- Write five test cases (input and expected output) for a program you made in week 2 and run them.
Big Idea 3: Algorithms and Programming (weeks 4 to 14)
Week 4: Variables and assignment
Learn
- Variables and assignment
- Data types
- Arithmetic and order of operations
- Reading and writing pseudocode
Do
- Beauty and Joy of Computing, a lab on variables and numbers.
- Use the exam pseudocode reference sheet in the College Board Course and Exam Description: rewrite three of your block programs in the exam's notation.
- Trace by hand what the value of each variable is after each line for four short programs.
Week 5: Boolean values
Learn
- Boolean values
- Comparison and logical operators
- Conditionals: if and if-else
- Nested conditionals
Do
- Beauty and Joy of Computing, a lab on conditionals (predicates).
- Write a truth table for AND, OR and NOT, then a program that picks a response to a temperature and a rain yes or no.
- Fix three given programs with wrong conditions by tracing each one.
Week 6: Iteration: repeat and while loops
Learn
- Iteration: repeat and while loops
- Loop conditions
- Infinite loops
- Nested loops
Do
- Beauty and Joy of Computing, a lab on loops and a lab that draws a pattern.
- Write a program that prints a multiplication table with nested loops.
- Trace a loop by hand with a table of values and predict its output before running it.
Week 7: Lists
Learn
- Lists
- Indexing
- Traversing a list
- Adding and removing items
Do
- Beauty and Joy of Computing, a lab on lists.
- Write a program that keeps a to-do list: add, remove and show items.
- Write a loop that finds the largest and the average of a list of ten numbers.
Week 8: Procedures and abstraction
Learn
- Procedures and abstraction
- Parameters and return values
- Procedural abstraction
- Reusing code
Do
- OpenStax Introduction to Computer Science, chapter 2, the section on design reusability.
- Beauty and Joy of Computing, a lab on procedures with inputs; rewrite repeated code from an earlier program as a procedure.
- Explain in two sentences how a procedure with a parameter makes a program easier to change.
Week 9: Strings
Learn
- Strings
- Substrings and concatenation
- String processing
- Modular programs
Do
- Beauty and Joy of Computing, a lab on text and string processing.
- Write a program that checks whether a word is a palindrome and counts vowels.
- Split the program into at least two procedures and test each alone.
Week 10: Algorithms and sequencing, selection, iteration
Learn
- Algorithms and sequencing, selection, iteration
- Expressing an algorithm in words and code
- Different algorithms for the same problem
- Algorithm correctness
Do
- OpenStax Introduction to Computer Science, chapter 3 (Data Structures and Algorithms), the introduction to algorithms.
- Write the same task two ways (for example, finding a name in a list) and say which uses fewer steps.
- Free practice: five multiple-choice questions on tracing code, taken from the College Board course page or a free source you have opened, scored with the answers.
Week 11: Searching: linear and binary
Learn
- Searching: linear and binary
- Sorted data
- Counting steps
- Efficiency of algorithms
Do
- OpenStax Introduction to Computer Science, chapter 3, the sections on searching.
- Play a number-guessing game with a friend to find a number from 1 to 100 using binary search; record how many guesses it takes compared to guessing in order.
- Write both searches for a list and count the comparisons for lists of 8, 64 and 512 items.
Week 12: Reasonable and unreasonable time
Learn
- Reasonable and unreasonable time
- Heuristics
- Undecidable problems
- Random numbers and simulations
Do
- OpenStax Introduction to Computer Science, chapter 3, the sections on algorithm efficiency; Beauty and Joy of Computing, a lab that uses random numbers.
- Write a simulation of rolling two dice 1000 times and graph how often each total appears.
- Explain in a paragraph why trying every route for a delivery truck through many cities takes too long, and what a heuristic gives up.
Week 13: Libraries and APIs
Learn
- Libraries and APIs
- Using documentation
- Building on others' work
- Unit review
Do
- Beauty and Joy of Computing, a lab that uses a library or an outside data source.
- Read the documentation for one library function and use it correctly in a program; write what its parameters mean.
- Self-test: 20 Big Idea 3 questions from free sources, corrected with the written answers.
Week 14: Writing a larger program
Learn
- Writing a larger program
- Planning with a flowchart
- Combining lists, loops and procedures
- Testing the whole program
Do
- Plan a quiz program: draw a flowchart, then build it with a list of questions, a loop, a score variable and a procedure that checks an answer.
- Test with at least eight inputs, including wrong ones and empty ones, and log each result.
- Have someone else use it and write down what confused them.
Big Idea 2: Data (weeks 15 to 20)
Week 15: Bits and binary
Learn
- Bits and binary
- Number systems
- Overflow and rounding
- Analog and digital data
Do
- OpenStax Introduction to Computer Science, chapter 5 (Hardware Realizations of Algorithms), the sections on binary data; read the College Board course page for Big Idea 2.
- Convert ten numbers between binary and decimal by hand, then check them with a free online converter.
- Explain why a computer can store only certain numbers exactly, with an example of a rounding error.
Week 16: Text, images and color as bits
Learn
- Text, images and color as bits
- Pixels and RGB
- Metadata
- Sound sampling
Do
- Beauty and Joy of Computing, a lab or reading on how computers store text and pictures; OpenStax Introduction to Computer Science, the matching sections of chapter 5.
- Build a 8 by 8 black and white pixel picture on graph paper, write it as a string of bits, and trade it with someone to decode.
- Change one color value of a photo in a free editor and write what number changed.
Week 17: Lossless and lossy compression
Learn
- Lossless and lossy compression
- File size and quality
- Trade-offs
- Compression in practice
Do
- Save the same picture as a lossless and a lossy file and compare the sizes and what you can see.
- Run-length encode a ten-character string by hand and say if the result is shorter.
- Write a paragraph on when to choose each kind of compression.
Week 18: Extracting information from data
Learn
- Extracting information from data
- Patterns and trends
- Correlation and causation
- Bias in data
Do
- OpenStax Introduction to Computer Science, chapter 8 (Data Management), the introduction.
- Choose a free public data set (weather, sports or a government data site), put 50 rows in a spreadsheet, and find one pattern.
- Write a short paragraph on a pattern that could be misleading, and what other data would be needed.
Week 19: Cleaning data
Learn
- Cleaning data
- Filtering and sorting
- Visualizations
- Large data sets
Do
- OpenStax Introduction to Computer Science, chapter 8, the sections on organizing and querying data.
- Clean the 50 rows from last week (fix blanks and duplicates), filter to a subset and make a chart, labeling both axes.
- Write what story the chart tells and one way it could be drawn to mislead.
Week 20: Metadata and privacy
Learn
- Metadata and privacy
- Data from many sources
- Scale of data
- Unit review
Do
- Look at the metadata of a photo you took (date, location, camera) and write how it could be used by someone who sees it.
- OpenStax Introduction to Computer Science, review questions for chapters 5 and 8.
- Self-test: 20 Big Idea 2 questions from free sources, corrected with the answers.
Big Idea 4: Computer Systems and Networks (weeks 21 to 25)
Week 21: Computing devices and systems
Learn
- Computing devices and systems
- Hardware and software layers
- Operating systems
- Abstraction in systems
Do
- OpenStax Introduction to Computer Science, chapter 6 (Infrastructure Abstraction Layer: Operating Systems), the first sections.
- Draw a labeled diagram of what happens between pressing a key and a letter appearing on screen.
- List five layers of abstraction you used today and what each hides.
Week 22: The Internet and IP addresses
Learn
- The Internet and IP addresses
- Packets and routing
- Protocols: TCP/IP and DNS
- Fault tolerance
Do
- OpenStax Introduction to Computer Science, chapter 11 (Web Applications Development), the sections on how the web works.
- Use a free traceroute tool or a free network-path visualization for a website of your choice and mark the hops on a sketch.
- Explain in a paragraph why a message is split into packets and what happens if one is lost.
Week 23: The World Wide Web
Learn
- The World Wide Web
- Clients and servers
- HTTP and HTTPS
- Bandwidth and latency
Do
- OpenStax Introduction to Computer Science, chapter 11, review and questions.
- Open your browser's free developer tools on a page, find three requests and write what each one fetched.
- Time how long a small and a large file take to download and compute the speed in megabits per second.
Week 24: Encryption and cybersecurity basics
Learn
- Encryption and cybersecurity basics
- Symmetric and public key encryption
- Phishing and malware
- Strong passwords and multifactor
Do
- OpenStax Introduction to Computer Science, chapter 14 (Cyber Resources Qualities and Cyber Computing Governance), the first sections.
- Encrypt and decrypt a short message with a Caesar cipher by hand, then explain why it is easy to break.
- Write a one-page home safety checklist: passwords, updates, backups and how to spot a phishing message.
Week 25: Sequential, parallel and distributed computing
Learn
- Sequential, parallel and distributed computing
- Speedup
- Critical path
- Unit review
Do
- Work out the time for a four-task job done one at a time and with two helpers when one task must wait for another; draw the chart.
- Explain how a distributed system (many computers working on one problem) differs from one fast computer.
- Self-test: 20 Big Idea 4 questions from free sources, corrected with the answers.
Big Idea 5: Impact of Computing (weeks 26 to 29)
Week 26: Computing innovations: beneficial and harmful effects
Learn
- Computing innovations: beneficial and harmful effects
- Intended and unintended effects
- Who benefits
- Evaluating a source
Do
- Read the College Board course page text for Big Idea 5 and pick one computing innovation to study through the unit.
- Beauty and Joy of Computing, the social implications readings; write a two-sided summary of your innovation: one benefit, one harm, with sources.
- Check three online sources about it: who wrote each, when, and why.
Week 27: The digital divide
Learn
- The digital divide
- Access to the Internet
- Crowdsourcing and citizen science
- Open data
Do
- OpenStax Introduction to Computer Science, chapter 14, the sections on access and responsibility.
- Find a free local or national report on home Internet access and write what it says about who lacks access and why it matters.
- Join or read about a free citizen science project and write how people's contributions are combined.
Week 28: Bias in computing
Learn
- Bias in computing
- Algorithmic bias
- Privacy and personal data
- Copyright and licensing
Do
- Write a paragraph on how a computer system could treat people unfairly because of the data it learned from, using an example you have read about.
- Find the license of one free text or image you used this year (for example Creative Commons) and say what it lets you do.
- Make a list of five things a website could know about you and how you could limit each.
Week 29: Safe computing
Learn
- Safe computing
- Responsible use of technology
- Law and ethics
- Unit review
Do
- OpenStax Introduction to Computer Science, review questions for chapters 11 and 14.
- Self-test: 20 Big Idea 5 questions from free sources, corrected with the answers.
- Choose the idea for your Create performance task and write its purpose in a sentence.
Create performance task (weeks 30 to 32)
Week 30: Reading the Create task rules
Learn
- Reading the Create task rules
- Program design and a list
- A procedure with a parameter
- Algorithms with selection and iteration
Do
- Read the Create performance task description in the free College Board Course and Exam Description and its scoring guidelines. Ask the adult to keep the written response separate from help.
- Plan the program on paper: purpose, user, input, output, the list it uses, the procedure it needs.
- Start building and keep dated notes of each step in the project log.
Week 31: Independent coding
Learn
- Independent coding
- Testing
- Recording the program run
- Written response drafting
Do
- Finish the program on your own, with outside help limited to what the task rules allow; test with at least six inputs.
- Record a short video of the program running that shows input, a function and output, following the task rules.
- Draft the written response to each prompt in your own words, with code snippets for the list and the procedure.
Week 32: Reviewing against the scoring guide
Learn
- Reviewing against the scoring guide
- Revising the response
- Submitting by the due date
- Reflection
Do
- Score your own task against the College Board scoring guidelines and fix anything missing.
- Submit the task through your school or the approved site by the date on the College Board course page (April 30, 2027 for the 2027 exam; confirm the date with the coordinator).
- Write a short note on what you would build next.
Exam skills and practice exam (weeks 33 to 36)
Week 33: How the exam is built
Learn
- How the exam is built
- Multiple-choice question types
- Reading pseudocode
- Pacing
Do
- Read the exam format in the Course and Exam Description and the pseudocode reference sheet.
- Take a set of 30 multiple-choice questions from free sources you have opened under time and score it by big idea.
- Make a list of the weakest big idea and the three topics inside it.
Week 34: Review of Big Ideas 1 and 2
Learn
- Review of Big Ideas 1 and 2
- Data representation drills
- Binary and compression problems
- Spreadsheet data questions
Do
- Redo your self-tests for Big Ideas 1 and 2 and the review questions in OpenStax chapters 5 and 8.
- Do 15 questions on binary, compression and data, and write why each wrong answer was wrong.
- Watch Khan Academy lessons on the two topics you missed most.
Week 35: Review of Big Ideas 3 and 4
Learn
- Review of Big Ideas 3 and 4
- Code tracing speed
- Network and security questions
- Parallel computing problems
Do
- Do 20 code-tracing questions, tracing each on paper first.
- Redo your Big Idea 4 self-test and OpenStax chapter 6 and 11 review questions.
- Explain one algorithm, one network protocol and one encryption idea aloud to someone at home.
Week 36: Full practice exam
Learn
- Full practice exam
- Review of Big Idea 5
- Error analysis
- Test-day plan
Do
- Take a full practice exam from a free source you have opened (a College Board sample, a school-provided AP Classroom set or Khan Academy practice) in one sitting and score it by big idea.
- Write what you missed by big idea and make flashcards for each missed idea.
- Write a one-page reflection on what you now explain well and what to review before exam day.
Projects
- Week 2: First program with a pair. A small game or drawing made with a pair partner, with a purpose sentence and comments in the code.
- Week 3: Debugging log. Break a program in three ways and record how each error was found and fixed.
- Week 11: Search step counting. Linear and binary search written and compared on lists of different sizes.
- Week 14: Quiz program. A program with a list, a loop and a procedure, tested with eight inputs.
- Week 18: Pixel picture and compression. A picture stored as bits and a compression comparison with a written conclusion.
- Week 20: Public data set story. A cleaned data set, a chart and a short written analysis.
- Week 25: Home security checklist. A one-page checklist on passwords, updates and phishing with a cipher demonstration.
- Week 29: Computing innovation study. A two-sided study of one innovation with checked sources.
- Week 32: Create performance task. A program of the student's own design, its video and the written response, scored with the College Board guidelines and submitted by the posted date.
- Week 36: Full practice exam. A timed practice exam scored by big idea with an error analysis.
How you will know it
- Programs (about 35 percent): each program has a purpose sentence, comments, a test list and a log. A non-expert can run it, try the test inputs and check that the output matches what the student said it would do; ask the student to change one line and predict the result.
- Create performance task (about 20 percent): score it with the College Board's free scoring guidelines for the task; each row is a yes or no on whether a named part is present, such as a list and a procedure with a parameter.
- Self-tests and tracing practice (about 25 percent): each unit ends with 20 questions with answers; keep a running score by big idea and require corrections in a different color.
- Written explanations (about 10 percent): paragraphs on bias, privacy, compression and the Internet are graded for a clear claim, an example and a reason, not for vocabulary alone.
- Practice exam (about 10 percent) in week 36, scored by big idea.
Before this course
Familiarity with Algebra 1 concepts and no coding experience. This matches what College Board says on its course page; it is not a hard rule, and many students take it as a first computing course.
Teaching this at home
- Run a week as two days of reading and questions, two days of programming, and one day of review or a self-test. Students do not need a special computer; any laptop with a browser can run Snap! and a free text-based language if the student wants one. The exam does not require a particular language and uses its own pseudocode, so practice reading that notation from week 4.
- Where students get stuck: loops that run one time too many or too few, lists that start at 1 in the exam pseudocode, and logic with several conditions. Tracing by hand with a table of variable values fixes most of it; require it before running any code.
- The Create performance task has rules about what help is allowed. Read the task description in the Course and Exam Description together at the start of week 30; the adult's job is to ask questions, not to write or fix the code during the task.
- Big Idea 5 questions reward balanced answers with a specific example. Ask for one benefit, one harm and who is affected, and be neutral: the exam does not take sides on technology debates.
- Safety and privacy: use no real personal data in programs or data sets, keep accounts for free tools in the grown-up's name if a site asks for one, and do the network and security activities only on your own devices and home network.
- If you fall behind, merge weeks 12 and 13, or weeks 24 and 25. The student must register for the exam through a school or approved testing site; ask early, as fall deadlines apply, and the Create task is submitted through that school or site's AP Digital Portfolio.
The official course page is at College Board: https://apstudents.collegeboard.org/courses/ap-computer-science-principles
AP is a trademark of College Board, which is not affiliated with Peabody and does not endorse this page.