AP Computer Science A — Course Home

★ This course is designed to prepare students to take the AP Computer Science A Exam ★
Excerpts from the course overview were taken from AP College Board.

AP Computer Science A Course Overview

AP Computer Science A is an introductory college-level computer science course that introduces one of the most popular programming languages to students. Fundamental topics include the design of solutions to problems, the use of data structures to organize large sets of data, the development and implementation of algorithms to process data and discover new information, the analysis of potential solutions, and the ethical and social implications of computing systems. The course emphasizes object-oriented programming and design using the Java programming language.

The following big ideas serve as the foundation of the course:

Big Idea

Description

Modularity

Object-oriented programming allows us to use abstraction to break complex programs into individual classes and methods.

Variables

Variables create data abstractions, representing a set of possible values or a group of related values.

Control

Doing things in order, making decisions, and repeating processes are represented in code using control structures.

Impact of Computing

Computers have revolutionized our lives. To use computing safely and responsibly, we must be aware of privacy, security, and ethical issues.

For this course we will use various Integrated Development Environments (IDEs) to manage programs, data files, and images. Coding Rooms is our primary online IDE. For personal development and collaboration, online IDEs allow peer collaboration. Students using a personal laptop may install VS Code as a desktop IDE.

Oracle Java Foundations — Course Goals

This course also prepares students to sit for the Oracle Java Foundations Certification Exam (1Z0-811). The exam consists of 75 multiple-choice questions (150 minutes, 65% passing score). Students who master AP CSA content are well positioned to earn this industry-recognized credential.

Oracle 1Z0-811 Exam Domain Alignment

1Z0-811 Exam Domain

AP CSA Unit Connection

Topic 2: Basic Java Elements — syntax, comments, java.lang

Unit 1 — program structure, semicolons, comments, java.lang package

Topic 3: Working with Java Operators

Unit 1 — arithmetic, assignment, relational, and logical operators

Topic 4: Working with the Math and Random Classes

Unit 1 — Math.sqrt(), Math.pow(), Math.random(), Math.PI

Topic 5: Working with the String Class

Unit 1 — String methods, concatenation, comparison, charAt(), substring()

Topic 6: Decision Statements

Unit 2 — if, if-else, else-if, switch statements

Topic 7: Loop Constructs

Unit 2 — while, for, enhanced for, do-while loops

Topic 8: Arrays and ArrayLists

Unit 4 — 1D arrays, 2D arrays, ArrayList creation and traversal

Topic 9: Classes and Constructors

Unit 3 — class design, constructors, instance variables, encapsulation

Topic 10: Static Methods and Overloading

Unit 3 — static vs. instance methods, overloaded methods

Topic 11: Exception Handling

Units 2/3 — try-catch blocks, runtime errors, ArithmeticException

Syllabus

Expectations

  • ==Be on time for class.== Students should be seated, logged into Canvas, the course website, and their notebook within the first five minutes to avoid being marked tardy or absent.

  • ==Be prepared for class.== Have your notebook, assignments, pen/pencil, and paper ready every day.

  • ==Have a good attitude about learning.== Be prepared to actively participate. Accept feedback with a positive attitude.

  • ==Be respectful of others and their property.==

  • ==Take care of the learning environment.== Keep your area neat and clean. Always clean your space before leaving. Put materials away in their proper place.

  • ==Report any damaged equipment== to the instructor immediately.

  • Do not change any settings on the computers.

  • Do not download or install any programs (including games) on school computers.

  • Do not access inappropriate content on the internet.

Academic Honesty Policy

==Be in charge of your own learning.== All submitted work — every line of code — must originate from your own mind.

  • Students may work with a peer and discuss general problem-solving strategies, ideas, and algorithms. However, all code must be your own. Every line of code must originate from your own thinking.

  • If you use external sources (websites, LLM/AI tools, friends), cite them in your code comments — indicate where you got help and whether any code sections came from that source. AI tools may be used for idea generation, debugging assistance, and understanding small parts of code — not to generate complete solutions.

  • Team/group assignments must include every team member’s name in the block header comment. All other assignments require individual submission — work cannot be a copy of a peer’s submission. A submitted file bearing another student’s name but not your own will be treated as cheating and subject to the district’s plagiarism/cheating policy.

Electronic Devices

  • During instruction, assessment, classwork, discussions, and group collaboration, all personal electronic devices must be placed in a secure location where they will not be a distraction. Smartphones, tablets, and personal devices are not permitted without explicit instructor permission. Phones must be silenced or powered off.

  • No Meta smart glasses, AR glasses, or AI-enabled wearable devices are permitted in the classroom at any time. These devices can capture audio and video without visible indication, which violates the privacy of other students and the integrity of assessments.

  • CAMS provides Windows Laptops for student use. Personal Laptops are a privilege on our campus, not a right. Parent(s)/guardian(s) will be notified and conferences will be held if a student persists in using laptops for non-academic purposes.

  • Earphones, headphones, or other listening tools (excluding medically approved listening devices) should not be used during instruction or collaboration time.

Notes / Notebook

Each student is responsible for taking, organizing, and maintaining hand-written unit notes (Purpose of Note-Taking). Notes must be hand-written using the Cornell Notes method. Formatted Cornell Notes documents will be provided for each unit subsection. Additional pages will be provided as needed. Students are encouraged to keep their notebooks up-to-date and organized.

📒 Notes may be used on unit tests — current unit only. Notes count for 5% of your final grade.

Academic Support

  • Before school — 7:30 am – 8:30 am (please contact me prior to the date you need assistance — I may be meeting with another student or in a meeting)

  • After school — Tuesday – Thursday: 3:45 pm – 4:15 pm

  • Peer Tutoring — Monday through Friday, before and after school

Weighted Grading

Grades are posted online using Canvas. Grades are weighted and assigned as detailed below. Each item is scaled on a point system.

Grading Category

Percentage

Projects (IDP, Unit Capstone, Final Project)

50%

Tests / Quizzes

30%

Classwork / Portfolio

15%

Notes (hand-written Cornell Notes — current unit usable on tests)

5%

Grading Scale

All projects, presentations, tests, quizzes, classwork, portfolio, and notes will be used to calculate your final grade.

Grade Letter

Percentage

A

90% – 100%

B

80% – 89%

C

70% – 79%

D

60% – 69%

F

50% – 59%

M (Missing)

45%

Students who score below 75% on a project, test, or quiz (excluding finals) may retake for up to 75%. Students have one week to review feedback and schedule a retake before or after school.

Classroom Attendance, Conduct, and Participation

It is crucial that students consistently attend class. Most classes consist of hands-on coding activities, pair programming, and projects that cannot be replicated outside of class time. Consistent attendance directly affects understanding and overall performance.

⚠️ Note on Participation: Participation is a critical component of learning. While it cannot be recorded as a formal grade per district policy, attendance, conduct, and active engagement are tracked and reflected in overall classroom standing.

Conduct Tracking (Additive Scale)

Infractions (Tardies, Sleeping, Gaming, Doing Other Classes’ Work)

Rating

0–5

Excellent (E)

6–10

Satisfactory (S)

11–15

Needs Improvement (N)

16+

Unsatisfactory (U)

Make-Up & Late Work Policy

📌 Planned Absences: If a student will not be present on the day an assignment is due, they must contact the teacher at least 2 days before the absence(s). Failure to notify the instructor in advance does not exempt a student from the assignment or late work penalty.

  • Students are responsible for all makeup work when absent. Refer to the district policy regarding makeup work timelines.

  • To make up a quiz or test, it is the student’s responsibility to contact the instructor within two school days of returning to set an agreed-upon date and time. Makeups and retakes are done before or after school only.

  • Handouts will be placed in a makeup folder labeled with the student’s name. It is the student’s responsibility to check this folder when returning before consulting the instructor.

  • Late work submitted after the due date without prior notification will receive a maximum score of 3/5. Work more than one week late will receive a maximum of 1/5. Projects follow their own rubric timelines.

Assignment Header & Submission Requirements

Required Block Comment Header

All submitted .java files and test case documents must include the following header. This mirrors the block comment required in Main.java and follows the standard used by university CS departments.

⚠️ Submissions missing the header will be penalized one point.

/**
 * Name:          [Your Full Name]
 * Partner:       [Partner's Full Name, or "None"]
 * Course:        AP Computer Science A
 * Instructor:    [Instructor Name]
 * Assignment:    [Assignment Number — Assignment Title]
 * Due Date:      [Month Day, Year]
 */

Example:

/**
 * Name:          Jordan Smith
 * Partner:       Alex Rivera
 * Course:        AP Computer Science A
 * Instructor:    [Instructor Name]
 * Assignment:    1.3.1 — Calculate Your Weight on Jupiter
 * Due Date:      September 12, 2026
 */

Submission Requirements

All assignments require the following unless otherwise stated:

  • All .java source file(s)

  • Test Cases document showing: inputs, expected output, actual output, and Pass/Fail result — with the assignment header at the top

Projects will have their own dedicated rubric and submission instructions posted on Canvas.

5-Point Assignment Rubric

Points

Grade

Compilation & Output

Documentation & Style

Submission

5

Full Credit

Program compiles and runs without errors or warnings. Output matches expected results for all test cases.

Block comment header fully completed. Meaningful variable names, camelCase convention, proper indentation. Inline and multi-line comments present throughout.

All required .java files and test cases submitted with completed assignment header.

4

Near Full Credit

Program compiles and runs. Output is correct for most test cases with one minor error or omission.

Block comment header complete. Comments mostly present. Minor style or formatting inconsistency.

All required files submitted. Assignment header present.

3

Partial Credit

Program compiles but produces incorrect output for some test cases, or compiles with warnings.

Limited comments. Block comment header partially completed. Variable names or formatting inconsistent.

Most required files submitted. Test cases incomplete or partially documented.

2

Minimal Credit

Program has syntax or logic errors that cause significant incorrect output, or fails to fully compile.

Little to no commenting. Block comment header missing or blank. Poor variable naming or formatting.

A required .java file or test cases document is missing. Assignment header absent.

1

Attempted

Code submitted shows a clear attempt but does not compile or run.

Minimal or no documentation present.

At least one file submitted, but submission is largely incomplete.

0

No Credit

Nothing submitted, file is empty, or code is unrelated to the assignment.

N/A

N/A

Note-Taking in Learning

==Do you have the PowerPoint, video, textbook, and website — do you still need to take notes?==

Despite the vast amount of information available in electronic formats, taking notes is an important learning strategy. By considering your note-taking strategies carefully, you will be able to create notes that help you retain the most important concepts and assist in exam preparation.

Two Purposes for Taking Notes

  1. External storage — keeping a record of information heard or read.

  2. Facilitating learning — actively processing and organizing content while studying.

The availability of information online may reduce the importance of external storage. However, by neglecting to take notes, ==you lose the benefits of note-taking as a learning tool==.

How Note-Taking Supports Learning

Taking notes during class supports your learning in several important ways:

  1. Helps you focus attention and avoid distractions.

  2. Engages your mind in identifying and organizing main ideas — active learning rather than passive listening.

  3. Creates a condensed, well-organized record that is more efficient to review than re-reading longer texts.

Note-Taking Methods

Method

Description

When to Use

Lists

Sequential listing of ideas as presented. May be short phrases or full paragraphs.

Fallback method; tends to require a lot of writing and makes prioritization difficult.

Outlines

Most important ideas along the left margin (Roman numerals), supporting ideas indented (letters).

When material is well-organized. Easy to use on a laptop.

Concept Maps

Central idea in the center; branches for new ideas; arrows to connect concepts.

When showing relationships among ideas; good for instructors who move between topics.

Cornell Method ✓ Required

Two-column approach: narrow cue column (left 1/3), notes column (right 2/3), summary footer.

Recommended by most universities. Works for all subject types. Excellent for exam review.

The Cornell Method

The Cornell method was developed in the 1950s by Professor Walter Pauk at Cornell University. It is recommended by most universities for its usefulness and flexibility.

Four components:

Component

Description

Header

Course name and date at the top of each page.

Notes column (right, 2/3 of page)

Capture notes during class using any method — lists, outlines, or diagrams.

Cue column (left, 1/3 of page)

Main ideas, keywords, and questions — filled in during and after class.

Summary (footer)

A 2–3 sentence summary of the class in your own words — written after class.

“I used to tape my lecture classes so I could fill in my sketchy notes afterwards. Now that I’m using the Cornell system, my notes are complete and organized in much less time.”
— A student at Southern Methodist University

==Reviewing your notes as soon as possible after class is the most important step in making note-taking work.==

General Tips on Note-Taking

  1. Be prepared — have your materials (notebook, pens) ready before class.

  2. Write on only one side of the paper to allow integration with reading notes.

  3. Label, number, and date all notes at the top of each page.

  4. Don’t try to capture everything — listen for big ideas, keywords, and instructor emphasis cues.

  5. Copy anything written on the board — it is likely to be important.

  6. Leave space between ideas so you can add detail later.

  7. Use abbreviations — be consistent so you can decode them when reviewing.

  8. Create a symbol to mark when you fall behind (return and fill in with help from a peer or the instructor).

  9. ==Review your notes the same day — this is the single most effective habit for retention.==

  10. Write a summary of the main ideas in your own words after each class.

What If You Miss Class?

  • Never ask: “Did I miss anything important?”

  • If notes or slides are posted online — take notes on them.

  • Borrow a classmate’s notes — photocopy them, then annotate with your own questions and connections. Do not just copy and insert.

  • Schedule a study session with the classmate who provided notes.

  • If no notes are available, use the syllabus to identify what was covered and write a short summary using course readings and reliable sources.

Java Style Guidelines

Consistent, readable code is a professional standard and a grading requirement in this course. All submitted code must follow these Java style conventions.

Naming Conventions

Element

Convention

Example

Variables

camelCase — start lowercase

studentScore, totalCount

Methods

camelCase — start lowercase, verb phrase

calculateAverage(), printResult()

Classes

PascalCase — start uppercase

BankAccount, MoonProblems

Constants

ALL_CAPS_WITH_UNDERSCORES

MAX_SIZE, PI_VALUE

Parameters

camelCase

numStudents, inputValue

Formatting Rules

  • Indentation: 4 spaces (not tabs) per level.

  • Braces: Opening brace on the same line as the statement. Closing brace on its own line.

  • Blank lines: One blank line between methods. Two blank lines between class-level sections.

  • Line length: Keep lines under 100 characters.

  • Variable names: Descriptive and meaningful — never single letters (x, a, n) except for loop counters (i, j).

Comments

  • Block comment header required at the top of every .java file (see Submission Requirements).

  • Inline comments (//) explain the why behind non-obvious logic — not the what.

  • Multi-line comments (/* */) for complex algorithm explanations.

  • Every method should have a brief comment describing its purpose.

Example: Well-Styled Code

/**
 * Name:          Jordan Smith
 * Partner:       None
 * Course:        AP Computer Science A
 * Instructor:    [Instructor Name]
 * Assignment:    1.3.1 — Calculate Your Weight on Jupiter
 * Due Date:      September 12, 2026
 */
public class WeightOnJupiter {

    public static void main(String[] args) {

        // Earth weight in pounds
        double earthWeight = 150.0;

        // Jupiter's gravity is 2.34 times Earth's gravity
        double jupiterGravityMultiplier = 2.34;

        // Calculate weight on Jupiter using proportional gravity
        double jupiterWeight = earthWeight * jupiterGravityMultiplier;

        System.out.println("Weight on Jupiter: " + jupiterWeight + " lbs");

    } // end main

} // end class WeightOnJupiter

AP Computational Thinking Practices: Skills

Practice 1: Program Design and Algorithm Development

1.A

Determine an appropriate program design to solve a problem or accomplish a task (not assessed)

1.B

Determine code that would be used to complete code segments

1.C

Determine code that would be used to interact with completed program code

Practice 2: Code Logic

2.A

Apply the meaning of specific operators

2.B

Determine the result or output based on statement execution order in a code segment without method calls (other than output)

2.C

Determine the result or output based on the statement execution order in a code segment containing method calls

2.D

Determine the number of times a code segment will execute

Practice 3: Code Implementation

3.A

Write program code to create objects of a class and call methods

3.B

Write program code to design a new type by creating a class

3.C

Write program code to satisfy method specifications using expressions, conditional statements, and iterative statements

3.D

Write program code to create, traverse, and manipulate elements in 1D array or ArrayList objects

3.E

Write program code to create, traverse, and manipulate elements in 2D array objects

Practice 4: Code Testing

4.A

Use test cases to find errors or validate results

4.B

Identify errors in program code

4.C

Determine if two or more code segments yield equivalent results

Practice 5: Documentation

5.A

Describe the behavior of a given segment of program code

5.B

Explain why a code segment will not compile or work as intended

5.C

Explain how the result of program code changes given a change to the initial code

5.D

Describe the initial conditions that must be met for a program segment to work as intended

AP CSA Vocabulary

Below is a comprehensive list of vocabulary words every AP Computer Science A student should know.

Missing a word? Please let me know…

Term

Definition

Algorithm

A step-by-step process for solving a problem or accomplishing a task.

Autoboxing

Automatic conversion of a primitive type to its corresponding wrapper class (e.g., int → Integer).

Boolean

A data type that holds one of two values: true or false.

Cast

Explicitly converting a value from one data type to another (e.g., (int) 3.7 → 3).

Class

A blueprint or template that defines the data (fields) and behavior (methods) for objects.

Compilation Error

An error detected by the Java compiler before the program runs (syntax errors, type mismatches).

Compound Assignment Operator

An operator that combines arithmetic with assignment (e.g., +=, -=, *=, /=).

Constructor

A special method used to initialize a new object. Has the same name as the class and no return type.

Data Type

Specifies the kind of data a variable can hold (e.g., int, double, boolean, String).

De Morgan’s Law

Rules for negating compound Boolean expressions: !(A && B) equals `!A

Encapsulation

Bundling data (fields) and methods that operate on that data within a class; restricting direct access to fields using private.

Enhanced for Loop

A simplified loop for traversing arrays or ArrayLists: for (Type item : collection).

Exception

A runtime error that disrupts normal program flow (e.g., ArrayIndexOutOfBoundsException, NullPointerException).

Field (Instance Variable)

A variable declared inside a class but outside any method; each object has its own copy.

Index

The position of an element in an array or ArrayList, starting at 0.

Inheritance

(Removed from 2025-26 AP CSA curriculum) A mechanism where one class acquires the fields and methods of another.

Instance

A specific object created from a class.

Instantiation

The process of creating an object using the new keyword.

Integer Division

Division between two integers that discards the decimal remainder (e.g., 7 / 2 = 3).

Interface

(Oracle 1Z0-811) A reference type containing only abstract methods and constants; defines a contract for implementing classes.

Iteration

The process of repeating a block of code using loops (while, for, enhanced for).

Local Variable

A variable declared inside a method; only accessible within that method.

Logic Error

An error where the program runs but produces incorrect output due to flawed reasoning.

Method

A named block of code that performs a specific task and can be called repeatedly.

Method Overloading

Defining multiple methods with the same name but different parameter lists within the same class.

Modular Arithmetic

Using the % operator to find the remainder of division (e.g., 10 % 3 = 1).

Mutator Method (Setter)

A method that modifies the value of a private field (e.g., setName()).

Accessor Method (Getter)

A method that returns the value of a private field (e.g., getName()).

null

A special value indicating that a reference variable does not point to any object.

Object

An instance of a class, containing its own data (fields) and behaviors (methods).

Off-by-One Error

A logic error caused by incorrect loop bounds, often accessing index 0 when 1 is intended, or vice versa.

Operator Precedence

The order in which operators are evaluated in an expression (e.g., * and / before + and -).

Parameter

A variable in a method declaration that receives a value when the method is called.

Polymorphism

(Oracle 1Z0-811) The ability of different objects to respond to the same method call in different ways.

Primitive Type

A basic data type built into Java: int, double, boolean, char, long, float, short, byte.

Private

An access modifier restricting a field or method to use only within its own class.

Public

An access modifier allowing a field or method to be accessed from any class.

Reference Type

Any non-primitive data type — objects, arrays, Strings — stored as a memory reference, not a direct value.

Return Type

The data type of the value a method returns; void if it returns nothing.

Runtime Error

An error that occurs while the program is running (e.g., dividing by zero, null pointer dereference).

Scope

The region of code where a variable is accessible — determined by where it is declared.

Sequential Search (Linear Search)

Checking each element of an array/ArrayList one by one until the target is found.

Static

A modifier indicating that a field or method belongs to the class itself, not to any individual instance.

Static Method

A method that can be called using the class name without creating an object (e.g., Math.sqrt()).

String

A sequence of characters, treated as an object in Java. Immutable — cannot be changed after creation.

Subclass

(Oracle 1Z0-811) A class that inherits from another class using extends.

Superclass

(Oracle 1Z0-811) A class whose properties are inherited by a subclass.

this keyword

A reference to the current object within a method or constructor.

Traversal

Visiting each element in an array or ArrayList, typically using a loop.

Unboxing

Automatic conversion of a wrapper class object to its corresponding primitive type.

Variable

A named storage location in memory that holds a value of a specific data type.

Void

A return type indicating a method does not return any value.

Wrapper Class

An object version of a primitive type: Integer, Double, Boolean. Provides useful methods like Integer.parseInt().

Units & Topics

📅 Timeline Goal: Complete all AP CSA content by March — AP Exam preparation April–May.

2025–26 AP CSA Curriculum — 4-Unit Framework

The AP CSA curriculum was revised for 2025–26, consolidating the previous 10-unit structure into 4 larger units. Key changes:

  • Inheritance, polymorphism, extends, and super have been removed from required AP content

  • File I/O with Scanner is a new addition (Unit 1)

  • Wrapper classes receive expanded emphasis

  • Exam is fully digital via Bluebook

Unit

Title

AP Exam Weight

Unit 1

Using Objects and Methods

15–25%

Unit 2

Selection and Iteration

25–35%

Unit 3

Class Creation

10–18%

Unit 4

Data Collections

30–40%

Course Timeline

Unit / Topic

Assessment

Approx. Timeline

Orientation & Course Setup

August

IDE setup, Coding Rooms, Java program structure

Week 1

Assignment header, test case format, submission requirements

Week 1–2

Unit 1 — Using Objects and Methods

August – October

1.1 Why Programming? Why Java?

MCQ

Aug Week 2

1.2 Variables and Data Types

MCQ

Aug Week 3

1.3 Expressions and Assignment Statements

MCQ

Aug Week 4

1.4 Compound Assignment Operators

MCQ

Sep Week 1

1.5 Casting and Ranges of Variables

MCQ

Sep Week 1

1.6 Static Methods — Math Class

MCQ

Sep Week 2

1.7 String Output and Concatenation

MCQ

Sep Week 2

1.8 String Methods

MCQ

Sep Week 3

1.9 Wrapper Class Overview

MCQ

Sep Week 3

1.10–1.11 Objects — Instances of Classes

MCQ

Sep Week 4

1.12–1.14 Calling Methods, Parameters, Return Values

MCQ

Oct Week 1

1.15 Method Decomposition

MCQ

Oct Week 1

1.16 Scope and Variable Declarations

MCQ

Oct Week 2

1.17 Integer and Double Wrapper Classes

MCQ

Oct Week 2

1.18 File I/O with Scanner (New 2025-26)

MCQ

Oct Week 3

Unit 1 Exam

MCQ + FRQ + Project

Oct Week 4

Unit 2 — Selection and Iteration

November – December

2.1 Boolean Expressions

MCQ

Nov Week 1

2.2 if Statements and Control Flow

MCQ

Nov Week 1

2.3 if-else Statements

MCQ

Nov Week 2

2.4 else-if Statements

MCQ

Nov Week 2

2.5 Compound Boolean Expressions

MCQ + FRQ

Nov Week 3

2.6 Equivalent Boolean Expressions

MCQ

Nov Week 3

2.7 Comparing Objects (.equals())

MCQ + FRQ

Nov Week 4

2.8 while Loops

MCQ

Dec Week 1

2.9 for Loops

MCQ

Dec Week 1

2.10 Developing Algorithms Using Strings

MCQ + FRQ

Dec Week 2

2.11 Nested Iteration

MCQ + FRQ

Dec Week 3

2.12 Informal Code Analysis

MCQ

Dec Week 4

Unit 2 Exam

MCQ + FRQ + Project

Dec Week 4 / Jan Week 1

— Semester 1 Ends —

Unit 3 — Class Creation

January – February

3.1 Anatomy of a Class

MCQ

Jan Week 2

3.2 Constructors

MCQ

Jan Week 2

3.3 Documentation with Comments

MCQ

Jan Week 3

3.4 Accessor Methods (Getters)

MCQ

Jan Week 3

3.5 Mutator Methods (Setters)

MCQ + FRQ

Jan Week 4

3.6 Writing Methods

MCQ

Jan Week 4

3.7 Static Variables and Methods

MCQ

Feb Week 1

3.8 Scope and Access

MCQ + FRQ

Feb Week 1

3.9 this Keyword

MCQ

Feb Week 2

3.10 Ethical and Social Implications of Computing

Feb Week 2

Unit 3 Exam

MCQ + FRQ + Project

Feb Week 3

Unit 4 — Data Collections

February – March

4.1 Array Creation and Access

MCQ

Feb Week 4

4.2 Traversing Arrays

MCQ

Feb Week 4

4.3 Enhanced for Loop for Arrays

MCQ + FRQ

Mar Week 1

4.4 Developing Algorithms Using Arrays

MCQ + FRQ

Mar Week 1

4.5 Introduction to ArrayList

MCQ

Mar Week 2

4.6 ArrayList Methods

MCQ

Mar Week 2

4.7 Traversing ArrayLists

MCQ

Mar Week 2

4.8 Developing Algorithms Using ArrayLists

MCQ + FRQ

Mar Week 3

4.9 Searching (Linear Search)

MCQ + FRQ

Mar Week 3

4.10 Sorting

MCQ

Mar Week 3

4.11 2D Arrays

MCQ

Mar Week 4

4.12 Traversing 2D Arrays

MCQ + FRQ

Mar Week 4

4.13 Ethical Issues Around Data Collection

Mar Week 4

Unit 4 Exam

MCQ + FRQ + Project

End of March

— All AP Content Complete —

AP Exam Preparation

April – May

Practice Exam (2022 Released)

MCQ + FRQ

April

Practice Exam (2023 Released)

MCQ + FRQ

April

Practice Exam (2024 Released)

MCQ + FRQ

April–May

FRQ Type Review (Methods, Class Design, ArrayList, 2D Array)

FRQ

May

AP Computer Science A Exam

May 2026

Final Project

May – June