AP® Computer Science A

Course Essential Questions:

• How can a problem be effectively broken down and translated into a clear algorithm and program design that produces meaningful results from data?
• How can algorithms be implemented in code using variables, data abstractions, and procedures to create efficient and functional programs?
• Why might a program fail to work as intended, and how can errors be identified, explained, and corrected?
• What ethical and societal responsibilities should programmers consider when designing, developing, and using computing systems?

Course Objectives:

• Design programs that effectively solve problems or accomplish tasks, and analyze data to identify and extract useful knowledge.
• Write program code to implement algorithms, use data abstractions to manage information, and apply procedural abstractions to organize and simplify complex tasks.
• Determine the result or output of an algorithm based on the order of executed statements. Create code that uses data and procedural abstractions. Explain why existing code segments do not work as intended and make corrections to fix it.
• Describe the behavior of a code segment or program and identify the initial conditions required for the code to work as intended.
• Evaluate the ethical and societal impacts of software development.

UNIT 1: Using Objects and Methods (Weeks 1-8)

Week 1: Introduction to AP CSA

• Review the syllabus
• Explore the Hour of Code initiative.
• Submit AP Summer Work.
• Introduce yourself to your fellow classmates by establishing your personal profile in the course.
• Demonstrate your mastery in navigating the online course interface.
• Register an account with the CSAwesome eBook.

Week 2: Establishing Our Programming Environment

• Download, install, and setup the Eclipse Integrated Development Environment
• Describe common patterns, algorithms, and sequencing steps found in everyday tasks using written language or diagrams.
• Explain the process of writing, compiling, and executing a program, and identify the role of an IDE in this workflow.
• Differentiate between syntax, logic, and run-time errors by analyzing how and when each type occurs during program development.

Week 3: Variables and Expressions

• Classify data as either a primitive or reference type and identify the most appropriate primitive type (int, double, or boolean) based on a given specification.
• Declare variables using correct syntax and construct simple expressions using arithmetic and string literals to generate console output.
• Evaluate arithmetic expressions to determine their results, including how operator precedence and data types affect expression outcomes.

Week 4: Assignment and Casting

• Write assignment and input statements using variables of appropriate types, and predict the value stored after expression evaluation.
• Convert between int and double using casting operations, and explain how casting affects the outcome of expressions.
• Analyze how limited memory and data type constraints can lead to rounding errors or overflow, and describe the resulting behavior of a program.

Week 5: Compound Operators and Libraries

• Construct assignment statements using compound operators and post-increment/decrement syntax, and determine the resulting stored value in a variable.
• Interpret API documentation to identify the attributes and behaviors of library classes, and explain how they can be used in a program.
• Describe the purpose and types of comments in Java, and explain how preconditions and postconditions help define method behavior and expected outcomes.

Week 6: Methods and Math

• Describe how parameters and return types influence how methods are called and used in code.
• Write code that correctly calls class methods using procedural abstraction, and determine the output or behavior based on method calls and return values.
• Develop expressions using built-in Math class methods and evaluate the results, including how to generate random numbers within a given range.

Week 7: Creating and Using Objects

• Explain the relationship between a class and an object by describing how a class acts as a blueprint and how objects are specific instances with defined attributes.
• Write Java code to declare and instantiate objects using constructors, and identify the correct constructor signature based on parameter types and order.
• Develop code that correctly calls instance methods using dot notation, and predict the result of method calls, including identifying potential NullPointerException errors.

Week 8: Strings

• Describe how String objects are created and combined, including immutability and how concatenation results in new objects.
• Write Java code to concatenate strings and call standard String methods (e.g., substring, length, indexOf, equals, compareTo), and determine the output of these method calls.
• Identify the initial conditions (such as valid index ranges) necessary for a String method call to execute without throwing exceptions like StringIndexOutOfBoundsException.

UNIT 2: Selection and Iteration (Weeks 9-15)

Week 9: If Statements

• Describe how sequencing and selection (if, if-else, if-else-if) are used to control the flow of an algorithm, and explain how their order affects the final output.
• Develop program code that uses Boolean expressions and selection statements to solve problems involving multiple conditions.
• Determine the result of executing an algorithm that includes nested selection and repetition structures, and trace the order of execution based on input values.

Week 10: DeMorgan's Laws

• Construct compound Boolean expressions using logical operators (!, &&, ||) and predict their outcomes based on operator precedence and short-circuit evaluation.
• Develop code that implements compound Boolean expressions and determine the result of these expressions during program execution.
• Compare Boolean expressions to identify equivalencies, including the application of De Morgan’s laws, and explain how these equivalencies affect logical reasoning in programming.

Week 11: While Loops

• Identify scenarios in programming where iteration is necessary and explain how while loops control repetitive processes based on Boolean conditions.
• Write code that uses while loops to implement iterative algorithms and predict the output of loops based on the evaluation of Boolean expressions.
• Analyze loop execution to detect common errors such as infinite loops and off-by-one errors, and modify code to correct these errors to ensure proper loop termination.

Week 12: For Loops

• Identify scenarios in programming where iteration is necessary and explain how while loops control repetitive processes based on Boolean conditions.
• Write code that uses while loops to implement iterative algorithms and predict the output of loops based on the evaluation of Boolean expressions.
• Analyze loop execution to detect common errors such as infinite loops and off-by-one errors, and modify code to correct these errors to ensure proper loop termination.

Week 13: Loop Algorithms and Strings

• Develop code that uses for loops to implement iterative processes and determine the output based on the execution order of loop statements.
• Explain the function of each part of a for loop header (initialization, Boolean expression, update) and modify code to correct errors that prevent a for loop from compiling or working as intended.

Week 14: Nested Loops and Runtime Analysis

• Analyze and explain how algorithms can be used to identify digits, calculate sums or averages, and find minimum or maximum values in integer data.
• Modify and debug code segments involving String algorithms to correct errors and ensure the code compiles and runs as intended, especially when processing substrings and reversing strings.

Week 15: Semester Review

• Complete a mid-term exam that covers unit's 1 through 4.
• Create an app that emulates A.I. chatbots such as Siri and Alexa.

UNIT 3: Class Creation (Weeks 16-19)

Week 16: Anatomy of a Class

• Consider best practices in ethical design of apps.
• Designate access and visibility constraints to classes, data, constructors, and methods.
• Design a class using UML class diagrams given a description of attributes and behaviors.

Week 17: Constructors and Instance Methods

• Construct classes with properly declared instance variables and design constructors that initialize an object’s state, including handling default values and copies of mutable objects.
• Differentiate between void and non-void methods by explaining their behaviors, return types, and flow of control, and analyze how accessor and mutator methods impact an object’s state.
• Develop methods with parameters that use primitive values, predict the output of method calls, and evaluate how parameter passing affects program behavior.

Week 18: Parameters and Static Methods

• Construct classes with properly declared instance variables and design constructors that initialize an object’s state, including handling default values and copies of mutable objects.
• Differentiate between void and non-void methods by explaining their behaviors, return types, and flow of control, and analyze how accessor and mutator methods impact an object’s state.
• Develop methods with parameters that use primitive values, predict the output of method calls, and evaluate how parameter passing affects program behavior.

Week 19: Scope and this Keyword

• Differentiate between local variables, parameters, and instance variables by explaining where each can be used in code and analyzing cases where variable names overlap.
• Apply the this keyword in constructors and methods to reference the current object, and demonstrate how it can be passed as an argument in method calls.
• Evaluate the behavior of code segments involving scope and this, and debug errors caused by incorrect variable references.

UNIT 4: Data Collections (Weeks 20-30)

Week 20: 1D Arrays and Data Sets

• Analyze the risks to personal privacy when collecting and storing data, and evaluate how data quality issues such as bias or incomplete information can impact program outcomes.
• Select appropriate data sets to solve problems or answer questions, and represent data patterns and algorithms using written descriptions, charts, or tables.
• Develop code that uses one-dimensional arrays to store, access, and traverse collections of data, and debug errors such as invalid index access.

Week 21: 1D Array Algorithms

• Apply standard array algorithms (e.g., finding min/max, sums, duplicates, or reversing elements) and design original algorithms using array traversals to solve specific problems.
• Develop programs that open and read files using the File and Scanner classes, and handle potential exceptions such as IOException or input mismatches.
• Evaluate the correctness of algorithms and file-processing code by testing with sample input, and debug errors caused by invalid indices, file access issues, or incorrect parsing of data.

Week 22: ArrayLists

• Apply standard array algorithms (e.g., finding min/max, sums, duplicates, or reversing elements) and design original algorithms using array traversals to solve specific problems.
• Develop programs that open and read files using the File and Scanner classes, and handle potential exceptions such as IOException or input mismatches.
• Evaluate the correctness of algorithms and file-processing code by testing with sample input, and debug errors caused by invalid indices, file access issues, or incorrect parsing of data.

Week 23: ArrayLists Algorithms

• Differentiate between primitive types and their wrapper class counterparts (int vs. Integer, double vs. Double), and explain the concepts of autoboxing, unboxing, and immutability of wrapper objects.
• Develop code that creates and manipulates ArrayList objects, including adding, removing, updating, and accessing elements, while applying proper indexing to avoid runtime errors.
• Traverse ArrayList objects using iteration techniques, analyze the results of traversals, and evaluate potential exceptions (e.g., IndexOutOfBoundsException, ConcurrentModificationException) to write safe and correct code.

Week 24: Data Structures

• ??Review your knowledge of applications of arrays, ArrayLists and text file operations.
• Develop programs that open and read files using the File and Scanner classes, and handle potential exceptions such as IOException or input mismatches.
• Evaluate the correctness of algorithms and file-processing code by testing with sample input, and debug errors caused by invalid indices, file access issues, or incorrect parsing of data.

Week 25: 2D Arrays

• Develop code that creates and initializes two-dimensional (2D) arrays to represent collections of related data, including specifying rows, columns, and default or custom values.
• Apply indexing techniques to access and modify individual elements or entire rows in a 2D array while understanding valid row and column ranges to prevent errors.
• Traverse 2D arrays using nested iteration statements (for loops or enhanced for loops) to analyze array contents in row-major, column-major, or custom order, and evaluate traversal results.

Week 26: 2D Array Algorithms

• Apply standard algorithms to 2D arrays to perform operations such as finding minimum/maximum values, computing sums or averages, checking properties, and detecting duplicates.
• Develop original algorithms that operate on entire 2D arrays or specific rows, columns, or subsections, including shifting, rotating, or reversing elements.

Week 27: Interactive Searching and Sorting

• Implement selection sort and insertion sort algorithms to sort arrays or ArrayLists, following the iterative steps of each algorithm accurately.
• Analyze the behavior of linear search and sorting algorithms by predicting outcomes, evaluating efficiency, and debugging errors in implementation.

Week 28: Recursion

• Describe what a recursive method is and the benefits of using recursion.
• Explain how recursive method calls are handled in a call stack.
• Trace the output of a recursive method.

Week 29: Recursive Searching and Sorting

• Search arrays and ArrayLists binary search algorithm.
• Sort 1D arrays using recursive merge sort.
• Implement a binary search using recursion.
• Summarize the advantages and disadvantages of the two searches and three sort algorithms.

Week 30: Unit 4 Review and Assessment

• Develop code that uses one-dimensional arrays to store, access, and traverse collections of data, and debug errors such as invalid index access.
• Assess our knowledge on Unit 4 concepts.

UNIT 5: AP Practice Exam, Review and Reflection (Weeks 31-33)

Week 31: Review Part 1 and Practice Exam

• Take a practice exam with multiple choice questions.
• Take a practice exam with free response questions.

Week 32: Review Part 2 and Practice Exam Reflection

• Analyze the results of the AP Multiple Choice Practice Exam 1 from the last topic.
• Take a practice exam with multiple choice questions.
• Take a practice exam with free response questions over random numbers and for loops.

Week 33: Final Thoughts and Goodbyes

• Examine other websites to get extra practice problems.
• Reflect on your time in this course. Provide feedback and reflections of this course to VHS Learning.