Updating search results...

Code.org

Code.org® is a nonprofit dedicated to expanding access to computer science in schools and increasing participation by women and underrepresented youth. Our vision is that every student in every school has the opportunity to learn computer science, just like biology, chemistry or algebra. Code.org provides the leading curriculum for K-12 computer science in the largest school districts in the United States and Code.org also organizes the annual Hour of Code campaign which has engaged more than 15% of all students in the world. Code.org is supported by generous donors including Amazon, Facebook, Google, the Infosys Foundation, Microsoft, and many more.

352 affiliated resources

Search Resources

View
Selected filters:
CS Principles 2019-2020 4.9: Public Key Cryptography
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This is a big multi-part lesson that introduces the concept of public key cryptography which is an answer to the crucial question: *How can two people send encrypted messages back and forth over insecure channels (the Internet) without meeting ahead of time to agree on a secret key?* In a nutshell, there are two main principles we want students to understand:

1. The mechanics of communication with public key cryptography
2. The basic mathematical principles that make it possible

The lesson gets at these two core ideas through a deliberate chain of thought experiments, demonstrations, activities and widgets. All parts are building blocks that lead to deeper understanding of how it works.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.10: Building an App: Color Sleuth
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This lesson attempts to walk students through the iterative development process of building an app (basically) from scratch that involves the use of `if` statements. Following an imaginary conversation between two characters - Alexis and Michael - students follow the problem solving and program design decisions they make for each step of constructing the app. Along the way they decide when and how to break things down into functions, and of course discuss the logic necessary to make a simple game.

The last step - writing code that executes an end-of-game condition - students must do on their own. How they decide to use `if` statements to end the game will require some creativity. The suggested condition - first to score 10 points - is subtly tricky and can be written many different ways.

At the conclusion of the lesson there are three practice Create PT-style questions as well as resources explaining the connection between this lesson and the actual Create PT. Depending on how you use these materials they can easily add an additional day to this lesson.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.11: While Loops
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This lesson demonstrates how a slight manipulation of a conditional statement can allow for the creation of a new and powerful tool in constructing programs, a **while** loop. Students are introduced to a **while** loop by analyzing the flow chart of a conditional statement in which the "true" branch leads back to the original condition. Students design their own flowcharts to represent a real-world situation that could be represented as a **while** loop, and they learn how to recognize common looping structures, most notably infinite loops. Students then move to App Lab, creating a **while** loop that runs exactly some predetermined number of times. While learning about creating **while** loops, students will be introduced to many of the common mistakes early programmers make with **while** loops and will be asked to debug small programs. They finally progress to putting if statements inside a while loop to count the number of times an event occurs **while** repeating the same action. This activity will recall the need for counter variables and foreshadows their further use in the following lesson.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.12: Loops and Simulations
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

In this lesson, students gain more practice using **while** loops as they develop a simulation that repeatedly flips coins until certain conditions are met. The lesson begins with an unplugged activity in which students flip a coin until they get 5 heads in total, and then again until they get 3 heads in a row. They will then compete to predict the highest outcome in the class for each statistic. This activity motivates the programming component of the lesson in which students develop a program that allows them to simulate this experiment for higher numbers of heads and longer streaks.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.13: Introduction to Arrays
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This lesson introduces arrays as a means of storing lists of information within a program. The class begins by highlighting the difficulties that arise when trying to store lists of information in a variable. Students then watch a short video introducing arrays and a subset of the operations that can be performed with them. Students will work in Code Studio for the remainder of the class as they practice using arrays in their programs. At the conclusion of the sequence, students build a simple app which can be used to store and cycle through a list of their favorite things. In the next lesson, students will continue working with a version of this app that can display images and not just text strings.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.14: Building an App: Image Scroller
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

Students will extend the **My Favorite Things** app they built in the previous lesson so that it now manages and displays a collection of images and responds to key events. Students are introduced to the practice of refactoring code in order to keep programs consistent and remove redundancies when adding new functionality. As part of learning to use key events, students are shown that event handlers pass a parameter which contains additional information about the event. This lesson also serves as further practice at using arrays in programs.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.15: Processing Arrays
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This lesson will probably take two days to complete. It introduces students to algorithms that process lists of data. The students will do two unplugged activities related to algorithms and program some of them themselves in App Lab. The **for** loop is re-introduced to implement these algorithms because it’s straightforward to use to process all the elements of a list. The lesson begins with an unplugged activity in which students write an algorithm to find the minimum value in a hand of cards. Students then move to Code Studio to write programs that use loops and arrays. Students are shown how to use a **for** loop to visit every element in an array. Students use this pattern to process an array in increasingly complex ways. At the end of the progression, students will write functions which process arrays to find or alter information, including finding the minimum value - a problem they worked on in the unplugged activity. Finally, an unplugged activity has students reason about linear vs. binary search and attempt to write pseudocode for a binary search.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.16: Functions with Return Values
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

In this lesson students are introduced to the **return** command and learn to write their own functions that return values. Students first complete a simple unplugged activity based on the game **Go Fish** to introduce the concept of a return value. They will then complete a short sequence of exercises in Code Studio, which introduces preferred patterns for writing functions that return values. At the end of the sequence, students write and use functions that return values in a simple turtle driver app.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.17.4: Create Your Own App
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

To conclude their introduction to programming, students will design an app based off of one they have previously worked on in the programming unit. Students will choose the kinds of improvements they wish to make to a past project in order to show their ability to make abstractions and implement complex algorithms. The project concludes with reflection questions similar to those students will see on the AP® Create Performance Task. Students can either complete the project individually or with a partner. Every student will need a collaborative partner with whom they will give and receive feedback.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.17: Building an App: Canvas Painter
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

Students continue to practice working with arrays and are introduced to a new user interface element, the canvas. The canvas includes commands for drawing simple geometric shapes (circles, rectangles, lines) and also triggers mouse and key events like any other user interface element. Over the course of the lesson, students combine these features to make an app that allows a user to draw an image while recording every dot drawn on the canvas in an array. By processing this array in different ways, the app will allow students to redraw their image in different styles, like random, spray paint, and sketching. Along the way, students use their knowledge of functions with return values to make code which is easy to manage and reuse.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.1: Introduction to Event-Driven Programming
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

Students will be introduced to a new feature of App Lab: **Design Mode**. Design Mode allows students to easily design the User Interface (UI) of their apps using a drag-and-drop editor. Students learn how to create UI elements they have seen before such as images, text labels and buttons, but they will see many more options for styling these elements with colors, font sizes and so on. Students also learn how to add **event handlers** - code that listens for and responds to user-events. Students also explore some common errors that come up in event-driven programming and will learn some important skills for debugging programs, chief among them being responding to error messages. Students end the lesson by creating the foundation of a simple "chaser game" which they will add onto in the next lesson.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.2: Multi-Screen Apps
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

Students continue learning about Event Driven programming in this lesson by learning how to add multiple "screens" to an app and adding code to switch between them. More techniques of debugging are presented, namely using `console.log`, a command that allows them to print out text which the user cannot see. It is useful for displaying messages to yourself to figure out what is happening as your program runs. Students will end the lesson by creating an improved version of the “chaser” game which has multiple screens.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.3: Building an App: Multi-Screen App
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This lesson gives students time to familiarize themselves with the process of making event-driven apps before we move on to deeper content. They will design and create a (minimum) 4-screen app on a topic of their choosing. There are some other constraints on the project to help guide students in their thinking. Students are also encouraged to do independent work, but alongside a "coding buddy" or "thought partner" to be a help along the way.

**Note:** This activity **is not intended to be a Practice PT** but could be used similarly. The aim is to give an opportunity to get comfortable with Design Mode and the structure of event-driven programming in a creative way. Another goal is to intentionally build in an environment of informal collaboration, even when doing individual work. Suggestions for containing the scope of the project and amount of time allocated to it can be found in the lesson plan.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.4: Controlling Memory with Variables
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This lesson gets into the basic mechanics of working with variables in programs. The lesson shows students how to create and assign values to variables and navigates through a series of common misconceptions about variables and how they work. Along the way, the lesson tries to build up the student’s mental model of how computers and programs work, which is essential for being able to reason about programs.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.5: Building an App: Clicker Game
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

In this lesson, students add variables to two different exemplar apps to keep track of a score, or a count of some number of button clicks. The major topic is **variable scope** and understanding the differences, benefits, and drawbacks, of using global versus local variables. This lesson focuses more on using global variables, since in event-driven apps that’s what you need to keep track of data across multiple events.

The very basics of a **simple if statement** are also presented in this lesson, mostly to highlight the difference between the = and == operators. Finally, students are asked to apply what they’ve learned about variables, scope, and if statements, to make their own “clicker” game modeled after one of the exemplars they saw during the lesson.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.6: User Input and Strings
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

In this lesson, students are introduced to the string data type as a way of representing arbitrary sequences of ASCII characters. They will use strings to accept input from a user as they work on mastering two new UI elements, the text input and the text area. Students combine these skills to develop a simple Mad Libs® app.

_Mad Libs® is a trademark of the Penguin Group (USA) LLC., which does not sponsor, authorize or endorse this site._

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.7: If-statements Unplugged
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

We take a whole lesson to learn about `if` statements, what they are, the terminology around them, and what they have to do with "selection" in programs. Students trace simple robot programs on paper to develop a sense of how to read and reason about code with `if` statements in it. Students also try their hand at writing code by hand to handle a robot situation.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.8: Boolean Expressions and "if" Statements
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

In this lesson, students write `if` and `if-else` statements in JavaScript for the first time. The concepts of conditional execution should carry over from the previous lesson, leaving this lesson to get into the nitty gritty details of writing working code. Students will write code in a series of "toy" problems setup for them in App Lab that require students to do everything from debug common problems, write simple programs that output to the console, or implement the conditional logic into an existing app or game, like "Password Checker" or a simple Dice Game. The lesson ends with a problem requiring nested `if` statements to foreshadow the next lesson.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 5.9: "if-else-if" and Conditional Logic
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

In this lesson, students will be introduced to the boolean (logic) operators NOT, AND, and OR as tools for creating compound boolean conditions in if statements. Students will learn how to more efficiently express complex logic using AND and OR, rather than deeply nested or chained conditionals. Students will work through a worksheet that covers the basics and a few problems with evaluating logical expressions, then write code in App Lab to practice using && and || in if statements. Finally, students will improve the Movie Bot so it can respond to multiple keywords and provide recommendations based on both the genre and rating provided by the user.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019
CS Principles 2019-2020 6.1: Explore PT - Review the Task
Conditional Remix & Share Permitted
CC BY-NC-SA
Rating
0.0 stars

This lesson contains a series of activities you can use to help students familiarize themselves with Explore Performance Task, how it is scored, and some example tasks provided by the College Board.

Students review the Submission Requirements and Scoring Guidelines for the Explore PT. Subsequently they review three example scored Explore PT submissions with commentary to better understand how the Submission Requirements and Scoring Guidelines are used together. In a wrap-up conversation they identify a piece of advice, a "gotcha", and a remaining question they have about the Explore PT.

Note: Most the exemplar task, scores, and commentary on scoring shared in this lesson come directly from the College Board. Code.org's commentary is noted where applicable.

Subject:
Applied Science
Computer Science
Material Type:
Lesson Plan
Provider:
Code.org
Provider Set:
CS Principles 2019-2020
Date Added:
09/10/2019