Students are introduced to the Natural Language Processing Project and evaluate requirements and examples to identify questions and key features. Before beginning work on the project, students expand their understanding of program structure and comments by identifying best practices and exploring the use of Javadocs to generate program documentation
This lesson is aligned to CSTA standards.

Students construct Integer and Double objects to represent int and double primitive values. Using the methods in the Integer and Double classes, students return the values these objects store as primitive values. Additionally, students explore the minimum and maximum values for integers to avoid overflow errors.
This lesson is aligned to CSTA standards.

Students explore the ArrayList class and learn how to declare and initialize an ArrayList and add elements. Students identify scenarios where an ArrayList is more suitable and differentiate between a dynamic data structure and a static data structure. Students then practice creating an ArrayList and adding values to the list.
This lesson is aligned to CSTA standards.

Students work with the get() and set() methods to retrieve and modify elements in an ArrayList and learn about the String method length() to return the number of characters in a String object. They apply the standard algorithms they developed with 1D and 2D arrays to obtain and modify elements in an ArrayList.
This lesson is aligned to CSTA standards.

Students explore generic types in Java and learn why an ArrayList can only store objects. Students then practice applying the algorithms they learned with 1D and 2D arrays to ArrayLists to find information and perform calculations with ArrayList data.
This lesson is aligned to CSTA standards.

Students explore the functionality of the remove() method in the ArrayList class and identify potential errors when attempting to remove items while traversing the list. Students learn about stop word removal and practice removing elements from an ArrayList
This lesson is aligned to CSTA standards.

Students explore the structure of a String and discover the IndexOutOfBoundsException. Students learn about text segmentation and use the indexOf() and substring() methods to implement algorithms to break text into words or sentences and apply natural language processing techniques.
This lesson is aligned to CSTA standards.

Students explore the functionality of the compareTo() method then write an algorithm to sort a list of Strings in alphabetical order. Students implement their algorithms in Java and practice using the compareTo() method to determine if one String comes before another and to sort a list of Strings in alphabetical order.
This lesson is aligned to CSTA standards.

Students combine their knowledge of standard algorithms and Strings to write an algorithm to check if a String is a palindrome. Students implement their algorithm in Java, then apply standard algorithms to traverse Strings find if one or more substrings has a particular property or to determine the number of substrings that meet specific criteria.
This lesson is aligned to CSTA standards.

Students explore the issues and impacts resulting from open source software bugs. Students discover strategies for maximizing system reliability.
This lesson is aligned to CSTA standards.

Students continue to develop their Creative Coding Project to create a program that portrays a personal interest or solves a problem using The Theater. Students first self-assess their work to evaluate their progress in completing project requirements, then continue developing their projects. Students then conduct acceptance testing to determine which of their user stories are complete and use the self-assessment and peer feedback to prioritize their remaining tasks.
This lesson is aligned to CSTA standards.

In the previous lesson, students conducted self-assessments and wrote acceptance criteria for their projects. Students obtain peer feedback in this lesson to identify remaining tasks to complete and continue developing their Creative Coding with The Theater Project.
This lesson is aligned to CSTA standards.

Students conducted code reviews at the end of the previous lesson to give and receive feedback that assists in identifying areas of improvement and fixes for problems they encountered. At this stage of the project, students consider this feedback as they finalize development in this lesson. Students share their final projects with their peers to celebrate their successes.
This lesson is aligned to CSTA standards.

Students practice developing solutions to AP CSA FRQs on a mock Arrays FRQ. Students apply decomposition and annotation strategies to identify the key components of the problem and validate their solutions using Scoring Guidelines.
This lesson is aligned to CSTA standards.

Students are introduced to the Creative Coding with The Theater Project and evaluate requirements and examples to identify questions and key features. Students learn about project backlogs and benchmarks and set up their Project Planning Board by identifying some of the tasks they need to complete for the project.
This lesson is aligned to CSTA standards.

Students revisit passing primitives and object references as parameters to identify similarities and differences between each. Students explore the impact of using an object reference as a parameter on the original object and identify scenarios when it is not ideal to use an object reference as a parameter. Students then learn about user stories and write user stories for their projects to identify required program features.
This lesson is aligned to CSTA standards.

Students revisit overloading and explore overloading methods to determine their impacts on the functionality of a program. Students practice writing overloaded methods to solve problems using the console, The Neighborhood, or The Theater before beginning their initial plans for their Creative Coding with The Theater Project.
This lesson is aligned to CSTA standards.

Students revisit access modifiers to explore the accessibility of methods and constructors in a program. Students identify scenarios for using a private method and constructor and practice writing and using private methods using the console or The Theater. Students then finalize their planning for their Creative Coding with The Theater Project and participate in a peer review to receive feedback on their work.
This lesson is aligned to CSTA standards.

Students have overridden methods from the Object class and worked with class hierarchies that implemented overridden methods. Students explore writing and calling overridden methods and how the super keyword can be used to call the superclass version of a method. Students identify scenarios for overriding methods and practice writing and calling overridden methods using the console, The Neighborhood, or The Theater.
This lesson is aligned to CSTA standards.

Students explore the ethical and social implications of intellectual property by analyzing and discussing real-world applications of algorithmic decision-making. Students learn why algorithms should be held accountable and regulated through audits and reflect on whether they would want their code to be audited.
This lesson is aligned to CSTA standards.