CS Discoveries 2019-2020

Standards Alignment

Learning Frameworks

Unit 1 Overview

Unit 1 introduces core practices and frameworks that students will use throughout the course. By the end of the unit, students should be able to identify the defining characteristics of a computer and how it is used to solve information problems. They should be able to use a structured problem solving process to address problems and design solutions that use computing technology.

Learning Framework

Understanding Computing Devices

Students should be able to identify input, output, storage, and processing as four essential components of a computing device and explain the role that each component takes when computers are used to solve informational problems.

Models of Computing Devices:

Identify a computer as a machine that processes information and give a high level description of the input-output-storage-processing model of computing devices.

Input and Output:

Identify the inputs and outputs of common computing devices and select the inputs and outputs used to perform common computing tasks.

Storage:

Provide examples of common types of information that is stored on a computer and explain the need for storage as part of processing information with a computer.

Processing:

Define processing as the work done (possibly by a computer) to turn an input into an output and define an algorithm as the series of commands a computer uses to process information

The Problem Solving Process

Students should be able to define and use a structured problem solving process, identifying key components of the process and how they apply to various problems. Students should use multiple strategies to approach problems, iteratively improving on the solution through collaboration and reflection.

Use a structured problem solving process:

Given various problems, identify individual actions that would fall within each step of a structured process to solve them.

Define a problem to be solved

Assess how well defined a problem is and use strategies to define the problem more precisely

Plan a solution

Consider various approaches to solving a problem, and decide which is the most appropriate

Implement a solution

Carry out and evaluate a solution to a problem, iteratively improving on it as needed

Computing and Algorithms

Students should combine their understandings of computing and problem solving to identify and design solutions for computational problems. In doing so, they should develop algorithms that can automate the processing of information, producing a desired output from a given input.

Identify and define computational problems:

Choose problems that can be solved with computing and justify those choices.

Develop computational solutions:

Identify the inputs associated with a given problem, and define the processing and storage needed to produce the desired output.

Developing algorithms:

Develop and iteratively improve algorithms for processing information.

Unit 2 Overview

Unit 2 introduces computer languages and how students can use these languages to create digital artifacts. By the end of the unit, students should be able to create a digital artifact that uses multiple computer languages to control the structure and style of their content. They should understand that different languages allow them to solve different problems, and that these solutions can be generalized across similar problems. Lastly, they should understand their responsibilities as both creators and consumers of digital media.

Learning Framework

Using Computer Languages

Students should understand the need for computer languages, and how to choose a language based on the the task at hand. They should understand that different languages use different syntax, and understand the need for precision and syntax in using multiple computer languages.

Understand and explain the need for computer languages

Understand why specialized languages exist to communicate with computers and describe the features a language might need.

Attend to precision and syntax when creating a digital artifact

Understand the need for precision when using computer languages and use appropriate syntax.

Combine computer languages within a digital artifact

Use multiple computer languages to manage the complexity of a digital artifact.

Choose an appropriate computer language

Understand differences between HTML and CSS and choose the most appropriate language for a given task.

Modularity and Abstraction

Students should be able to break down complex problems into their component parts, distinguishing between content, structure, and formatting. They should also recognize and use abstraction as it is built into computer languages, grouping elements by type or by classes that they create.

Logically separate the content, structure and formatting of a digital artifact

Distinguish between the content, structure, and formatting in the design of a digital artifact and ensure that they are logically separated in its encoding (e.g. by using HTML for structuring and CSS for formatting).

Create classes that can be referenced and affected as a group

Use classes to identify and set the properties multiple elements as a group

Create rules that affect entire groups of elements

Use classes to create formatting rules that will be applied to groups of elements, either by tag or by class.

Use stylesheets to apply formatting rules across multiple web pages

Create and reference style sheets so that consistent formatting rules will apply to multiple web pages.

Creating a Digital Artifact

Students should be able to design and create their own digital artifact using multiple computer languages.

Structure content on a web page using HTML

Use HTML to create a web page that includes hierarchical headings, paragraphs, lists, and images.

Apply formatting in a web page using CSS

Use external style sheets to control placement, size, and appearance of elements.

Define colors with RGB codes

Use RGB color codes to specify colors for elements on a web page.

Debugging and Clean Code

Students should understand the importance of clean, readable code and should use appropriate formatting and commenting conventions to make their code easier to read and maintain. Students should use multiple strategies to find and eliminate bugs from their code.

Format code to make it easier to read and maintain

Use whitespace and indentation to make code easier to read and maintain.

Comment code where appropriate

Use comments to make code more readable.

Use multiple debugging strategies

Develop a set of techniques for preventing bugs in HTML and CSS code and finding them when they occur.

Responsible Creation and Consumption of Digital Media

Students should recognize their responsibilities as creators and consumers of digital media. They should be able to make ethical and safe choices when publishing information online. They should understand that not all information found online is trustworthy, and have strategies for finding relevant and reliable information on the web.

Use good judgement in sharing personal information online

Justify and adhere to guidelines for safely publishing information online,

Explain the purpose of copyright and follow copyright law, accurately attributing others when using their work.

Vet sources

Use basic web searching techniques to find relevant information online, identify elements that contribute to a website's trustworthiness or untrustworthiness.

Unit 3 Overview

Unit 3 focuses on algorithms and programming. By the end of the unit, students should be able to create an interactive animation or game that includes basic programming concepts such as control structures, variables, user input, and randomness. They should manage this task by working with others to break it down using objects (sprites) and functions. Throughout the process, they should give and respond constructively to peer feedback and work with their teammates to complete a project.

Learning Framework

Program Development

Students should be able to collaborate with peers to develop a piece of software. This process involves defining the needs of the program, designing a program to meet those needs, and breaking down the design into manageable pieces. Student code should be written so that others can read and understand it, and they should give and receive feedback on their work, as well as test and revise the program.

Constructively give and respond to peer feedback

Give feedback to peers using a structured process that points out strengths and areas for growth in a project, and incorporate given feedback for their own programs into their revisions.

Write readable code

Organize code such that it is readable and make comments where appropriate to help readers understand the purpose of specific sections. Use reasonable variable and function names.

Using a structured process to plan and develop a program

Use a structured process to describe a program’s behavior, identify the core programming constructs necessary to complete the project, then use them as a guide to complete the program.

Collaborate effectively with team members in distributing and completing tasks on time

Break up tasks so that each team member can make a meaningful contribution. Ensure that the code will work together once it is finished.

Modularity

Students should be able to break down complex problems into their component parts, both to increase readability and organization of code and to allow them to reuse portions of code many times. Algorithms should be broken into functions, and screen elements into sprites/objects. They should also recognize and use abstraction as it is built into programming languages.

Use objects to manage the complexity of on-screen elements

Create and modify objects (sprites) to represent on screen elements and their associated properties. Use dot notation to get and set sprite properties.

Manage complexity through abstraction

Use abstraction to reason about a program at different levels of complexity. Describe the benefits of abstraction, including simplifying code to more easily program complex behavior.

Define and call functions in a program

Create and use functions to organize reuse code within the same program. Modify and use functions created by others

Algorithms and Control

Students should be able to use basic programming constructs to create a wide range of behaviors in their programs. These constructs should be combined to create complex behaviors, such as screen elements that move according to user input, or properties that change after a certain threshold has been reached. Programs should run differently each time according user input or random chance.

Use arguments to change the way a method runs

Use arguments to change the way a method runs, distinguishing between the roles of multiple arguments passed to a method

Detect and respond to user input

Use input from the keyboard and mouse to change the behavior of a program while it is running.

Use iteration to repeat behavior within a program.

Use loops to repeat behavior in a program, combing repetition with other control structure to produce ongoing complex behaviors.

Use conditionals to control the flow of a program.

Use conditional statements to control the flow of a program based on user input, variable values, or properties of objects (sprites).

Generate and use random numbers in a program.

Use random numbers to introduce variation in how a program is run.

Position and Movement

Students should use the coordinate plane to place and move screen elements. The should be able to model various types of motion, including acceleration, linear movement and simulating gravity.

Place elements on screen using a coordinate plane

Use a coordinate system to place elements on a screen, accounting for object size and overlay.

Model two dimensional movement on a coordinate plane

Manipulate the x and y coordinates of an object on a screen to create the illusion of smooth motion.

Model complex movement on a coordinate plane

Combine different types of movement to create more complex behaviors such as acceleration, jumping, and bouncing.

Variables/Storing Information

Students should be able to create new variables as needed in their programs, and update and access the variable values as the program runs.

Use variables to store and update information

Create and assign values to variables as a program is run to store and update changing information

Unit 4 Overview

Unit 4 extends the problem solving process to incorporate user centered design and software development. By the end of the unit, students should see the design process as a form of problem solving that prioritizes the needs of a user. They should be able to identify user needs and assess how well different designs address them. In particular they know how to develop a paper and digital prototypes, gather and respond to feedback about a prototype, and consider ways different user interfaces do or do not affect the usability of their apps. Students should leave the unit with a basic understand of other roles in software development, such as product management, marketing, design, and testing, and to use what they have learned as a tool for social impact.

Learning Framework

Understanding the user

Students should actively consider the needs of others while developing a solution to a problem. They should identify user needs as central criteria for the development of a computational artifact and distinguish their own needs from those of the user, taking steps to identify those needs through a variety of strategies.

Identify user needs as distinct from the needs of the developer:

Describe the target users for a computational artifact and identify those user’s needs, distinguishing between the needs of the student and those of the user.

Collect and analyze user information to better understand user needs:

Collect information on users, either through research, interviews, or surveys, and analyze that information to create a profile for the user, including the needs that the user may have in interacting with the intended computational artifact.

Designing to criteria

Students should be able to use set criteria to guide their design of a computational artifact, both in the overall design and purpose of the artifact and in the specific ways that users can interact with it.

Generate and evaluate ideas for meeting specific criteria

Generate multiple strategies for meeting user needs, then organize them into meaningful categories so that they can be analyzed. Select the most appropriate strategies from the list.

Design according to specific user needs

Design an artifact, including core functionality and user interface, that meets the needs of a specific user, or design improvements to an existing artifact in order to meet those needs.

Prototyping and Testing

Students should be able to create and use a prototype to test the proposed features and functionality of a computational artifact. They should design prototypes tests that allow them to observe user interaction and get user feedback on the artifact and use that feedback to create a plan for improving the artifact’s design.

Create and test a prototype for a computational artifact

Create a paper or digital prototype that incorporates the user flow for a computational artifact. Design and run tests that use these prototypes to gather feedback on a design before creating the full computational artifact.

Synthesize user feedback to identify needed improvements to a design

Analyze user tests to identify features that should be removed, added, or improved within the design of a computational artifact.

Software Development

Use events to detect and respond to use input

Select the appropriate input element for a given type of information and create an event that detects and responds to that input.

Collaboratively develop a computational artifact

Collaborate with others to develop a computational artifact, developing a plan for splitting work effectively, assigning roles and responsibilities to each team member, and integrating all components into the final artifact.

Communicate and document the design and development of a computational artifact

Communicate the design and intended use of program, as well as the development of an ongoing project, to a variety of audiences, including non-technical users.

Refinine Computational Artifacts

Analyze user feedback and test results on a computational artifact, then categorize and prioritize the issues according to impact and ease of implementation. Create and implement a plan for further development of the artifact.

Evaluation and Feedback

Students should be able to evaluate a computational artifact, such as a web page, app, or program, according to its ability to meet a broad range of user needs and its social impact. Students should understand that computational artifacts may incorporate assumptions that developers have made about users, and should be able to clearly and respectfully critique a design

Evaluate usability of computational artifact

Critically evaluate a design based on a specific set of user needs, identifying which needs are and are not met by the design.

Evaluate the purpose and impact of a computational artifact:

Identify the ways in which a computational artifact will impact the intended users, as well as others. This impact may or may not be related to the intended purpose of the artifact. Evaluate whether or not a computational artifact is successful in its intended purpose.

Unit 5 Overview

Unit 5 covers the importance of data in solving problems and highlights how computers can help in this process. By the end of the unit, students should have a broad understanding of the role of data and data representation in solving information problems. They should be able to explain the necessary components of any data representation scheme, as well as the particulars of binary and common ways that various types of simple and complex data are represented in binary code. Students should also be able to design and implement a data-based solution to a given problem and determine how the different aspects of this problem solving process could be automated.

Learning Framework

Data Encoding Systems

Student should be able to use a variety of encoding systems, as well as develop their own systems for encoding particular types of data. They should recognize the importance of encoding at various levels of abstraction.

Develop an encoding system for a particular type of data

Recognize the necessary features of a system for encoding information, such as general agreement among users and a lack of ambiguity. Create, test, and use a system for encoding a particular type of data.

Use existing encoding systems

Choose and justify an appropriate encoding system for a given piece of information. Recognize and extend patterns in existing encoding systems.

Modeling and Problem Solving with Data

Students should be able to use data as a central tool in a structured problem solving process. This process should incorporate data-based models that students test and refine. Students should be able to explain how different aspects of this process can be automated, and how data allows them to identify patterns and support conclusions about the phenomena that they are observing.

Data-based problem solving

Use data in conjunction with the problem solving process to find a data-based solution to a problem. Identify, collect, and clean relevant data, and use it to identify relationships that will help better understand and solve a problem.

Draw conclusions from data

Identify patterns and draw conclusions from data sets, and use them to support a claim or decision. Identify additional data that could improve the decision.

Develop a data-based model

Choose the best way to model complex information or real world phenomena based on how it will be used, and provide examples of how different forms of modeling can facilitate solving different types of problems. Refine the model based on new data.

Automated decision making

Design an algorithm for making decisions using data as inputs, and explain the benefits and drawbacks of using computers for automated decision making

Binary Systems

Students should identify binary representation as a fundamental representation system in computing. They should be able to use binary systems to represent different types of data, and identify some key common representation systems.

Defining binary systems

Define a binary system as one that uses just two possible states to represent information. Describe common features of systems used to encode information in binary.

Using binary systems

Use multiple binary systems to encode, decode, and manipulate information, including characters, numbers, and images. Choose and justify the use of different binary representation depending on the information being represented.

Data and Security

Students should be able to explain how their data may be used with or without their knowledge. They should be able to identify different ways to secure data, both physical and digital, and implement an encryption scheme, differentiating between encryption and encoding.

Distinguish between data that users intentionally and unintentionally produce.

Explain how users produce data both intentionally and unintentionally when interacting with computing systems. Give examples of each type of data and how they are collected.

Apply a method of encryption to ensure the secure transmission of data.

Encrypt and decrypt data using a set cryptographic scheme.

Use both physical and digital security measures to secure data.

Differentiate between physical and digital security measures, and give examples of each. Choose multiple security measures what will best secure data in a given scenario.

Collecting and Transforming Data

Identify and collect relevant data

Identify data that could be collected to develop a model or solve a problem, determine the appropriate sources of that data. Give examples of how data can be collected from sensors, tracking user behavior, as well as surveys and direct responses.

Clean a data set

Explain why a data set must be cleaned to make it more useful, and identify and remove irrelevant data from a data set.

Use data to highlight relationships

Use various data visualizations to highlight relationships in data, including cross-tabulation. Transform data from one visualization to another, and choose and justify the most appropriate visualization for a given task.

Unit 6 Overview

In Unit 6, students further develop their programming skills while more deeply exploring the role of hardware platforms in computing. By the end of the unit, students should be able to design and build a physical computing device that integrates hardware inputs and outputs with software. This unit builds on the skills and understandings from the Animations and Games unit with more sophisticated programming constructs, such as arrays, for-loops, and parameters, as well as a deeper understanding of the types of input and output that can be used in computing. Students should leave the unit feeling equipped to use physical computing to solve problems in fun and innovative ways.

Learning Framework

Computing Systems

Identify hardware used in computing systems

Describe different types of input and output that a computing device might use, and justify the choice of a particular input or output for a given task or computing system

Prototype a physical computing device

Develop an interactive physical prototype that integrates hardware and software, including simple circuits. Connect, troubleshoot, and debug external devices and integrated computing systems.

Use hardware output

Develop software to control a variety of physical devices. Recognize the needs for various types of hardware output in computing systems and use software to produce them.

Use hardware input

Develop a program that responds to a variety of hardware input, including those the user does and doesn’t actively control. Recognize the need for various types of input, both analog and digital, and represent the values of those inputs in various ways.

Algorithms

Events and user input

Use event handlers to respond to user interaction, and describe how an event handler responds to user input.

Use getters and setters to manipulate properties

Use getters and setters to access and manipulate the properties of elements in a system.

Modularity

Use functions with parameters

Create and use a function that uses parameters to generalize behavior. Recognize when a program can use parameterized functions to further generalize algorithms, and justify their use.

Use arrays and iteration

Recognize an array as a list of elements that can be operated on sequentially. Create, modify, and and access elements in arrays. Use for loops to iterate over arrays.

Program Development

Use a structured process to develop a piece of software

Implement different features of a program by following a structured project guide, scoping the features according to user needs and intended functionality.

Identify and analyze computing solutions to a specific problem

Identify various computing solutions to a given problem, and analyze their effectiveness. Suggest and implement improvements to computing solutions.


Download as CSV

Unit 1: Problem Solving

Lesson 1: Intro to Problem Solving

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 1B-AP-08 - Compare and refine multiple algorithms for the same task and determine which is the most appropriate.
  • 1B-AP-11 - Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process.
  • 1B-AP-16 - Take on varying roles, with teacher guidance, when collaborating with peers during the design, implementation and review stages of program development.

Lesson 2: The Problem Solving Process

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 1B-AP-08 - Compare and refine multiple algorithms for the same task and determine which is the most appropriate.
  • 1B-AP-11 - Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process.

Lesson 3: Exploring Problem Solving

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 1B-AP-08 - Compare and refine multiple algorithms for the same task and determine which is the most appropriate.
  • 1B-AP-11 - Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process.
  • 1B-AP-16 - Take on varying roles, with teacher guidance, when collaborating with peers during the design, implementation and review stages of program development.

Lesson 4: What is a Computer?

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

CS - Computing Systems
  • 1B-CS-01 - Describe how internal and external parts of computing devices function to form a system.

Lesson 5: Input and Output

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

CS - Computing Systems
  • 1B-CS-01 - Describe how internal and external parts of computing devices function to form a system.
  • 1B-CS-02 - Model how computer hardware and software work together as a system to accomplish tasks.

Lesson 6: Processing

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
CS - Computing Systems
  • 1B-CS-01 - Describe how internal and external parts of computing devices function to form a system.
  • 1B-CS-02 - Model how computer hardware and software work together as a system to accomplish tasks.

Lesson 7: Apps and Storage

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.

Lesson 8: Project - Propose an App

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
CS - Computing Systems
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.

Unit 2: Web Development

Lesson 1: Exploring Websites

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.

Lesson 2: Websites for Expression

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
IC - Impacts of Computing
  • 1B-IC-18 - Discuss computing technologies that have changed the world and express how those technologies influence, and are influenced by, cultural practices.

Lesson 3: Intro to HTML

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 1B-AP-11 - Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process.

Lesson 4: Headings

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 1B-AP-11 - Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process.
  • 1B-AP-15 - Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended.

Lesson 5: Digital Footprint

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
  • 2-IC-23 - Describe tradeoffs between allowing information to be public and keeping information private and secure.
NI - Networks & the Internet
  • 1B-NI-05 - Discuss real-world cybersecurity problems and how personal information can be protected.

Lesson 6: Lists

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 1B-AP-12 - Modify, remix or incorporate portions of an existing program into one's own work, to develop something new or add more advanced features.
  • 1B-AP-15 - Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended.

Lesson 7: Intellectual Property and Images

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 3A-AP-20 - Evaluate licenses that limit or restrict use of computational artifacts when using resources such as libraries.
IC - Impacts of Computing
  • 1B-IC-21 - Use public domain or creative commons media and refrain from copying or using material created by others without permission.
  • 2-IC-23 - Describe tradeoffs between allowing information to be public and keeping information private and secure.

Lesson 8: Clean Code and Debugging

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 9: Project - Multi-Page Websites

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
IC - Impacts of Computing
  • 1B-IC-21 - Use public domain or creative commons media and refrain from copying or using material created by others without permission.

Lesson 10: Styling Text with CSS

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 11: Styling Elements with CSS

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 12: Sources and Search Engines

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.
  • 2-IC-23 - Describe tradeoffs between allowing information to be public and keeping information private and secure.

Lesson 13: RGB Colors and Classes

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 14: Project - Final Personal Website

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Unit 3: Interactive Animations and Games

Lesson 1: Programming for Entertainment

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.

Lesson 2: Plotting Shapes

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.

Lesson 3: Drawing in Game Lab

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 4: Shapes and Randomization

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 5: Variables

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 6: Sprites

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 7: The Draw Loop

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 8: Counter Pattern Unplugged

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.

Lesson 9: Sprite Movement

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 10: Booleans Unplugged

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.

Lesson 11: Booleans and Conditionals

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 12: Conditionals and User Input

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 13: Other Forms of Input

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 14: Project - Interactive Card

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 15: Velocity

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 16: Collision Detection

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.

Lesson 17: Complex Sprite Movement

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 18: Collisions

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 19: Functions

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-14 - Create procedures with parameters to organize code and make it easier to reuse.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 20: The Game Design Process

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 21: Using the Game Design Process

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 22: Project - Design a Game

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Unit 4: The Design Process

Lesson 1: Analysis of Design

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.

Lesson 2: Understanding Your User

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.

Lesson 3: User-Centered Design Micro Activity

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

CS - Computing Systems
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.

Lesson 4: User Interfaces

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.

Lesson 5: Feedback and Testing

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
IC - Impacts of Computing
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 6: Identifying User Needs

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
IC - Impacts of Computing
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 7: Project - Paper Prototype

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.

Lesson 8: Designing Apps for Good

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.

Lesson 9: Market Research

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.

Lesson 10: Paper Prototypes

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 11: Prototype Testing

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
DA - Data & Analysis
  • 2-DA-08 - Collect data using computational tools and transform the data to make it more useful and reliable.
  • 2-DA-09 - Refine computational models based on the data they have generated.
IC - Impacts of Computing
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 12: Digital Design

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
IC - Impacts of Computing
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 13: Linking Screens

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-14 - Create procedures with parameters to organize code and make it easier to reuse.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
IC - Impacts of Computing
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 14: Testing the App

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
DA - Data & Analysis
  • 2-DA-08 - Collect data using computational tools and transform the data to make it more useful and reliable.
IC - Impacts of Computing
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 15: Improving and Iterating

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-14 - Create procedures with parameters to organize code and make it easier to reuse.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
DA - Data & Analysis
  • 2-DA-09 - Refine computational models based on the data they have generated.
IC - Impacts of Computing
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 16: Project - App Presentation

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
DA - Data & Analysis
  • 2-DA-09 - Refine computational models based on the data they have generated.
IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Unit 5: Data and Society

Lesson 1: Representation Matters

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-07 - Represent data using multiple encoding schemes.

Lesson 2: Patterns and Representation

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-07 - Represent data using multiple encoding schemes.

Lesson 3: ASCII and Binary Representation

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-07 - Represent data using multiple encoding schemes.

Lesson 4: Representing Images

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-07 - Represent data using multiple encoding schemes.

Lesson 5: Representing Numbers

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-07 - Represent data using multiple encoding schemes.

Lesson 6: Keeping Data Secret

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

NI - Networks & the Internet
  • 2-NI-05 - Explain how physical and digital security measures protect electronic information.
  • 2-NI-06 - Apply multiple methods of encryption to model the secure transmission of information.

Lesson 7: Combining Representations

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-07 - Represent data using multiple encoding schemes.

Lesson 8: Create a Representation

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
DA - Data & Analysis
  • 2-DA-07 - Represent data using multiple encoding schemes.

Lesson 9: Problem Solving and Data

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-08 - Collect data using computational tools and transform the data to make it more useful and reliable.

Lesson 10: Problem Solving with Big Data

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
  • 2-IC-23 - Describe tradeoffs between allowing information to be public and keeping information private and secure.

Lesson 11: Structuring Data

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-08 - Collect data using computational tools and transform the data to make it more useful and reliable.

Lesson 12: Making Decisions with Data

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

DA - Data & Analysis
  • 2-DA-08 - Collect data using computational tools and transform the data to make it more useful and reliable.

Lesson 13: Interpreting Data

Lesson 14: Automating Data Decisions

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
DA - Data & Analysis
  • 2-DA-08 - Collect data using computational tools and transform the data to make it more useful and reliable.
IC - Impacts of Computing
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.

Lesson 15: Project - Make a Recommendation

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
DA - Data & Analysis
  • 2-DA-08 - Collect data using computational tools and transform the data to make it more useful and reliable.
IC - Impacts of Computing
  • 2-IC-23 - Describe tradeoffs between allowing information to be public and keeping information private and secure.

Unit 6: Physical Computing

Lesson 1: Innovations in Computing

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

IC - Impacts of Computing
  • 2-IC-20 - Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.

Lesson 2: Designing Screens with Code

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.

Lesson 3: The Circuit Playground

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.

Lesson 4: Input Unplugged

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.

Lesson 5: Board Events

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.

Lesson 6: Getting Properties

Lesson 7: Analog Input

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.

Lesson 8: The Program Design Process

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-14 - Create procedures with parameters to organize code and make it easier to reuse.
  • 3A-AP-16 - Design and iteratively develop computational artifacts for practical intent, personal expression, or to address a societal issue by using events to initiate instructions.
CS - Computing Systems
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.

Lesson 9: Project: Make a Game

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.

Lesson 10: Arrays and Color LEDs

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.

Lesson 11: Making Music

Lesson 12: Arrays and For Loops

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-14 - Create procedures with parameters to organize code and make it easier to reuse.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.

Lesson 13: Accelerometer

Lesson 14: Functions with Parameters

Lesson 15: Circuits and Physical Prototypes

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-14 - Create procedures with parameters to organize code and make it easier to reuse.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.
IC - Impacts of Computing
  • 2-IC-21 - Discuss issues of bias and accessibility in the design of existing technologies.

Lesson 16: Project: Prototype an Innovation

Standards Alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
  • 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
  • 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
  • 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
  • 2-CS-03 - Systematically identify and fix problems with computing devices and their components.