Long-Range Plan · Full-Year · with Lesson Catalog
Code.org CS Discoveries (course csd-2026) mapped to the Montgomery County Public Schools 2026–2027 traditional calendar. Day-by-day pacing generated from live lesson durations, plus every lesson's overview, objectives, standards, agenda, and resources pulled from Code Studio.
| Unit | Lessons | Minutes | Days | CSTA | Culminating project |
|---|---|---|---|---|---|
| Unit 1 Problem Solving & Computing | 8 | 585m | ~13d | 11 | Project - Propose an App |
| Unit 2 Web Development | 21 | 1125m | ~25d | 21 | Project - Website for a Purpose |
| Unit 3b Interactive Animations & Games | 28 | 1530m | ~34d | 10 | Project - Design a Game |
| Unit 4 The Design Process | 21 | 1125m | ~25d | 15 | Project - App Presentation |
| Unit 5 Data & Society | 16 | 900m | ~20d | 11 | Project - Make a Recommendation |
| Unit 6b Creating Apps with Devices — micro:bit Option B · taught | 17 | 1305m | ~29d | 14 | Project - Prototype an Innovation |
| Unit 7 AI & Machine Learning optional | 22 | 1170m | ~26d | 31 | Project - Design an AI App |
| Taught path (micro:bit) | 111 | 6570m | ~146d | 36 | 7 culminating projects |
This lesson is a fun introduction to the open-ended, collaborative, and creative problem-solving students will be using over the rest of this unit and course. Students work in groups to design aluminum foil boats that will support as many pennies as possible. Groups have two rounds to work on their boats, with the goal of trying to hold more pennies than they did in round 1. The structure of the activity foreshadows different steps of the problem-solving process that students will be introduced to in more detail in the following lesson. At the end of the lesson, students reflect on their experiences with the activity and make connections to the types of problem-solving they will be doing for the rest of the course
Question of the Day: What can help us to work together and solve problems as a team?
Alternate versions of this lesson are also available.
For each group
For the teacher
This lesson introduces the formal problem-solving process that students will use over the course of the year, Define - Prepare - Try - Reflect. The lesson begins by anchoring the formal problem-solving process in some real-life experiences they already have solving problems by asking students to brainstorm all the different types of problems that they encounter in everyday life. Students are then shown the four steps of the problem-solving process and work together to relate these abstract steps to their actual experiences solving problems. First students relate these steps to the problem activities from the previous lesson, then a problem they are good at solving, then a problem they want to improve at solving. At the end of the lesson, the class collects a list of generally useful strategies for each step of the process to put on posters that will be used throughout the unit and year.
Question of the Day: What are some common steps we can use to solve many different types of problems?
For each student
For the class
For the Teacher
In this lesson, students apply the problem-solving process to three different problems in order to better understand the value of each step. They will solve a word search, arrange seating for a birthday party, and redesign a classroom. The problems grow increasingly complex and poorly defined to highlight how the problem-solving process is particularly helpful when tackling these types of problems. The lesson concludes with students reflecting on their experience with the problem-solving process. They will justify the inclusion of each step and will brainstorm questions or strategies that can help them better define open-ended problems, as this is often the most critical step.
This lesson will likely take two class periods or more to complete. The first two problems may fit into a single class period but the third will need to be moved to a second day.
Question of the Day: How can we apply the problem-solving process to many different kinds of problems?
Alternate versions of this lesson are also available.
Continuation — day 2 of 2.
In this lesson, students apply the problem-solving process to three different problems in order to better understand the value of each step. They will solve a word search, arrange seating for a birthday party, and redesign a classroom. The problems grow increasingly complex and poorly defined to highlight how the problem-solving process is particularly helpful when tackling these types of problems. The lesson concludes with students reflecting on their experience with the problem-solving process. They will justify the inclusion of each step and will brainstorm questions or strategies that can help them better define open-ended problems, as this is often the most critical step.
This lesson will likely take two class periods or more to complete. The first two problems may fit into a single class period but the third will need to be moved to a second day.
Question of the Day: How can we apply the problem-solving process to many different kinds of problems?
Alternate versions of this lesson are also available.
This lesson builds on the problem-solving theme of the earlier lessons and focuses on the specifics of how computing is used in problem-solving, starting with developing a preliminary definition of a computer. To begin the lesson, the class will brainstorm possible definitions for a computer and place the results of this brainstorm on the board. Next, students will work in groups to sort pictures into “is a computer” or “is not a computer” on poster paper. Groups will place their posters around the room and briefly explain their motivations for choosing some of their most difficult categorizations. The teacher will then introduce a definition of the computer and allow students to revise their posters according to the new definition.
Question of the Day: What is a computer?
For each group
For the teacher
This lesson introduces focuses on two of the features identified in the previous lesson, input and output, that can help classify devices as a computer and has students identify different methods of input or output in common apps. In this lesson, students consider how computers get and give information to the user through inputs and outputs. Students first consider what information they would need to solve a "thinking problem", then use that information to produce a recommendation. They then identify the inputs and outputs of that process. Afterward, students consider an app that engages in the same process and determine how that app inputs and outputs information. Last, they consider other types of inputs and outputs that computers can use to help solve problems.
Question of the Day: How do computers use input and output to get and give the information that they need to solve problems?
This lesson introduces the concept of processing within computational problem-solving. While this lesson focuses on four common types of processing - if/then (conditionals), finding a match (searching), counting, and comparing - students should understand that processing is whatever a computer does to turn inputs into outputs. Students are first introduced to the types of processing through several sample apps. They then investigate more apps to determine what sorts of processing each uses. They then think of their own app and decide what types of processing it would need to work. Finally, they brainstorm other types of processing that may be useful but were not included in the main lesson.
Question of the Day: What are the different ways computers can process information?
This lesson introduces the final component of the unit's model of computing: storage. After trying out an "outfit picker" app, students discuss what information should be stored in the app versus input every time the app is run. They then look at a series of apps and use their decisions about what should be stored to create guidelines for deciding what information to store. They then review the four components of this chapter's model of computing: input, output, storage, and processing. Afterward, they have one last opportunity to revise their decisions about which items should be classified as a "computer" from earlier in the chapter. The lesson ends with a reflection on their own app ideas and how storage could be used.
Question of the Day: Why is storage an important part of the computing process?
To conclude this unit, this project combines the two major themes of Unit 1, the problem-solving process and the input/output/store/process model of a computer, to have students identify real-world problems and find ways to use technology to help solve them. This project will be completed across multiple days and will result in students creating a poster of a proposed app they design to solve a real-world problem, highlighting the features of their app that they will present to their classmates. A project guide provides step-by-step instructions for students and helps them organize their thoughts. The project is designed to be completed in pairs though it can be completed individually.
Question of the Day: How can the IOSP model help us to design an app that solves a problem?
Continuation — day 2 of 5.
To conclude this unit, this project combines the two major themes of Unit 1, the problem-solving process and the input/output/store/process model of a computer, to have students identify real-world problems and find ways to use technology to help solve them. This project will be completed across multiple days and will result in students creating a poster of a proposed app they design to solve a real-world problem, highlighting the features of their app that they will present to their classmates. A project guide provides step-by-step instructions for students and helps them organize their thoughts. The project is designed to be completed in pairs though it can be completed individually.
Question of the Day: How can the IOSP model help us to design an app that solves a problem?
Continuation — day 3 of 5.
To conclude this unit, this project combines the two major themes of Unit 1, the problem-solving process and the input/output/store/process model of a computer, to have students identify real-world problems and find ways to use technology to help solve them. This project will be completed across multiple days and will result in students creating a poster of a proposed app they design to solve a real-world problem, highlighting the features of their app that they will present to their classmates. A project guide provides step-by-step instructions for students and helps them organize their thoughts. The project is designed to be completed in pairs though it can be completed individually.
Question of the Day: How can the IOSP model help us to design an app that solves a problem?
Continuation — day 4 of 5.
To conclude this unit, this project combines the two major themes of Unit 1, the problem-solving process and the input/output/store/process model of a computer, to have students identify real-world problems and find ways to use technology to help solve them. This project will be completed across multiple days and will result in students creating a poster of a proposed app they design to solve a real-world problem, highlighting the features of their app that they will present to their classmates. A project guide provides step-by-step instructions for students and helps them organize their thoughts. The project is designed to be completed in pairs though it can be completed individually.
Question of the Day: How can the IOSP model help us to design an app that solves a problem?
Continuation — day 5 of 5.
To conclude this unit, this project combines the two major themes of Unit 1, the problem-solving process and the input/output/store/process model of a computer, to have students identify real-world problems and find ways to use technology to help solve them. This project will be completed across multiple days and will result in students creating a poster of a proposed app they design to solve a real-world problem, highlighting the features of their app that they will present to their classmates. A project guide provides step-by-step instructions for students and helps them organize their thoughts. The project is designed to be completed in pairs though it can be completed individually.
Question of the Day: How can the IOSP model help us to design an app that solves a problem?
Question of the Day: How can we choose websites based on the needs of a user?
To kick off a unit devoted to group problem solving and developing websites for other users, students begin by investigating the design of different websites. Students look at a variety of websites and attempt to match each design with a potential user. Then students choose a user and attempt to prototype a website design for them on paper or in a digital template. To conclude the activity, students consider what it means to be a web designer and create resources for other users.
This lesson introduces many new concepts and tools to students: they are introduced to HTML, the Web Lab tool, and how to navigate lesson resources on Code.org in general. In this lesson, students are introduced to HTML as a solution to the problem of how to communicate both the content and structure of a website to a computer. The lesson begins with a brief unplugged activity demonstrating the challenges of effectively communicating the structure of a web page. Students then look at an exemplar HTML page in Web Lab and discuss with their classmates how HTML tags help solve this problem. Students then write their first HTML. A wrap-up discussion helps to solidify the understanding of content vs. structure that was developed throughout the lesson.
Question of the Day: How can we tell the computer both *what* to put on the web page, and *how* to organize it?
This lesson introduces the core practices of pair programming and debugging. In this lesson, students continue to use HTML to structure text on web pages, this time in pairs, with a focus on working together and debugging problems with their sites. Students learn how to use the different heading and list elements and practice using them to give their web pages more structure.
Question of the Day: How can we work together to fix problems with our websites?
Question of the Day: How can you make sure that your private information stays private?
In this lesson, students pause their own on developing web pages so they can develop an understanding of how personal information is surfaced on the internet, sometimes intentionally and sometimes unintentionally. Students look at several fictitious social media pages to see what they can learn about different people purely from publicly available information. They then reflect on what guidelines are appropriate for posting their own information online, especially as they prepare to create more personalized websites.
In this mini-project, students use what they have learned to create a web page for a user. Students begin their project by using the Problem Solving Process to help them design a web page for a user. As they determine what content to include on the web page for their user, they will identify which tags they will use to implement their design. Students then build their user’s web page in Web Lab. Optionally, after engaging in a formal feedback process, they may change their web pages based on feedback before reflecting on their process. The lesson also includes an optional review of the HTML students have learned before building the web page.
Question of the Day: How can I use HTML to design and build a web page for a user?
This lesson introduces CSS as a way to style elements on the page. Students learn the basic syntax for CSS rule-sets and then explore properties that impact HTML text elements. They work on an HTML page about Guinness World Record holders, adding their own style to the provided page. While only a few CSS properties are introduced in the core lesson, students are encouraged to use the optional activities at the end of the lesson to explore more ways that they can express themselves using CSS.
Question of the Day: How can we change the style of text on a web page?
Until this point, the only content that students have used on their web pages is their own, but in the next lesson, they will be adding images to their sites. Before they do so, they need to understand the rules governing how to legally use content they find on the web. Starting with a discussion of their personal opinions on how others should be allowed to use their work, the class explores the purpose and role of copyright for both creators and users of creative content. They then move on to an activity exploring the various Creative Commons licenses as a solution to the difficulty in dealing with copyright.
Question of the Day: What kind of rules protect everyone's rights when we use each other's content?
This lesson introduces images, which are different from earlier tags in that they are 'self-closing' and include attributes. Students should understand that these tags do not surround content in the same way as other tags. Students start the class by considering the ethical implications of using images on their websites, specifically in terms of intellectual property. They then learn how to add images to their web pages using the <img> tag and how to cite the image sources appropriately.
Question of the Day: How can we add images on our websites, while making sure we respect everyone's rights?
This lesson continues the introduction to CSS style properties, this time focusing more on non-text elements. Students begin this lesson by looking at a website about Desserts of the World. They investigate and modify the new CSS styles on this website, adding their own styles to the page. After working on the Desserts page, students apply their knowledge of new CSS properties to their personal websites.
Question of the Day: How can we style the images and layouts of our pages?
In this mini-project, students use what they have learned to style a web page for a user. Students begin their project using the Problem Solving Process to help them determine how they will style a web page for a user. Students then style their users' web pages in Web Lab. Optionally, after engaging in a formal feedback process, they may change their web pages based on feedback before reflecting on their process. The lesson also includes an optional review of the HTML and CSS students learned before styling the web page.
Question of the Day: How can I use CSS to style a web page for a user?
Up until this point, the only styling students have been able to do is styling by the element, which means that every element of a particular kind has the same style. This lesson expands on the CSS that students have already learned by introducing classes, which allow web developers to treat groups of elements they want to be styled differently than other elements of the same type. Students first investigate and modify classes on various pages, then create their own classes and use them to better control the appearance of their pages. They then reflect on how they could use this skill to improve their team websites.
Question of the Day: How can we create different styles for the same type of element?
*Note: Single elements can also be selected by id, but this type of selection is possible with a class applied only to that single element. Because id selection does not add any extra functionality, it is not taught in this course.*
This lesson introduces students to two new web development tools: div tags and Flexbox styling. This lesson introduces students to div tags to organize their HTML code into sections. They then learn about Flexbox and how it can be used with their div containers to style and position items. Students practice using Flexbox properties to control the layout of web pages.
Question of the Day: What are div tags and Flexbox and why are they important in web design?
This lesson introduces students to advanced Flexbox child properties including `order`, `align-self`, `flex-grow`, and `flex-shrink` through an interactive warm-up and the various level exercises. They’ll deepen their understanding of how these properties affect web page layouts and conclude with a creative group drawing game to reinforce their learning.
Question of the Day: How do Flexbox child properties affect the layout and organization of elements within a webpage?
In this chapter project, students use what they have learned to style and organize a web page for a user. Students begin their project by using the Problem Solving Process to help them determine how they will organize the content of a user’s web page. Students then use CSS classes and flexbox to organize their user’s web page in Web Lab. Optionally, after engaging in a formal feedback process, they may change their web pages based on feedback before reflecting on their process.
Question of the Day: How can I use CSS classes and Flexbox to organize webpage content for a user?
Continuation — day 2 of 2.
In this chapter project, students use what they have learned to style and organize a web page for a user. Students begin their project by using the Problem Solving Process to help them determine how they will organize the content of a user’s web page. Students then use CSS classes and flexbox to organize their user’s web page in Web Lab. Optionally, after engaging in a formal feedback process, they may change their web pages based on feedback before reflecting on their process.
Question of the Day: How can I use CSS classes and Flexbox to organize webpage content for a user?
This lesson explicitly addresses the challenges students may find working in a group and supports them in crafting a plan to overcome these challenges. Students work together to set group norms and brainstorm what features they would like their websites to have. The class starts by thinking of some popular teams in different contexts, then reflects on what makes teams successful. They then get into their own teams and make a plan for how they will interact and reach success in their own projects. Afterward, the teams begin to brainstorm ideas for their website project.
Question of the Day: How can we work together to make a great team?
This lesson encourages students to think more about their responsibilities as consumers of information and how to find relevant and trustworthy information online. After viewing and discussing a video about how search engines work, students will search for information relevant to their site. They'll need to analyze the sites they find for credibility to decide which are appropriate to use on their own website. By the end of this lesson, students should have developed strategies for determining which websites are more trustworthy and tie these strategies back to their own role as content producers by looking for ways to make their own sites appear more trustworthy.
Question of the Day: How do we find relevant and trustworthy information on the Internet?
This lesson will give students practice in using links and introduce them to good navigation practices for their sites. Students begin by looking online for the first web page and discussing how its use of links was what started the web. They then transition to Web Lab where they learn how to make their own links, as well as good conventions that make it easier for users to navigate on a page. Finally, they reflect on their group project and what their personal goals are for the final stretch.
Question of the Day: How can we combine several different web pages into one website?
This lesson introduces students to the dynamic world of CSS pseudo-classes. Students will learn about their role in enhancing web page interactivity and style. They will explore, practice, and apply various pseudo-classes like `link`, `visited`, `hover`, and `active`, understanding how these selectors can transform the user experience on websites.
Question of the Day: What is a CSS pseudo-class, and how does it change the way an element looks or behaves on a web page?
Students work in teams to plan out their websites and create a sketch of each page. They then download the media that they will need for their sites. At the end of the activity, they decide how the work will be distributed among team members and report whether the entire group agreed to the plan.
Question of the Day: How do we plan a web page as a group?
Continuation — day 2 of 2.
Students work in teams to plan out their websites and create a sketch of each page. They then download the media that they will need for their sites. At the end of the activity, they decide how the work will be distributed among team members and report whether the entire group agreed to the plan.
Question of the Day: How do we plan a web page as a group?
Teams have spent a lot of time throughout the chapter planning their websites. In this lesson, they are finally able to code their pages. Using the project guide, the team works together and individually to code all of the pages, then puts all of the work together into a single site.
Question of the Day: What skills and practices will help us work together to make a great website?
Continuation — day 2 of 2.
Teams have spent a lot of time throughout the chapter planning their websites. In this lesson, they are finally able to code their pages. Using the project guide, the team works together and individually to code all of the pages, then puts all of the work together into a single site.
Question of the Day: What skills and practices will help us work together to make a great website?
This lesson focuses on the value of peer feedback. Students first reflect on what they are proud of, and what they would like feedback on. Teams then work with peers to get that feedback through a structured process that includes the project rubric criteria. Afterward, students decide how they would like to respond to the feedback and put the finishing touches on their sites. After a final review of the rubric, they reflect on their process. To cap off the unit, they will share their projects and also an overview of the process they took to get to that final design.
Question of the Day: How can we use feedback to make our websites better?*
Continuation — day 2 of 2.
This lesson focuses on the value of peer feedback. Students first reflect on what they are proud of, and what they would like feedback on. Teams then work with peers to get that feedback through a structured process that includes the project rubric criteria. Afterward, students decide how they would like to respond to the feedback and put the finishing touches on their sites. After a final review of the rubric, they reflect on their process. To cap off the unit, they will share their projects and also an overview of the process they took to get to that final design.
Question of the Day: How can we use feedback to make our websites better?*
To kick off a unit devoted to problem-solving and developing animations and games, students begin by investigating the design of different animations and games. Students look at a variety of animations and games and attempt to match each design with a potential user. Then students choose a user and attempt to prototype an animation or game design for them on paper or in a digital template. To conclude the activity, students consider what it means to be an animation and game designer and create resources for other users.
Question of the Day: How can we design animations and games based on the needs of a user?
The primary purpose of this lesson is to introduce students to the coordinate system they will use in Game Lab. Students begin by exploring the challenges of communicating how to draw with shapes and then transition to using a tool that introduces how this problem is approached in Game Lab. The warm-up activity quickly demonstrates the challenges of communicating position without some shared reference point. In the main activity, students explore a Game Lab tool that allows students to interactively place shapes on Game Lab's 400 by 400 grid. They then take turns instructing a partner how to draw a hidden image using this tool, accounting for many challenges students will encounter when programming in Game Lab. Students optionally create their own images to communicate before a final debrief discussion.
Question of the Day: How can we clearly communicate how to draw something on a screen?
This lesson is designed to give students a chance to get used to the programming environment, as well as the basic sequencing and debugging that they will use throughout the unit. Students begin with an introduction to the GameLab interactive development environment (IDE), then learn the three commands ([`rect`(#4dd0e1)](/docs/gamelab/rect/), [`ellipse`(#4dd0e1)](/docs/gamelab/ellipse/), and [`fill`(#4dd0e1)](/docs/gamelab/fill/)) that they will need to code the same types of images that they created on paper in the previous lesson. Challenge levels provide a chance for students who have more programming experience to further explore Game Lab.
Question of the Day: How can we communicate to a computer how to draw shapes on the screen?
In this lesson, students continue to build skills and develop their familiarity with Game Lab by manipulating the width and height of the shapes they use to draw. The lesson kicks off with a discussion that connects expanded block functionality (e.g. different sized shapes) with the need for more block inputs, or "parameters". Students learn to draw with versions of [`ellipse()`(#4dd0e1)](/docs/gamelab/ellipse/) and [`rect()`(#4dd0e1)](/docs/gamelab/rect/) that include width and height parameters. They also learn to use the [`background()`(#4dd0e1)](/docs/gamelab/background/) block. Throughout the lesson, students will need to reason about the x-y coordinate plane, consider the order of their code, and slightly increase their programs' complexity.
Question of the Day: How can we use parameters to give the computer more specific instructions?
In this lesson, students learn how to use variables to label a value. Students begin the lesson with a very basic description of the purpose of a variable within the context of the storage component of the input-output-storage-processing model. Students then complete a level progression that reinforces the model of a variable as a way to label or name a number. Students should leave this lesson knowing that variables are a way to label a value in their programs so that they can be reused or referenced later. In the following lesson, students will be introduced to random numbers, in which they will see a more powerful use for variables, and in later lessons, students will continue to expand their understanding of variables and experience more advanced ways they can be used.
Question of the Day: How can we use variables to store information in our programs?
This lesson introduces randomness, which is important both as a way to make programs more interesting and also to motivate the use of variables. Students are introduced to the [`randomNumber()`(#FFB74D)](/docs/gamelab/randomNumber/) block and how it can be used to create new behaviors in their programs. They then learn how to update variables during a program. Combining all of these skills, students draw randomized images.
Question of the Day: How can we make our programs behave differently each time they are run?
After a quick review of the code they have learned so far, students are introduced to their first creative project of the unit. Using the problem-solving process as a model, students define the robot face that they want to create, prepare by thinking of the different code they will need, try their plan in Game Lab, then reflect on what they have created. They also have a chance to share their creations with their peers. The open-ended nature of this lesson also provides flexibility for the teacher to decide how long students should spend on their work, depending on the scheduling demands of the particular course implementation.
Question of the Day: How can we use shapes, variables, and randomness to express our creativity?
In order to create more interesting and detailed images, students are introduced to the sprite object which allows for one variable name to control both the shape and all its aspects. The lesson starts with a discussion of the various information that programs must keep track of, then presents sprites as a way to keep track of that information. Students then learn how to assign each sprite an image, which will greatly increase the complexity of what they can draw on the screen.
Question of the Day: How can we use sprites to help us keep track of lots of information in our programs?
In the last lesson, when students were introduced to sprites, they focused mainly on creating a sprite and assigning it an animation. This lesson starts to dig into what makes sprites such a powerful programming construct - that they have properties that can be modified as a program is _running_. This lays the foundation for much of what students will be doing in the rest of the unit in terms of accessing and manipulating sprite properties to create interesting behaviors in their programs. The lesson starts with a review of what a sprite is, then students move on to Game Lab to practice more with sprites, using their properties to change their appearance. They then reflect on the connections between properties and variables.
Question of the Day: How can we use sprite properties to change their appearance on the screen?
This lesson introduces Game Lab's text commands, giving students more practice using the coordinate plane and parameters. This is the last type of element that students will be placing on the screen - after this, students will focus on how they can control the movement and interactions of these elements. The lesson begins with asking students to caption a cartoon created in Game Lab. They then move on to Code Studio where they practice placing text on the screen and controlling other text properties, such as size. Students who complete the assessment early can go on to learn more challenging blocks related to text properties.
Question of the Day: How can we use text to improve our scenes and animations?
After a quick review of the code they have learned so far, students start working on their next creative project of the unit. Using the problem-solving process as a model again, students define the scene that they want to create, prepare by thinking of the different code they will need, try their plan in Game Lab, then reflect on what they have created. They also have a chance to share their creations with their peers. The open-ended nature of this lesson also provides flexibility for the teacher to decide how long students should spend on their work, depending on the scheduling demands of the particular course implementation.
Question of the Day: How can we use Game Lab to express our creativity?
In this lesson, students are introduced to the draw loop, one of the core programming paradigms in Game Lab. To begin the lesson students look at some physical flipbooks to see that having many frames with different images creates the impression of motion. Students then watch a video explaining how the draw loop in Game Lab helps to create this same impression in their programs. Students combine the draw loop with random numbers to manipulate some simple animations with dots and then with sprites. Students should leave the lesson understanding that the commands in the draw loop are called after all other code but are then called repeatedly to create animation. Students will have a chance to continue to develop an understanding of this behavior in the next two lessons, but laying a strong conceptual foundation in this lesson will serve them well for the rest of the unit.
Question of the Day: How can we animate our images in Game Lab?
This lesson builds on the draw loop that students learned previously to create programs with _purposeful_ motion. Students learn how to control sprite movement using a construct called the counter pattern, which incrementally changes a sprite's properties. Students first brainstorm different ways that they could animate sprites by controlling their properties, then explore the counter pattern in Code Studio. After examining working code, students try using the counter pattern to create various types of sprite movements. The skills that students build in this lesson lay the foundation for all of the animations and games that they will make throughout the rest of the unit.
Question of the Day: How can we control sprite movement in Game Lab?
This lesson is a chance for students to get more creative with what they have learned as students are asked to combine different methods that they have learned to create an animated scene. Students first review the types of movement and animation that they have learned and brainstorm what types of scenes might need that movement. They then begin to plan out their own animated scenes, which they create in Game Lab.
Question of the Day: How can we combine different programming patterns to make a complete animation?
This lesson introduces booleans and conditionals, which allow a program to run differently depending on whether a condition is true. Students start by playing a short game in which they respond according to whether particular conditions are met. They then move to Code Studio, where they learn how the computer evaluates Boolean expressions, and how they can be used to structure a program.
Question of the Day: How can programs react to changes as they are running?
One common way conditionals are used is to check for different types of user input, especially key presses. Following the introduction to booleans and _if_ statements in the previous lesson, students are introduced to a new block called [`keyDown()`(#fff176)](/docs/gamelab/keyDown/) which returns a boolean and can be used in conditionals statements to move sprites around the screen. By the end of this lesson, students will have written programs that take keyboard input from the user to control sprites on the screen.
Question of the Day: How can our programs react to user input?
In this lesson, students continue to explore ways to use conditional statements to take user input - this time with the mouse. They will also expand their understanding of conditionals to include _else_, which allows for the computer to run a certain section of code when a condition is true, and a different section of code when it is not. This concept is introduced alongside several new mouse input commands, allowing students to gradually build up programs that use input in different ways.
Question of the Day: What are more ways that the computer can react to user input?
This end-of-chapter assessment is a good place for students to bring together all the pieces they have learned (drawing, variables, sprites, images, conditionals, user input) in one place. In this project, students plan for and develop an interactive greeting card using all of the programming techniques they've learned to this point. Giving students the opportunity to really be creative after learning all these new concepts will help to engage them further as they head into Chapter 2.
Question of the Day: What skills and practices are important when creating an interactive program?
Continuation — day 2 of 2.
This end-of-chapter assessment is a good place for students to bring together all the pieces they have learned (drawing, variables, sprites, images, conditionals, user input) in one place. In this project, students plan for and develop an interactive greeting card using all of the programming techniques they've learned to this point. Giving students the opportunity to really be creative after learning all these new concepts will help to engage them further as they head into Chapter 2.
Question of the Day: What skills and practices are important when creating an interactive program?
This lesson launches a major theme of the chapter: that complex behavior can be represented in simpler ways to make it easier to write and reason about code. After a brief review of how they used the counter pattern to move sprites in previous lessons, students are introduced to the idea of hiding those patterns in a single [`velocity`(#f78183)](/docs/ide/gamelab/expressions/velocityX) block. Students then head to Code Studio to try out new blocks that set a sprite's velocity directly, and look at various ways that they are able to code more complex behaviors in their sprites. Over the next several lessons, students will see how this method of managing complexity allows them to produce more interesting sprite behaviors.
Question of the Day: How can programming languages hide complicated patterns so that it is easier to program?
This lesson formally introduces the use of abstractions, simple ways of representing underlying complexity. In the last lesson, students were exposed to the idea of using one block to represent complex code. Working in pairs, students further explore this idea in the context of the intentionally complex mathematical challenge of determining whether two sprites are touching. Students then use a single block, the [`isTouching()`(#f78183)](/docs/gamelab/isTouching/) block, to represent this complexity and to create different effects when sprites collide. By the end of the lesson, students should understand that by using a single block to represent this complexity, it becomes much easier to write and reason about code and appreciate the value of using abstractions.
Question of the Day: How can programming help make complicated problems more simple?
This lesson is another chance for students to get more creative with what they have learned. Students use what they have learned about collision detection and setting velocity to create a simple side-scroller game. After looking at a sample side-scroller game, students brainstorm what sort of side-scroller they would like to make, then use a structured process to program the game in Code Studio. This lesson can be shortened or lengthened depending on time constraints.
Question of the Day: How can the new types of sprite movement and collision detection be used to create a game?
This lesson does not introduce any new blocks and in fact, only uses patterns students have seen in Chapter 1 and demonstrates how combining these patterns, in particular the abstractions students learned in the previous two lessons, allows them to build new behaviors for their sprites. Specifically, this lesson has students learn how to combine the velocity properties of sprites with the counter pattern to create more complex sprite movement. After reviewing the two concepts, they explore various scenarios in which velocity is used in the counter pattern and observe the different types of movement that result, such as simulating gravity. They then reflect on how they were able to get new behaviors by combining blocks and patterns that they already knew.
Question of the Day: How can previous blocks be combined in new patterns to make interesting movements?
This lesson introduces collisions, another useful abstraction that will allow students to manipulate their sprites in entirely new ways. After a brief review of how they used the [`isTouching`(#f78183)](/docs/gamelab/isTouching/) block, students brainstorm other ways that two sprites could interact. They then use [`isTouching`(#f78183)](/docs/gamelab/isTouching/) to make one sprite push another across the screen before practicing with the four collision blocks ([`collide`(#f78183)](/docs/gamelab/collide/), [`displace`(#f78183)](/docs/gamelab/displace/), [`bounce`(#f78183)](/docs/gamelab/bounce/), and [`bounceOff`(#f78183)](/docs/gamelab/bounceOff/)). This is the last time they will learn a new sprite behavior, and following this lesson students will transition to focusing on how they organize their increasingly complex code.
Question of the Day: How can programmers build on abstractions to create further abstractions?
This lesson is another chance for students to get more creative with what they have learned. Students use what they have learned about simulating gravity and the different types of collisions to create simple flyer games. After looking at a sample flyer game, students brainstorm what sort of flyer games they would like, then use a structured process to program the game in Code Studio.
Question of the Day: How can the new types of collisions and modeling movement be used to create a game?
In previous lessons, students have learned to use a number of abstractions in their programs which have allowed them to build much more complex programs while ignoring the details of how that behavior is created. In this lesson, students learn to build abstractions of their own by creating functions that will serve to organize their code, make it more readable, and remove repeated blocks of code. Students first think about what sorts of new blocks they would like in Game Lab, and what code those blocks would contain inside. Afterward, students learn to create functions in Game Lab. They will use functions to remove long blocks of code from their draw loop and to replace repeated pieces of code with a single function.
Question of the Day: How can programmers use functions to create their own abstractions?
This lesson introduces students to the process they will use to design games for the remainder of the unit which is centered around a project guide that asks students to define their sprites, variables, and functions _before_ they begin programming their game. Students begin by playing a game on Game Lab where the code is hidden, discussing what they think the sprites, variables, and functions would need to be to make the game. For the purposes of heavily scaffolding the software development process, students are then given a completed project guide that provides starter code and shows one way to implement the game. Students are then walked through this implementation process through a series of levels and have an opportunity to make improvements to the game to make it their own in the final level. In the subsequent lessons, students will need to complete a greater portion of the guide independently, and for the final project, they will follow this process largely independently.
Question of the Day: How does having a plan help to make a large project easier?
In this multi-day lesson, students use the problem-solving process from Unit 1 to create a platform jumper game. This lesson also builds on the use of the Project Guide in the previous lesson by having students complete more of this project guide independently before using it to build a game. Students begin the lesson by looking at an example of a platform jumper, then define what their games will look like. Next, they use a structured process to plan the backgrounds, variables, sprites, and functions they will need to implement their game. After writing the code for the game, students will reflect on how the game could be improved, and implement those changes.
Question of the Day: How can the problem-solving process help programmers to manage large projects?
Continuation — day 2 of 2.
In this multi-day lesson, students use the problem-solving process from Unit 1 to create a platform jumper game. This lesson also builds on the use of the Project Guide in the previous lesson by having students complete more of this project guide independently before using it to build a game. Students begin the lesson by looking at an example of a platform jumper, then define what their games will look like. Next, they use a structured process to plan the backgrounds, variables, sprites, and functions they will need to implement their game. After writing the code for the game, students will reflect on how the game could be improved, and implement those changes.
Question of the Day: How can the problem-solving process help programmers to manage large projects?
Students will plan and build their own game using the project guide from the previous two lessons. Working individually or in pairs, students will first decide on the type of game they'd like to build, taking as inspiration a set of sample games. They will then complete a blank project guide where they will describe the game's behavior and scope out the variables, sprites, and functions they'll need to build. In Code Studio, a series of levels prompts them on a general sequence they can use to implement this plan. Partway through the process, students will share their projects for peer review and will incorporate feedback as they finish their game. At the end of the lesson, students will share their completed games with their classmates. This project will span multiple classes and can easily take anywhere from 3-5 class periods.
Question of the Day: How can the five CS practices (problem-solving, persistence, communication, collaboration, and creativity) help programmers to complete large projects?
Continuation — day 2 of 5.
Students will plan and build their own game using the project guide from the previous two lessons. Working individually or in pairs, students will first decide on the type of game they'd like to build, taking as inspiration a set of sample games. They will then complete a blank project guide where they will describe the game's behavior and scope out the variables, sprites, and functions they'll need to build. In Code Studio, a series of levels prompts them on a general sequence they can use to implement this plan. Partway through the process, students will share their projects for peer review and will incorporate feedback as they finish their game. At the end of the lesson, students will share their completed games with their classmates. This project will span multiple classes and can easily take anywhere from 3-5 class periods.
Question of the Day: How can the five CS practices (problem-solving, persistence, communication, collaboration, and creativity) help programmers to complete large projects?
Continuation — day 3 of 5.
Students will plan and build their own game using the project guide from the previous two lessons. Working individually or in pairs, students will first decide on the type of game they'd like to build, taking as inspiration a set of sample games. They will then complete a blank project guide where they will describe the game's behavior and scope out the variables, sprites, and functions they'll need to build. In Code Studio, a series of levels prompts them on a general sequence they can use to implement this plan. Partway through the process, students will share their projects for peer review and will incorporate feedback as they finish their game. At the end of the lesson, students will share their completed games with their classmates. This project will span multiple classes and can easily take anywhere from 3-5 class periods.
Question of the Day: How can the five CS practices (problem-solving, persistence, communication, collaboration, and creativity) help programmers to complete large projects?
Continuation — day 4 of 5.
Students will plan and build their own game using the project guide from the previous two lessons. Working individually or in pairs, students will first decide on the type of game they'd like to build, taking as inspiration a set of sample games. They will then complete a blank project guide where they will describe the game's behavior and scope out the variables, sprites, and functions they'll need to build. In Code Studio, a series of levels prompts them on a general sequence they can use to implement this plan. Partway through the process, students will share their projects for peer review and will incorporate feedback as they finish their game. At the end of the lesson, students will share their completed games with their classmates. This project will span multiple classes and can easily take anywhere from 3-5 class periods.
Question of the Day: How can the five CS practices (problem-solving, persistence, communication, collaboration, and creativity) help programmers to complete large projects?
Continuation — day 5 of 5.
Students will plan and build their own game using the project guide from the previous two lessons. Working individually or in pairs, students will first decide on the type of game they'd like to build, taking as inspiration a set of sample games. They will then complete a blank project guide where they will describe the game's behavior and scope out the variables, sprites, and functions they'll need to build. In Code Studio, a series of levels prompts them on a general sequence they can use to implement this plan. Partway through the process, students will share their projects for peer review and will incorporate feedback as they finish their game. At the end of the lesson, students will share their completed games with their classmates. This project will span multiple classes and can easily take anywhere from 3-5 class periods.
Question of the Day: How can the five CS practices (problem-solving, persistence, communication, collaboration, and creativity) help programmers to complete large projects?
To kick off a unit devoted to group problem-solving and developing products for other users, students begin by investigating the design of various shoes. We are purposefully starting out by looking at non-technical objects to encourage students to think more broadly about what it means to consider the end-user of a product before honing in on how it specifically applies to software design. Students begin by looking at a variety of shoes and attempting to match each shoe with a potential user. Students also provide feedback on these designs, using an “I Like…” / “I Wish…” / “I Wonder…” structure that will be repeated throughout the unit. To conclude the activity, students are asked to propose some changes to one set of shoes that would make it more useful or usable.
Question of the Day: How can we choose products based on the needs of a user?
This lesson builds on the previous by asking students to not only consider that there _is_ a user that products are designed for, but also empathize with those potential users since designers need to understand their users' needs in order to create useful products. This lesson encourages students to think about how to design for another person by role-playing as someone else using a user profile and reacting as that user to a series of products. Each student is assigned a user profile describing a person, which they then use to choose appropriate products, critique product design, and suggest improvements to design.
Question of the Day: How can we make sure a product is meeting the needs of a user?
This is the first part of a two-day lesson where students are guided through an abbreviated version of the design process they will be seeing throughout this unit. This lesson focuses on the Define and Prepare steps of the process. Students first brainstorm a list of potential users of smart clothing. As a class, they then group these ideas into broad categories and each group will choose one category of user. Groups repeat this process to brainstorm the needs or concerns of their user, eventually categorizing these needs and choosing one to focus on. In the next lesson, students will complete the Try and Reflect steps of the design process.
The activity in this lesson is an adaptation of the Design Charrette from the University of Washington.
Question of the Day: How can we design for people other than ourselves?
This is the second part of a two-day lesson where students are guided through an abbreviated version of the design process they will be seeing throughout this unit. Yesterday students completed the Define and Prepare steps of the design process. Today, they complete the Try and Reflect portions. Students continue their work from yesterday by designing a piece of smart clothing, using the specific needs and concerns they brainstormed to guide their decision-making. Students have a chance to share their decision-making process and get feedback on how well their product addresses the user needs they selected.
Question of the Day: How can we design a product to meet a user's needs?
Following the mini-design project, students look towards the next phase of design - prototyping a product that attempts to address user needs. In teams, students examine a paper prototype for a chat app called "Txt Ur Grndkdz". Through using this paper prototype, students get a chance to see how a simple paper prototype can be used to quickly test ideas and assumptions before we ever get to the computer. This prototype will also serve as the context around which students will start to parse and organize feedback from a wide variety of users. After "using" the provided prototype students begin to identify ways to improve the next iteration.
Question of the Day: How can we test an app to make sure it meets a user's needs?
In this lesson, students use feedback from "users" of the paper-prototyped app from the previous lesson in order to develop improvements to the user interface of that paper prototype. The lesson begins with a reflection on the fact that designers need to translate human needs with technology into changes to the user interface or experience. Students are then given a collection of feedback and requests from users of the app from the previous lesson. In groups, students categorize the feedback and identify ways the needs expressed in the feedback could be met by changes to the interface of the app. Then in groups students will implement some of these changes to meet one of the needs they identified.
Question of the Day: How can we use feedback to improve an app?
In previous lessons, needs & interests have been presented more explicitly to students. In this lesson, they have the task of extracting that information from a user interview, which motivates the app they will create. Students begin by first interpreting user interviews to determine the needs & interests of a user. They then speculate on the barriers these users are facing or the opportunities that are available for each user. In a group, they share these barriers & opportunities and brainstorm different apps that could be used to address these issues. By the end of the lesson, students will have decided on an app idea that addresses a barrier or opportunity for a user.
Question of the Day: How can user interviews help us create apps to meet the needs of a user?
The focus of this project is on the design process, especially empathizing with their user and the testing & feedback steps of the app design process. Based on user interviews from the previous lesson, each student comes up with an idea for an app that will address their user's problem. Students then get to create their own paper prototype of their app ideas by drawing "screens" on individual notecards. A project guide directs students through the process including building the paper prototype and testing it with their user to see if their assumptions about the user interfaces they created are accurate.
This is a two-day lesson, with specific timings outlined in the lesson plan below.
Question of the Day: How can I develop an app prototype for a user?
Continuation — day 2 of 2.
The focus of this project is on the design process, especially empathizing with their user and the testing & feedback steps of the app design process. Based on user interviews from the previous lesson, each student comes up with an idea for an app that will address their user's problem. Students then get to create their own paper prototype of their app ideas by drawing "screens" on individual notecards. A project guide directs students through the process including building the paper prototype and testing it with their user to see if their assumptions about the user interfaces they created are accurate.
This is a two-day lesson, with specific timings outlined in the lesson plan below.
Question of the Day: How can I develop an app prototype for a user?
This lesson lays the foundation for the project that will last the remainder of the unit. Students first explore a number of apps designed for social impact that have been created by other students. Students form project teams and lay out a contract for how the team will function throughout the development of their app. Finally, they brainstorm a team name, a topic for their app, and potential users. *Teachers can choose to make this lesson pack a bigger punch if they find examples (even those from their own previous classes) that demonstrate local examples of students designing apps for social good.*
Question of the Day: What is an App for Good we want to create?
In this lesson students research apps similar to the one they intend on creating to better understand the needs of their users. Students work within their teams to search the Internet for other apps, then evaluate the ones they find interesting. By the end of the lesson, each team will have a clearer idea about the type of app they want to create and further refine who their target users are. Each team will maintain a list of citations for all the apps they examined for use in their final presentation.
Question of the Day: How can we use existing apps as inspiration for our own apps?
This lesson helps narrow the scope of the types of design elements students can include in their apps since up until now, students have explored and brainstormed apps with a variety of functionality - they may have discovered apps that use maps, or connect to social media, or access data on your phone. However, students will eventually be prototyping these apps in App Lab, so they will be in better shape if their ideas align with the kinds of apps that can be made using AppLab’s tools. Today focuses on having teams look at several example apps made in AppLab and identifying the components of the user interface. They then make a plan for which features could use which components in their app.
Question of the Day: What user interface elements will be useful for our app?
This lesson kicks off the actual design phase of this project. Students work in their teams to create paper prototypes for the apps they’ve been developing. They begin by making a plan for each screen, then assigning different team members to work on each screen so the task can be completed in time. They can use 3x5 index cards to develop their paper prototypes or the Paper Prototype template.
Question of the Day: How can we build a paper prototype for our app?
The primary purpose of developing paper prototypes is that they allow for quick testing and iteration before any code is written. This lesson is focused on giving teams a chance to test their prototypes and gut-check assumptions about how the app should be laid out and navigated before moving to App Lab. Teams develop a plan to test with users before running prototype tests with multiple other students in the class (and potentially outside the class). In order to test the prototype with the users, the students will have to assign roles in the testing (the “narrator”, the “computer” and the “observers”) as well as have some questions prepared for the user to answer after the test is complete.
Question of the Day: How does our prototype work when tested by real users?
Students are introduced to the App Lab programming environment that they will use to build their apps. Students work through a progression of skill-building levels to learn how to use the drag-and-drop design mode of App Lab. Students will build up an exemplar app screen and end the lesson by making a plan to adapt one of their Paper Prototype screens into App Lab, focusing on having unique IDs for each element. In tomorrow’s lesson, they will build a screen from their paper prototype, incorporating the feedback from yesterday’s lesson.
Question of the Day: How can we use App Lab and Design Mode to create apps?
Having collaboratively developed a paper prototype for their apps, groups now divide and conquer to begin work on an interactive digital version based on the paper prototype. Using the drag-and-drop design mode of App Lab, students individually work through a progression of skill-building levels to learn how to build digital versions of a paper prototype. From there, each group member builds out at least one page of their app in App Lab, to be later combined into a single app.
Question of the Day: How can I design a digital prototype from a paper prototype?
In this lesson, students learn how to add screens to their apps, how to import screens created by other students, and how to program events to navigate between screens. Students learn basic event-driven programming by building up the model app that they started in the previous lesson. At the end of the lesson, students make a plan for how they will stay organized when importing each other’s screens in tomorrow’s lesson.
Question of the Day: How can I use events to create an app?
In this lesson, teams combine their digital prototype screens into a single app, which they can then link together using code. They share their project’s import URLs with each other, then import each teammate’s screen into their own app. Each student works independently to add events to their code to link the screens together, completing their digital prototype.
Question of the Day: How can I combine screens to create a complete digital prototype?
By now students should be fairly practiced at testing with users but this time around, the role of the computer is actually done by the computer! This means that the team running the test needs to focus their energy on carefully watching what the user does, and encourage the user to say aloud what they are experiencing. The primary purpose of this lesson is to have the team actually test the app with other people, preferably from the target audience the app is intended for, or from different teams in the class while observers from the team will record the results. As with testing the paper prototypes, teams will start by planning for the specific scenarios before running and observing tests.
Question of the Day: How does our digital prototype work when tested by real users?
Teams have at this point developed an app prototype that has gone through multiple iterations and rounds of user testing. With the information and guidance gained from the last round of user testing, each student has the opportunity to plan for and implement improvements (which could be adding programmatic functionality, a more eye-catching design, more informative text copy, better uniformity of iconography, or any number of other non-programming related features) to the team app. Depending on the time you have available, and student interest, you can run the cycle of testing and iteration as many times as you see fit.
Question of the Day: How can we create a plan to address bugs and features in our prototype?
Teams make a decision about how they will incorporate updates to their app, then they begin updating their app based on their post-its from yesterday’s lesson. They use a “To Do / Doing / Done” chart to organize their work and track their progress. Teams spend the majority of the class working on updating their app, with time at the end to re-combine into a single app if necessary.
Question of the Day: How can I track my work while we make updates to our app?
At this point, teams have researched a topic of personal and social importance, developed and tested both a paper prototype and a digital prototype, and iterated on the initial app to incorporate new features and bug fixes. Now is the time for them to review what they have done and pull together a coherent presentation to not only demonstrate their process of creation, but to also acknowledge the research, design, testing, and iteration that teams have gone through. Using the provided presentation template, teams prepare to present their process of app development, including the problem they set out to solve, the ways in which they've incorporated feedback from testing, and their plans for the future.
Question of the Day: How can I present the steps in our design process to people outside of our team?
Continuation — day 2 of 4.
At this point, teams have researched a topic of personal and social importance, developed and tested both a paper prototype and a digital prototype, and iterated on the initial app to incorporate new features and bug fixes. Now is the time for them to review what they have done and pull together a coherent presentation to not only demonstrate their process of creation, but to also acknowledge the research, design, testing, and iteration that teams have gone through. Using the provided presentation template, teams prepare to present their process of app development, including the problem they set out to solve, the ways in which they've incorporated feedback from testing, and their plans for the future.
Question of the Day: How can I present the steps in our design process to people outside of our team?
Continuation — day 3 of 4.
At this point, teams have researched a topic of personal and social importance, developed and tested both a paper prototype and a digital prototype, and iterated on the initial app to incorporate new features and bug fixes. Now is the time for them to review what they have done and pull together a coherent presentation to not only demonstrate their process of creation, but to also acknowledge the research, design, testing, and iteration that teams have gone through. Using the provided presentation template, teams prepare to present their process of app development, including the problem they set out to solve, the ways in which they've incorporated feedback from testing, and their plans for the future.
Question of the Day: How can I present the steps in our design process to people outside of our team?
Continuation — day 4 of 4.
At this point, teams have researched a topic of personal and social importance, developed and tested both a paper prototype and a digital prototype, and iterated on the initial app to incorporate new features and bug fixes. Now is the time for them to review what they have done and pull together a coherent presentation to not only demonstrate their process of creation, but to also acknowledge the research, design, testing, and iteration that teams have gone through. Using the provided presentation template, teams prepare to present their process of app development, including the problem they set out to solve, the ways in which they've incorporated feedback from testing, and their plans for the future.
Question of the Day: How can I present the steps in our design process to people outside of our team?
In Chapter 1 of this unit, students learn the different representation systems that computers use to represent information. In this first lesson, students get an overview of what data is and how it is used to solve problems. Students start off with a brief discussion to come to a common understanding of data. They then split into groups and use a data set to make a series of meal recommendations for people with various criteria. Each group has the choices of meals represented in a different way (pictures, recipes, menu, nutrition) that gives an advantage for one of the recommendations. Afterward, groups compare their responses and discuss how the different representations of the meal data affected how the students were able to solve the different problems and see that the same objects can be represented in a number of different ways.
Question of the Day: How does data affect decisions we make every day?
In this lesson, students get to explore for themselves the qualities of a good system for representing information by creating their own system for representing information. They begin by brainstorming all the different systems they already use to represent yes-no responses and then move on to create a system that can represent any letter in the alphabet using only a single stack of cards. The cards used have one of 6 different possible drawings (6 animals, 6 colors, etc.) and so to represent the entire alphabet students will need to work with their groups to use patterns of multiple cards to represent each letter. Students create messages with their systems and exchange them with other groups to ensure the system worked as intended. In the wrap-up discussion, the class reviews the pros and cons of the different systems, discussing commonalities between working systems and recognizing that there are many possible solutions to this problem and what's important is that everyone uses the same arbitrary system to communicate.
Question of the Day: How can we create a system for representing information?
This lesson is an opportunity to make some real-world connections from the previous lesson and review some of the concepts students saw in that activity. Students are formally introduced to the concept of binary, learn what a bit of information is, and get practice using a binary system and ASCII, a system for encoding information. At the beginning of the lesson, the teacher introduces the fact that computers must represent information using either "on" or "off". Then students are introduced to the ASCII system for representing text using binary symbols. Students practice using this system before encoding their own message using ASCII. At the end of the lesson, a debrief conversation helps synthesize the key learning objectives of the activity.
Question of the Day: What system do computers use to represent letters and words?
In this lesson, students learn how computers represent images. To begin the lesson they consider the challenge of turning all the complexity of vision into a binary pattern. Through a series of images showing how this transformation is made, students are introduced to the concept of splitting images into squares or "pixels" which can then be turned on or off individually to make the entire image. Students then do a short set of challenges using the Pixelation Widget in order to draw black and white images. Puzzles are designed to call out some of the challenges of representing images in this way. In the wrap-up, students make connections between the system for representing images and the system for representing text they learned in the previous lesson.
Question of the Day: What system do computers use to represent images?
In this lesson, students learn how to use the binary system to represent integers. With a set of cards that represent the place values in a binary (base-2) number system by a collection of dots, students turn bits "on" or "off" by turning cards face up and face down, then observe the numbers that result from these different patterns. Eventually, students extend the pattern to a generic 4-bit system.
Question of the Day: What system do computers use to represent numbers?
In this lesson, students use all three types of binary representation systems (ASCII characters, binary numbers, and images) to decode information in a record. After seeing a series of bits and being asked to decode them, students are introduced to the idea that in order to understand binary information, they must understand both the system that is being used and the meaning of the information encoded. They then decode a record representing a pet based on a given structure.
Question of the Day: How do computers tell the difference between binary codes for letters, numbers, or images?
As students have been encoding and decoding data, they have not been worried about securing the data that they are using even when that information has been highly personal or sensitive (such as addresses or phone numbers). In this lesson, they continue to explore how data is represented in a punchcard and begin to think about how they can ensure that only the intended recipient can read the data that they send. Once students understand the reasons for protecting data, they learn a binary encryption system that lets them encrypt and decrypt data in their punchcards, and eventually, they are able to send secret messages to one another using this method. The class concludes with a discussion on the importance of protecting our information and how encryption is one way we can accomplish this.
Question of the Day: How can we keep data secret and protect it from misuse?
The project serves as a cumulative project for the chapter, bringing together the different representation systems students have learned to design a structure that represents their perfect day. Students will first write a short description of their perfect day and then review with a partner to identify the key pieces of information they think a computer could capture. As a class, students will decide how a punch card of bytes of information will be interpreted to represent those pieces of information. Students will then use the ASCII, binary number, and image formats they have learned to represent their perfect days and then trade punch cards and try to decode what the other student's perfect day is like. This lesson forces students to grapple with some of the challenges of representing information in a computer since computers are good at representing _some_ kinds of information like numbers or characters, but this forces students to represent information in ways that might not always capture the full analog experience of an object or event.
Question of the Day: How can I represent complex information using binary systems?
In this lesson, students use the problem solving process from earlier in the course to solve a data problem. After reviewing the process, the class is presented with a decision: whether a city should build a library, pet shelter, or fire department. Students work in teams to collect information on the Internet to help them decide what should be built, then use this information to build an argument that will convince the city council of their choice. They then map what they have done to the problem solving process that they have been using throughout the course, comparing the general problem solving process to its specific application to data problems.
Question of the Day: How can we use data to solve problems in our community?
In this lesson, students go further into the collection and interpretation of data, including cleaning and visualizing data. Students first look at how presenting data in different ways can help people to understand it better, and they then create visualizations of their own data. Using the results of a preferred pizza topping survey, students must decide what to do with data that does not easily fit into the visualization scheme that they have chosen. Finally, students discuss which parts of this process can be automated by a computer and which need a human to make decisions.
Question of the Day: how can we make it easier for computers to process data?
Students begin the lesson by looking at a cake preference survey that allows respondents to specify both a cake and an icing flavor. They discuss how knowing the relationship between cake and icing preference helps them better decide which combination to recommend. They are then introduced to cross-tabulation, which allows them to graph relationships to different preferences. They use this technique to find relationships in a preference survey, then brainstorm the different types of problems that this process could help solve.
Question of the Day: How can patterns in data help us make decisions?
In this lesson, students get to practice making decisions with data based on problems designed to be familiar to middle school students. Students work in groups discussing how they would use the data presented to make a decision before the class discusses their final choices. Not all questions have "right answers" and in some cases, students can and should decide that they should collect more data. The lesson concludes with a discussion of how different people could draw different conclusions from the same data, or how collecting different data might have affected the decisions they made.
Question of the Day: how can patterns in data help make a decision?
In this lesson, students look at a simple example of how a computer could be used to complete the decision-making step of the data problem-solving process if it's given an algorithm. Students are given the task of creating an algorithm that could suggest a vacation spot. Students then create rules that a computer could use to make this decision automatically. Students share their rules and what choices their rules would make with the class data. They then use their rules on data from their classmates to test whether their rules would make the same decision that a person would. The lesson concludes with a discussion about the benefits and drawbacks of using computers to automate the data problem-solving process.
Question of the Day: How can computers help us make decisions about data?
In this lesson, students look at how data is collected and used by organizations to solve problems in the real world as well as also provide students an opportunity to reflect on the fact that in their own lives, they are intentionally and unintentionally producing data that companies collect and use. Students are presented with three scenarios that could be solved using data and brainstorm the types of data they would need and how they could collect the data. Each problem is designed to reflect a real-world service that exists. After brainstorming, students watch a video about a real-world service and record notes about what data is collected by the real-world service and how it is used. At the end of the lesson, students record whether data was provided actively by a user, was recorded passively, or collected by sensors.
Question of the Day: How is our data collected and why is it useful?
In previous lessons, students have seen how we can use data to make decisions. We've also seen that data can be collected about us constantly, leading to a larger amount of data to analyze - more than a human can handle! In this lesson, students are introduced to the concepts of Artificial Intelligence and Machine Learning using the AI for Oceans widget. First students classify objects as either "fish" or "not fish" to attempt to remove trash from the ocean. Then, students will need to expand their training data set to include other sea creatures that belong in the water. In the second part of the activity, students will choose their own labels to apply to images of randomly generated fish. This training data is used for a machine-learning model that should then be able to label new images on its own.
Question of the Day: How can machines "learn"?
To conclude this unit, students design a recommendation engine based on data that they collect and analyze from their classmates. After looking at an example of a recommendation app, students follow a project guide to complete this multi-day activity. In the first several steps, students choose what choice they want to help the user to make, what data they need to give the recommendation, create a survey, and collect information about their classmates' choices. They then interpret the data and use what they have learned to create the recommendation algorithm. Last, they use their algorithms to make recommendations to a few classmates. Students perform a peer review and make any necessary updates to their projects before preparing a presentation to the class.
Question of the Day: How can I use data to make my own recommendations?
Continuation — day 2 of 5.
To conclude this unit, students design a recommendation engine based on data that they collect and analyze from their classmates. After looking at an example of a recommendation app, students follow a project guide to complete this multi-day activity. In the first several steps, students choose what choice they want to help the user to make, what data they need to give the recommendation, create a survey, and collect information about their classmates' choices. They then interpret the data and use what they have learned to create the recommendation algorithm. Last, they use their algorithms to make recommendations to a few classmates. Students perform a peer review and make any necessary updates to their projects before preparing a presentation to the class.
Question of the Day: How can I use data to make my own recommendations?
Continuation — day 3 of 5.
To conclude this unit, students design a recommendation engine based on data that they collect and analyze from their classmates. After looking at an example of a recommendation app, students follow a project guide to complete this multi-day activity. In the first several steps, students choose what choice they want to help the user to make, what data they need to give the recommendation, create a survey, and collect information about their classmates' choices. They then interpret the data and use what they have learned to create the recommendation algorithm. Last, they use their algorithms to make recommendations to a few classmates. Students perform a peer review and make any necessary updates to their projects before preparing a presentation to the class.
Question of the Day: How can I use data to make my own recommendations?
Continuation — day 4 of 5.
To conclude this unit, students design a recommendation engine based on data that they collect and analyze from their classmates. After looking at an example of a recommendation app, students follow a project guide to complete this multi-day activity. In the first several steps, students choose what choice they want to help the user to make, what data they need to give the recommendation, create a survey, and collect information about their classmates' choices. They then interpret the data and use what they have learned to create the recommendation algorithm. Last, they use their algorithms to make recommendations to a few classmates. Students perform a peer review and make any necessary updates to their projects before preparing a presentation to the class.
Question of the Day: How can I use data to make my own recommendations?
Continuation — day 5 of 5.
To conclude this unit, students design a recommendation engine based on data that they collect and analyze from their classmates. After looking at an example of a recommendation app, students follow a project guide to complete this multi-day activity. In the first several steps, students choose what choice they want to help the user to make, what data they need to give the recommendation, create a survey, and collect information about their classmates' choices. They then interpret the data and use what they have learned to create the recommendation algorithm. Last, they use their algorithms to make recommendations to a few classmates. Students perform a peer review and make any necessary updates to their projects before preparing a presentation to the class.
Question of the Day: How can I use data to make my own recommendations?
This unit assumes students are already familiar with App Lab, so we recommend starting with the App Lab Hour of Code which is included in this lesson. If your students are already familiar with App Lab, you may decide to skip this lesson, which requires hiding it from students in the unit overview page. Click here to learn more about hiding this lesson, allowing your classes to start right away with Physical Computing
This tutorial is designed to quickly introduce the App Lab programming environment as a powerful tool for building and sharing apps. The tutorial itself teaches students to create and control buttons, text, images, sounds, and screens in JavaScript using either blocks or text. At the end of the tutorial, students are given time to either extend a project they started building into a "Choose Your Own Adventure", "Greeting Card", or "Personality Quiz" app. They can also continue on to build more projects featured on the code.org/applab page.
To kick off a unit devoted to problem-solving and creating apps with devices, students begin by investigating the design of different physical devices and their apps. Students look at a variety of physical designs and attempt to match each design with a potential user. Then students choose a user and attempt to prototype a physical design for them on paper or in a digital template. To conclude the activity, students consider what it means to be a physical designer and create resources for other users.
Question of the Day: How can we design apps with devices based on the needs of a user?
This lesson gives students their first opportunity to write App Lab programs that incorporate the micro:bit physical computing device. After first inspecting the micro:bit boards, investigating some of its physical features and hypothesizing about potential uses, students move online to create applications that use App Lab inputs to control the micro:bit’s main output, its LED display, to show simple pictures, words and numbers.
Question of the Day: How can I control the main output on the BBC micro:bit?
Students should already be familiar with programming in App Lab, specifically using Design Mode to create screen elements and using `onEvent` blocks to create button click events. To expand the kinds of apps that students can make, and to encourage them to think in new ways about how users interact with apps, we introduce the `setProperty()` and `setText()` blocks that allow users to change the properties and content of various UI elements. In this lesson students explore how they can use events to update elements on the screen
Question of the Day: How can you update design elements of an app?
This lesson transitions students from considering the micro:bit as strictly an output device and instead introduces the buttons as tools for input. Starting with the hardware buttons, students learn to use [`onBoardEvent()`(#f78183)](/docs/applab/onBoardEvent/), analogously to [`onEvent()`(#fff176)](/docs/applab/onEvent/), in order to take input from their micro:bit.
Question of the Day: How can the user interact with the micro:bit for input?
In this lesson, students are introduced to variables, the counter pattern, and if-statements. Students will use these concepts in the context of programming the micro:bit and creating more complex input/output behaviors, such as counting the number of button presses before having the micro:bit light up. The concepts in this lesson are used to make more complex and fulfilling apps in future lessons, and students may need to refer back to the videos and examples in this lesson as they continue to master these concepts.
Question of the Day: How can I create more complex programs that keep track of information and make decisions?
In this mini-project, students will use the micro:bit to collect data, then use App Lab to analyze the data that was collected. This is similar to citizen science fieldwork or survey apps where a person collects data on a device "in the field", then returns to a central location to view and analyze the data (such as cataloguing endangered species in the wild). Students will use variables and events to collect data from the micro:bit, then use if-statements to make decisions or recommendations based on the data they collect.
Question of the Day: How can I use events and variables to create an app that collects and analyzes data?
Continuation — day 2 of 2.
In this mini-project, students will use the micro:bit to collect data, then use App Lab to analyze the data that was collected. This is similar to citizen science fieldwork or survey apps where a person collects data on a device "in the field", then returns to a central location to view and analyze the data (such as cataloguing endangered species in the wild). Students will use variables and events to collect data from the micro:bit, then use if-statements to make decisions or recommendations based on the data they collect.
Question of the Day: How can I use events and variables to create an app that collects and analyzes data?
Students learn to use several new design elements - text inputs, dropdowns, and sliders - so they can get user input from the screen of their apps. This lesson also introduces students to the getProperty and getText blocks, which allow them to access their user input in their code. Students first practice using these tools to determine what the user has input in various user interface elements. Students later use getProperty and setProperty together with the counter pattern to make elements move across the screen. A new event trigger, change, is also introduced to represent when a dropdown or slider changes values.
Question of the Day: How can we use the app screen for user input?
In this lesson, students combine inputs and outputs across both the micro:bit and the app screen. For example, students may use dropdowns or sliders to make the LEDs on the micro:bit change. Or, students may use the buttons on the micro:bit to update elements on the screen. This lesson also extends how students use variables and if-statements to make more complex decisions based on user input. There are no new coding commands or micro:bit features in this lesson, but students are combining many elements from previous lessons in new ways.
Question of the Day: How can I use inputs and outputs from both the micro:bit and the app screen?
In this project, students create an app that controls the micro:bit so it interacts with the physical environment around it, similar to many smart phone apps that are used to control devices in a house or car or school. Students use physical materials to help design their physical device, then create an app that lets the user interact with the physical device or change settings.
Continuation — day 2 of 5.
In this project, students create an app that controls the micro:bit so it interacts with the physical environment around it, similar to many smart phone apps that are used to control devices in a house or car or school. Students use physical materials to help design their physical device, then create an app that lets the user interact with the physical device or change settings.
Continuation — day 3 of 5.
In this project, students create an app that controls the micro:bit so it interacts with the physical environment around it, similar to many smart phone apps that are used to control devices in a house or car or school. Students use physical materials to help design their physical device, then create an app that lets the user interact with the physical device or change settings.
Continuation — day 4 of 5.
In this project, students create an app that controls the micro:bit so it interacts with the physical environment around it, similar to many smart phone apps that are used to control devices in a house or car or school. Students use physical materials to help design their physical device, then create an app that lets the user interact with the physical device or change settings.
Continuation — day 5 of 5.
In this project, students create an app that controls the micro:bit so it interacts with the physical environment around it, similar to many smart phone apps that are used to control devices in a house or car or school. Students use physical materials to help design their physical device, then create an app that lets the user interact with the physical device or change settings.
In this lesson, students explore how the two sensors (light and temperature) can be used to write programs that respond to changes in the environment. The use of these sensors marks a transition in terms of how users interact with a program. By using sensors as an input, the user of an app doesn't have to directly interact with it at all or may interact without actually realizing they are doing so.
Question of the Day: How can I use sensors to detect changes in the environment?
In this lesson, students will explore the accelerometer and its capabilities. They’ll become familiar with its events and properties, as well as create multiple programs utilizing the accelerometer similar to those they’ve likely come across in real world applications.
Question of the Day: How can I use the accelerometer to create apps?
This lesson introduces students to functions as way to organize and group repeated blocks of code together. Then, students learn how to use parameters in their functions as a way to generalize behaviors to work for different contexts. Students will use these concepts in future lessons, and it may be necessary to return to this lesson to reference the resources and videos.
Question of the Day: How can I use functions to organize and simplify my code?
In this lesson, students create an interactive "pet" using the sensors on the micro:bit, the LED Display to represent expressions, and physical materials. Students explore how the micro:bit can augment physical materials to create an interactive experience. This project does not use the App Lab screen except to help with debugging - otherwise, users only interact with the interactive pet itself.
Continuation — day 2 of 2.
In this lesson, students create an interactive "pet" using the sensors on the micro:bit, the LED Display to represent expressions, and physical materials. Students explore how the micro:bit can augment physical materials to create an interactive experience. This project does not use the App Lab screen except to help with debugging - otherwise, users only interact with the interactive pet itself.
In this lesson, students learn how to attach external LEDs to their micro:bit and use code to light up these LEDs. This allows students to create more flexible devices that mimic real-world products. This lesson requires several external materials, as well as safety protocols to ensure students don’t accidentally damage their micro:bit.
Question of the Day: How can I use external LEDs to create physical prototypes?
Continuation — day 2 of 2.
In this lesson, students learn how to attach external LEDs to their micro:bit and use code to light up these LEDs. This allows students to create more flexible devices that mimic real-world products. This lesson requires several external materials, as well as safety protocols to ensure students don’t accidentally damage their micro:bit.
Question of the Day: How can I use external LEDs to create physical prototypes?
In this lesson, students learn how to connect external wires to create input events when the wires touch, simulating a button press. Students learn to use code to recognize these external button events to make changes to their app. This allows students to create more flexible devices that mimic real-world products. This lesson requires several external materials, as well as safety protocols to ensure students don’t accidentally damage their micro:bit.
Question of the Day: How can I use external buttons to create physical prototypes?
Continuation — day 2 of 2.
In this lesson, students learn how to connect external wires to create input events when the wires touch, simulating a button press. Students learn to use code to recognize these external button events to make changes to their app. This allows students to create more flexible devices that mimic real-world products. This lesson requires several external materials, as well as safety protocols to ensure students don’t accidentally damage their micro:bit.
Question of the Day: How can I use external buttons to create physical prototypes?
In this final project for the course, students team to develop and test a prototype for an innovative computing device based on the micro:bit. Using the inputs and outputs available on the board, groups will create programs that allow for interesting and unique user interactions.
Continuation — day 2 of 5.
In this final project for the course, students team to develop and test a prototype for an innovative computing device based on the micro:bit. Using the inputs and outputs available on the board, groups will create programs that allow for interesting and unique user interactions.
Continuation — day 3 of 5.
In this final project for the course, students team to develop and test a prototype for an innovative computing device based on the micro:bit. Using the inputs and outputs available on the board, groups will create programs that allow for interesting and unique user interactions.
Continuation — day 4 of 5.
In this final project for the course, students team to develop and test a prototype for an innovative computing device based on the micro:bit. Using the inputs and outputs available on the board, groups will create programs that allow for interesting and unique user interactions.
Continuation — day 5 of 5.
In this final project for the course, students team to develop and test a prototype for an innovative computing device based on the micro:bit. Using the inputs and outputs available on the board, groups will create programs that allow for interesting and unique user interactions.
This lesson is a fun introduction to the open-ended, collaborative, and creative problem-solving students will be using over the rest of this unit and course. Students work in groups to design aluminum foil boats that will support as many pennies as possible. Groups have two rounds to work on their boats, with the goal of trying to hold more pennies than they did in round 1. The structure of the activity foreshadows different steps of the problem-solving process that students will be introduced to in more detail in the following lesson. At the end of the lesson, students reflect on their experiences with the activity and make connections to the types of problem-solving they will be doing for the rest of the course
Question of the Day: What can help us to work together and solve problems as a team?
Alternate versions of this lesson are also available.
For each group
For the teacher
This lesson introduces the formal problem-solving process that students will use over the course of the year, Define - Prepare - Try - Reflect. The lesson begins by anchoring the formal problem-solving process in some real-life experiences they already have solving problems by asking students to brainstorm all the different types of problems that they encounter in everyday life. Students are then shown the four steps of the problem-solving process and work together to relate these abstract steps to their actual experiences solving problems. First students relate these steps to the problem activities from the previous lesson, then a problem they are good at solving, then a problem they want to improve at solving. At the end of the lesson, the class collects a list of generally useful strategies for each step of the process to put on posters that will be used throughout the unit and year.
Question of the Day: What are some common steps we can use to solve many different types of problems?
For each student
For the class
For the Teacher
In this lesson, students apply the problem-solving process to three different problems in order to better understand the value of each step. They will solve a word search, arrange seating for a birthday party, and redesign a classroom. The problems grow increasingly complex and poorly defined to highlight how the problem-solving process is particularly helpful when tackling these types of problems. The lesson concludes with students reflecting on their experience with the problem-solving process. They will justify the inclusion of each step and will brainstorm questions or strategies that can help them better define open-ended problems, as this is often the most critical step.
This lesson will likely take two class periods or more to complete. The first two problems may fit into a single class period but the third will need to be moved to a second day.
Question of the Day: How can we apply the problem-solving process to many different kinds of problems?
Alternate versions of this lesson are also available.
This lesson builds on the problem-solving theme of the earlier lessons and focuses on the specifics of how computing is used in problem-solving, starting with developing a preliminary definition of a computer. To begin the lesson, the class will brainstorm possible definitions for a computer and place the results of this brainstorm on the board. Next, students will work in groups to sort pictures into “is a computer” or “is not a computer” on poster paper. Groups will place their posters around the room and briefly explain their motivations for choosing some of their most difficult categorizations. The teacher will then introduce a definition of the computer and allow students to revise their posters according to the new definition.
Question of the Day: What is a computer?
For each group
For the teacher
This lesson introduces focuses on two of the features identified in the previous lesson, input and output, that can help classify devices as a computer and has students identify different methods of input or output in common apps. In this lesson, students consider how computers get and give information to the user through inputs and outputs. Students first consider what information they would need to solve a "thinking problem", then use that information to produce a recommendation. They then identify the inputs and outputs of that process. Afterward, students consider an app that engages in the same process and determine how that app inputs and outputs information. Last, they consider other types of inputs and outputs that computers can use to help solve problems.
Question of the Day: How do computers use input and output to get and give the information that they need to solve problems?
This lesson introduces the concept of processing within computational problem-solving. While this lesson focuses on four common types of processing - if/then (conditionals), finding a match (searching), counting, and comparing - students should understand that processing is whatever a computer does to turn inputs into outputs. Students are first introduced to the types of processing through several sample apps. They then investigate more apps to determine what sorts of processing each uses. They then think of their own app and decide what types of processing it would need to work. Finally, they brainstorm other types of processing that may be useful but were not included in the main lesson.
Question of the Day: What are the different ways computers can process information?
This lesson introduces the final component of the unit's model of computing: storage. After trying out an "outfit picker" app, students discuss what information should be stored in the app versus input every time the app is run. They then look at a series of apps and use their decisions about what should be stored to create guidelines for deciding what information to store. They then review the four components of this chapter's model of computing: input, output, storage, and processing. Afterward, they have one last opportunity to revise their decisions about which items should be classified as a "computer" from earlier in the chapter. The lesson ends with a reflection on their own app ideas and how storage could be used.
Question of the Day: Why is storage an important part of the computing process?
To conclude this unit, this project combines the two major themes of Unit 1, the problem-solving process and the input/output/store/process model of a computer, to have students identify real-world problems and find ways to use technology to help solve them. This project will be completed across multiple days and will result in students creating a poster of a proposed app they design to solve a real-world problem, highlighting the features of their app that they will present to their classmates. A project guide provides step-by-step instructions for students and helps them organize their thoughts. The project is designed to be completed in pairs though it can be completed individually.
Question of the Day: How can the IOSP model help us to design an app that solves a problem?
Question of the Day: How can we choose websites based on the needs of a user?
To kick off a unit devoted to group problem solving and developing websites for other users, students begin by investigating the design of different websites. Students look at a variety of websites and attempt to match each design with a potential user. Then students choose a user and attempt to prototype a website design for them on paper or in a digital template. To conclude the activity, students consider what it means to be a web designer and create resources for other users.
This lesson introduces many new concepts and tools to students: they are introduced to HTML, the Web Lab tool, and how to navigate lesson resources on Code.org in general. In this lesson, students are introduced to HTML as a solution to the problem of how to communicate both the content and structure of a website to a computer. The lesson begins with a brief unplugged activity demonstrating the challenges of effectively communicating the structure of a web page. Students then look at an exemplar HTML page in Web Lab and discuss with their classmates how HTML tags help solve this problem. Students then write their first HTML. A wrap-up discussion helps to solidify the understanding of content vs. structure that was developed throughout the lesson.
Question of the Day: How can we tell the computer both *what* to put on the web page, and *how* to organize it?
This lesson introduces the core practices of pair programming and debugging. In this lesson, students continue to use HTML to structure text on web pages, this time in pairs, with a focus on working together and debugging problems with their sites. Students learn how to use the different heading and list elements and practice using them to give their web pages more structure.
Question of the Day: How can we work together to fix problems with our websites?
Question of the Day: How can you make sure that your private information stays private?
In this lesson, students pause their own on developing web pages so they can develop an understanding of how personal information is surfaced on the internet, sometimes intentionally and sometimes unintentionally. Students look at several fictitious social media pages to see what they can learn about different people purely from publicly available information. They then reflect on what guidelines are appropriate for posting their own information online, especially as they prepare to create more personalized websites.
In this mini-project, students use what they have learned to create a web page for a user. Students begin their project by using the Problem Solving Process to help them design a web page for a user. As they determine what content to include on the web page for their user, they will identify which tags they will use to implement their design. Students then build their user’s web page in Web Lab. Optionally, after engaging in a formal feedback process, they may change their web pages based on feedback before reflecting on their process. The lesson also includes an optional review of the HTML students have learned before building the web page.
Question of the Day: How can I use HTML to design and build a web page for a user?
This lesson introduces CSS as a way to style elements on the page. Students learn the basic syntax for CSS rule-sets and then explore properties that impact HTML text elements. They work on an HTML page about Guinness World Record holders, adding their own style to the provided page. While only a few CSS properties are introduced in the core lesson, students are encouraged to use the optional activities at the end of the lesson to explore more ways that they can express themselves using CSS.
Question of the Day: How can we change the style of text on a web page?
Until this point, the only content that students have used on their web pages is their own, but in the next lesson, they will be adding images to their sites. Before they do so, they need to understand the rules governing how to legally use content they find on the web. Starting with a discussion of their personal opinions on how others should be allowed to use their work, the class explores the purpose and role of copyright for both creators and users of creative content. They then move on to an activity exploring the various Creative Commons licenses as a solution to the difficulty in dealing with copyright.
Question of the Day: What kind of rules protect everyone's rights when we use each other's content?
This lesson introduces images, which are different from earlier tags in that they are 'self-closing' and include attributes. Students should understand that these tags do not surround content in the same way as other tags. Students start the class by considering the ethical implications of using images on their websites, specifically in terms of intellectual property. They then learn how to add images to their web pages using the <img> tag and how to cite the image sources appropriately.
Question of the Day: How can we add images on our websites, while making sure we respect everyone's rights?
This lesson continues the introduction to CSS style properties, this time focusing more on non-text elements. Students begin this lesson by looking at a website about Desserts of the World. They investigate and modify the new CSS styles on this website, adding their own styles to the page. After working on the Desserts page, students apply their knowledge of new CSS properties to their personal websites.
Question of the Day: How can we style the images and layouts of our pages?
In this mini-project, students use what they have learned to style a web page for a user. Students begin their project using the Problem Solving Process to help them determine how they will style a web page for a user. Students then style their users' web pages in Web Lab. Optionally, after engaging in a formal feedback process, they may change their web pages based on feedback before reflecting on their process. The lesson also includes an optional review of the HTML and CSS students learned before styling the web page.
Question of the Day: How can I use CSS to style a web page for a user?
Up until this point, the only styling students have been able to do is styling by the element, which means that every element of a particular kind has the same style. This lesson expands on the CSS that students have already learned by introducing classes, which allow web developers to treat groups of elements they want to be styled differently than other elements of the same type. Students first investigate and modify classes on various pages, then create their own classes and use them to better control the appearance of their pages. They then reflect on how they could use this skill to improve their team websites.
Question of the Day: How can we create different styles for the same type of element?
*Note: Single elements can also be selected by id, but this type of selection is possible with a class applied only to that single element. Because id selection does not add any extra functionality, it is not taught in this course.*
This lesson introduces students to two new web development tools: div tags and Flexbox styling. This lesson introduces students to div tags to organize their HTML code into sections. They then learn about Flexbox and how it can be used with their div containers to style and position items. Students practice using Flexbox properties to control the layout of web pages.
Question of the Day: What are div tags and Flexbox and why are they important in web design?
This lesson introduces students to advanced Flexbox child properties including `order`, `align-self`, `flex-grow`, and `flex-shrink` through an interactive warm-up and the various level exercises. They’ll deepen their understanding of how these properties affect web page layouts and conclude with a creative group drawing game to reinforce their learning.
Question of the Day: How do Flexbox child properties affect the layout and organization of elements within a webpage?
In this chapter project, students use what they have learned to style and organize a web page for a user. Students begin their project by using the Problem Solving Process to help them determine how they will organize the content of a user’s web page. Students then use CSS classes and flexbox to organize their user’s web page in Web Lab. Optionally, after engaging in a formal feedback process, they may change their web pages based on feedback before reflecting on their process.
Question of the Day: How can I use CSS classes and Flexbox to organize webpage content for a user?
This lesson explicitly addresses the challenges students may find working in a group and supports them in crafting a plan to overcome these challenges. Students work together to set group norms and brainstorm what features they would like their websites to have. The class starts by thinking of some popular teams in different contexts, then reflects on what makes teams successful. They then get into their own teams and make a plan for how they will interact and reach success in their own projects. Afterward, the teams begin to brainstorm ideas for their website project.
Question of the Day: How can we work together to make a great team?
This lesson encourages students to think more about their responsibilities as consumers of information and how to find relevant and trustworthy information online. After viewing and discussing a video about how search engines work, students will search for information relevant to their site. They'll need to analyze the sites they find for credibility to decide which are appropriate to use on their own website. By the end of this lesson, students should have developed strategies for determining which websites are more trustworthy and tie these strategies back to their own role as content producers by looking for ways to make their own sites appear more trustworthy.
Question of the Day: How do we find relevant and trustworthy information on the Internet?
This lesson will give students practice in using links and introduce them to good navigation practices for their sites. Students begin by looking online for the first web page and discussing how its use of links was what started the web. They then transition to Web Lab where they learn how to make their own links, as well as good conventions that make it easier for users to navigate on a page. Finally, they reflect on their group project and what their personal goals are for the final stretch.
Question of the Day: How can we combine several different web pages into one website?
This lesson introduces students to the dynamic world of CSS pseudo-classes. Students will learn about their role in enhancing web page interactivity and style. They will explore, practice, and apply various pseudo-classes like `link`, `visited`, `hover`, and `active`, understanding how these selectors can transform the user experience on websites.
Question of the Day: What is a CSS pseudo-class, and how does it change the way an element looks or behaves on a web page?
Students work in teams to plan out their websites and create a sketch of each page. They then download the media that they will need for their sites. At the end of the activity, they decide how the work will be distributed among team members and report whether the entire group agreed to the plan.
Question of the Day: How do we plan a web page as a group?
Teams have spent a lot of time throughout the chapter planning their websites. In this lesson, they are finally able to code their pages. Using the project guide, the team works together and individually to code all of the pages, then puts all of the work together into a single site.
Question of the Day: What skills and practices will help us work together to make a great website?
This lesson focuses on the value of peer feedback. Students first reflect on what they are proud of, and what they would like feedback on. Teams then work with peers to get that feedback through a structured process that includes the project rubric criteria. Afterward, students decide how they would like to respond to the feedback and put the finishing touches on their sites. After a final review of the rubric, they reflect on their process. To cap off the unit, they will share their projects and also an overview of the process they took to get to that final design.
Question of the Day: How can we use feedback to make our websites better?*
To kick off a unit devoted to problem-solving and developing animations and games, students begin by investigating the design of different animations and games. Students look at a variety of animations and games and attempt to match each design with a potential user. Then students choose a user and attempt to prototype an animation or game design for them on paper or in a digital template. To conclude the activity, students consider what it means to be an animation and game designer and create resources for other users.
Question of the Day: How can we design animations and games based on the needs of a user?
The primary purpose of this lesson is to introduce students to the coordinate system they will use in Game Lab. Students begin by exploring the challenges of communicating how to draw with shapes and then transition to using a tool that introduces how this problem is approached in Game Lab. The warm-up activity quickly demonstrates the challenges of communicating position without some shared reference point. In the main activity, students explore a Game Lab tool that allows students to interactively place shapes on Game Lab's 400 by 400 grid. They then take turns instructing a partner how to draw a hidden image using this tool, accounting for many challenges students will encounter when programming in Game Lab. Students optionally create their own images to communicate before a final debrief discussion.
Question of the Day: How can we clearly communicate how to draw something on a screen?
This lesson is designed to give students a chance to get used to the programming environment, as well as the basic sequencing and debugging that they will use throughout the unit. Students begin with an introduction to the GameLab interactive development environment (IDE), then learn the three commands ([`rect`(#4dd0e1)](/docs/gamelab/rect/), [`ellipse`(#4dd0e1)](/docs/gamelab/ellipse/), and [`fill`(#4dd0e1)](/docs/gamelab/fill/)) that they will need to code the same types of images that they created on paper in the previous lesson. Challenge levels provide a chance for students who have more programming experience to further explore Game Lab.
Question of the Day: How can we communicate to a computer how to draw shapes on the screen?
In this lesson, students continue to build skills and develop their familiarity with Game Lab by manipulating the width and height of the shapes they use to draw. The lesson kicks off with a discussion that connects expanded block functionality (e.g. different sized shapes) with the need for more block inputs, or "parameters". Students learn to draw with versions of [`ellipse()`(#4dd0e1)](/docs/gamelab/ellipse/) and [`rect()`(#4dd0e1)](/docs/gamelab/rect/) that include width and height parameters. They also learn to use the [`background()`(#4dd0e1)](/docs/gamelab/background/) block. Throughout the lesson, students will need to reason about the x-y coordinate plane, consider the order of their code, and slightly increase their programs' complexity.
Question of the Day: How can we use parameters to give the computer more specific instructions?
In this lesson, students learn how to use variables to label a value. Students begin the lesson with a very basic description of the purpose of a variable within the context of the storage component of the input-output-storage-processing model. Students then complete a level progression that reinforces the model of a variable as a way to label or name a number. Students should leave this lesson knowing that variables are a way to label a value in their programs so that they can be reused or referenced later. In the following lesson, students will be introduced to random numbers, in which they will see a more powerful use for variables, and in later lessons, students will continue to expand their understanding of variables and experience more advanced ways they can be used.
Question of the Day: How can we use variables to store information in our programs?
This lesson introduces randomness, which is important both as a way to make programs more interesting and also to motivate the use of variables. Students are introduced to the [`randomNumber()`(#FFB74D)](/docs/gamelab/randomNumber/) block and how it can be used to create new behaviors in their programs. They then learn how to update variables during a program. Combining all of these skills, students draw randomized images.
Question of the Day: How can we make our programs behave differently each time they are run?
After a quick review of the code they have learned so far, students are introduced to their first creative project of the unit. Using the problem-solving process as a model, students define the robot face that they want to create, prepare by thinking of the different code they will need, try their plan in Game Lab, then reflect on what they have created. They also have a chance to share their creations with their peers. The open-ended nature of this lesson also provides flexibility for the teacher to decide how long students should spend on their work, depending on the scheduling demands of the particular course implementation.
Question of the Day: How can we use shapes, variables, and randomness to express our creativity?
In order to create more interesting and detailed images, students are introduced to the sprite object which allows for one variable name to control both the shape and all its aspects. The lesson starts with a discussion of the various information that programs must keep track of, then presents sprites as a way to keep track of that information. Students then learn how to assign each sprite an image, which will greatly increase the complexity of what they can draw on the screen.
Question of the Day: How can we use sprites to help us keep track of lots of information in our programs?
In the last lesson, when students were introduced to sprites, they focused mainly on creating a sprite and assigning it an animation. This lesson starts to dig into what makes sprites such a powerful programming construct - that they have properties that can be modified as a program is _running_. This lays the foundation for much of what students will be doing in the rest of the unit in terms of accessing and manipulating sprite properties to create interesting behaviors in their programs. The lesson starts with a review of what a sprite is, then students move on to Game Lab to practice more with sprites, using their properties to change their appearance. They then reflect on the connections between properties and variables.
Question of the Day: How can we use sprite properties to change their appearance on the screen?
This lesson introduces Game Lab's text commands, giving students more practice using the coordinate plane and parameters. This is the last type of element that students will be placing on the screen - after this, students will focus on how they can control the movement and interactions of these elements. The lesson begins with asking students to caption a cartoon created in Game Lab. They then move on to Code Studio where they practice placing text on the screen and controlling other text properties, such as size. Students who complete the assessment early can go on to learn more challenging blocks related to text properties.
Question of the Day: How can we use text to improve our scenes and animations?
After a quick review of the code they have learned so far, students start working on their next creative project of the unit. Using the problem-solving process as a model again, students define the scene that they want to create, prepare by thinking of the different code they will need, try their plan in Game Lab, then reflect on what they have created. They also have a chance to share their creations with their peers. The open-ended nature of this lesson also provides flexibility for the teacher to decide how long students should spend on their work, depending on the scheduling demands of the particular course implementation.
Question of the Day: How can we use Game Lab to express our creativity?
In this lesson, students are introduced to the draw loop, one of the core programming paradigms in Game Lab. To begin the lesson students look at some physical flipbooks to see that having many frames with different images creates the impression of motion. Students then watch a video explaining how the draw loop in Game Lab helps to create this same impression in their programs. Students combine the draw loop with random numbers to manipulate some simple animations with dots and then with sprites. Students should leave the lesson understanding that the commands in the draw loop are called after all other code but are then called repeatedly to create animation. Students will have a chance to continue to develop an understanding of this behavior in the next two lessons, but laying a strong conceptual foundation in this lesson will serve them well for the rest of the unit.
Question of the Day: How can we animate our images in Game Lab?
This lesson builds on the draw loop that students learned previously to create programs with _purposeful_ motion. Students learn how to control sprite movement using a construct called the counter pattern, which incrementally changes a sprite's properties. Students first brainstorm different ways that they could animate sprites by controlling their properties, then explore the counter pattern in Code Studio. After examining working code, students try using the counter pattern to create various types of sprite movements. The skills that students build in this lesson lay the foundation for all of the animations and games that they will make throughout the rest of the unit.
Question of the Day: How can we control sprite movement in Game Lab?
This lesson is a chance for students to get more creative with what they have learned as students are asked to combine different methods that they have learned to create an animated scene. Students first review the types of movement and animation that they have learned and brainstorm what types of scenes might need that movement. They then begin to plan out their own animated scenes, which they create in Game Lab.
Question of the Day: How can we combine different programming patterns to make a complete animation?
This lesson introduces booleans and conditionals, which allow a program to run differently depending on whether a condition is true. Students start by playing a short game in which they respond according to whether particular conditions are met. They then move to Code Studio, where they learn how the computer evaluates Boolean expressions, and how they can be used to structure a program.
Question of the Day: How can programs react to changes as they are running?
One common way conditionals are used is to check for different types of user input, especially key presses. Following the introduction to booleans and _if_ statements in the previous lesson, students are introduced to a new block called [`keyDown()`(#fff176)](/docs/gamelab/keyDown/) which returns a boolean and can be used in conditionals statements to move sprites around the screen. By the end of this lesson, students will have written programs that take keyboard input from the user to control sprites on the screen.
Question of the Day: How can our programs react to user input?
In this lesson, students continue to explore ways to use conditional statements to take user input - this time with the mouse. They will also expand their understanding of conditionals to include _else_, which allows for the computer to run a certain section of code when a condition is true, and a different section of code when it is not. This concept is introduced alongside several new mouse input commands, allowing students to gradually build up programs that use input in different ways.
Question of the Day: What are more ways that the computer can react to user input?
This end-of-chapter assessment is a good place for students to bring together all the pieces they have learned (drawing, variables, sprites, images, conditionals, user input) in one place. In this project, students plan for and develop an interactive greeting card using all of the programming techniques they've learned to this point. Giving students the opportunity to really be creative after learning all these new concepts will help to engage them further as they head into Chapter 2.
Question of the Day: What skills and practices are important when creating an interactive program?
This lesson launches a major theme of the chapter: that complex behavior can be represented in simpler ways to make it easier to write and reason about code. After a brief review of how they used the counter pattern to move sprites in previous lessons, students are introduced to the idea of hiding those patterns in a single [`velocity`(#f78183)](/docs/ide/gamelab/expressions/velocityX) block. Students then head to Code Studio to try out new blocks that set a sprite's velocity directly, and look at various ways that they are able to code more complex behaviors in their sprites. Over the next several lessons, students will see how this method of managing complexity allows them to produce more interesting sprite behaviors.
Question of the Day: How can programming languages hide complicated patterns so that it is easier to program?
This lesson formally introduces the use of abstractions, simple ways of representing underlying complexity. In the last lesson, students were exposed to the idea of using one block to represent complex code. Working in pairs, students further explore this idea in the context of the intentionally complex mathematical challenge of determining whether two sprites are touching. Students then use a single block, the [`isTouching()`(#f78183)](/docs/gamelab/isTouching/) block, to represent this complexity and to create different effects when sprites collide. By the end of the lesson, students should understand that by using a single block to represent this complexity, it becomes much easier to write and reason about code and appreciate the value of using abstractions.
Question of the Day: How can programming help make complicated problems more simple?
This lesson is another chance for students to get more creative with what they have learned. Students use what they have learned about collision detection and setting velocity to create a simple side-scroller game. After looking at a sample side-scroller game, students brainstorm what sort of side-scroller they would like to make, then use a structured process to program the game in Code Studio. This lesson can be shortened or lengthened depending on time constraints.
Question of the Day: How can the new types of sprite movement and collision detection be used to create a game?
This lesson does not introduce any new blocks and in fact, only uses patterns students have seen in Chapter 1 and demonstrates how combining these patterns, in particular the abstractions students learned in the previous two lessons, allows them to build new behaviors for their sprites. Specifically, this lesson has students learn how to combine the velocity properties of sprites with the counter pattern to create more complex sprite movement. After reviewing the two concepts, they explore various scenarios in which velocity is used in the counter pattern and observe the different types of movement that result, such as simulating gravity. They then reflect on how they were able to get new behaviors by combining blocks and patterns that they already knew.
Question of the Day: How can previous blocks be combined in new patterns to make interesting movements?
This lesson introduces collisions, another useful abstraction that will allow students to manipulate their sprites in entirely new ways. After a brief review of how they used the [`isTouching`(#f78183)](/docs/gamelab/isTouching/) block, students brainstorm other ways that two sprites could interact. They then use [`isTouching`(#f78183)](/docs/gamelab/isTouching/) to make one sprite push another across the screen before practicing with the four collision blocks ([`collide`(#f78183)](/docs/gamelab/collide/), [`displace`(#f78183)](/docs/gamelab/displace/), [`bounce`(#f78183)](/docs/gamelab/bounce/), and [`bounceOff`(#f78183)](/docs/gamelab/bounceOff/)). This is the last time they will learn a new sprite behavior, and following this lesson students will transition to focusing on how they organize their increasingly complex code.
Question of the Day: How can programmers build on abstractions to create further abstractions?
This lesson is another chance for students to get more creative with what they have learned. Students use what they have learned about simulating gravity and the different types of collisions to create simple flyer games. After looking at a sample flyer game, students brainstorm what sort of flyer games they would like, then use a structured process to program the game in Code Studio.
Question of the Day: How can the new types of collisions and modeling movement be used to create a game?
In previous lessons, students have learned to use a number of abstractions in their programs which have allowed them to build much more complex programs while ignoring the details of how that behavior is created. In this lesson, students learn to build abstractions of their own by creating functions that will serve to organize their code, make it more readable, and remove repeated blocks of code. Students first think about what sorts of new blocks they would like in Game Lab, and what code those blocks would contain inside. Afterward, students learn to create functions in Game Lab. They will use functions to remove long blocks of code from their draw loop and to replace repeated pieces of code with a single function.
Question of the Day: How can programmers use functions to create their own abstractions?
This lesson introduces students to the process they will use to design games for the remainder of the unit which is centered around a project guide that asks students to define their sprites, variables, and functions _before_ they begin programming their game. Students begin by playing a game on Game Lab where the code is hidden, discussing what they think the sprites, variables, and functions would need to be to make the game. For the purposes of heavily scaffolding the software development process, students are then given a completed project guide that provides starter code and shows one way to implement the game. Students are then walked through this implementation process through a series of levels and have an opportunity to make improvements to the game to make it their own in the final level. In the subsequent lessons, students will need to complete a greater portion of the guide independently, and for the final project, they will follow this process largely independently.
Question of the Day: How does having a plan help to make a large project easier?
In this multi-day lesson, students use the problem-solving process from Unit 1 to create a platform jumper game. This lesson also builds on the use of the Project Guide in the previous lesson by having students complete more of this project guide independently before using it to build a game. Students begin the lesson by looking at an example of a platform jumper, then define what their games will look like. Next, they use a structured process to plan the backgrounds, variables, sprites, and functions they will need to implement their game. After writing the code for the game, students will reflect on how the game could be improved, and implement those changes.
Question of the Day: How can the problem-solving process help programmers to manage large projects?
Students will plan and build their own game using the project guide from the previous two lessons. Working individually or in pairs, students will first decide on the type of game they'd like to build, taking as inspiration a set of sample games. They will then complete a blank project guide where they will describe the game's behavior and scope out the variables, sprites, and functions they'll need to build. In Code Studio, a series of levels prompts them on a general sequence they can use to implement this plan. Partway through the process, students will share their projects for peer review and will incorporate feedback as they finish their game. At the end of the lesson, students will share their completed games with their classmates. This project will span multiple classes and can easily take anywhere from 3-5 class periods.
Question of the Day: How can the five CS practices (problem-solving, persistence, communication, collaboration, and creativity) help programmers to complete large projects?
To kick off a unit devoted to group problem-solving and developing products for other users, students begin by investigating the design of various shoes. We are purposefully starting out by looking at non-technical objects to encourage students to think more broadly about what it means to consider the end-user of a product before honing in on how it specifically applies to software design. Students begin by looking at a variety of shoes and attempting to match each shoe with a potential user. Students also provide feedback on these designs, using an “I Like…” / “I Wish…” / “I Wonder…” structure that will be repeated throughout the unit. To conclude the activity, students are asked to propose some changes to one set of shoes that would make it more useful or usable.
Question of the Day: How can we choose products based on the needs of a user?
This lesson builds on the previous by asking students to not only consider that there _is_ a user that products are designed for, but also empathize with those potential users since designers need to understand their users' needs in order to create useful products. This lesson encourages students to think about how to design for another person by role-playing as someone else using a user profile and reacting as that user to a series of products. Each student is assigned a user profile describing a person, which they then use to choose appropriate products, critique product design, and suggest improvements to design.
Question of the Day: How can we make sure a product is meeting the needs of a user?
This is the first part of a two-day lesson where students are guided through an abbreviated version of the design process they will be seeing throughout this unit. This lesson focuses on the Define and Prepare steps of the process. Students first brainstorm a list of potential users of smart clothing. As a class, they then group these ideas into broad categories and each group will choose one category of user. Groups repeat this process to brainstorm the needs or concerns of their user, eventually categorizing these needs and choosing one to focus on. In the next lesson, students will complete the Try and Reflect steps of the design process.
The activity in this lesson is an adaptation of the Design Charrette from the University of Washington.
Question of the Day: How can we design for people other than ourselves?
This is the second part of a two-day lesson where students are guided through an abbreviated version of the design process they will be seeing throughout this unit. Yesterday students completed the Define and Prepare steps of the design process. Today, they complete the Try and Reflect portions. Students continue their work from yesterday by designing a piece of smart clothing, using the specific needs and concerns they brainstormed to guide their decision-making. Students have a chance to share their decision-making process and get feedback on how well their product addresses the user needs they selected.
Question of the Day: How can we design a product to meet a user's needs?
Following the mini-design project, students look towards the next phase of design - prototyping a product that attempts to address user needs. In teams, students examine a paper prototype for a chat app called "Txt Ur Grndkdz". Through using this paper prototype, students get a chance to see how a simple paper prototype can be used to quickly test ideas and assumptions before we ever get to the computer. This prototype will also serve as the context around which students will start to parse and organize feedback from a wide variety of users. After "using" the provided prototype students begin to identify ways to improve the next iteration.
Question of the Day: How can we test an app to make sure it meets a user's needs?
In this lesson, students use feedback from "users" of the paper-prototyped app from the previous lesson in order to develop improvements to the user interface of that paper prototype. The lesson begins with a reflection on the fact that designers need to translate human needs with technology into changes to the user interface or experience. Students are then given a collection of feedback and requests from users of the app from the previous lesson. In groups, students categorize the feedback and identify ways the needs expressed in the feedback could be met by changes to the interface of the app. Then in groups students will implement some of these changes to meet one of the needs they identified.
Question of the Day: How can we use feedback to improve an app?
In previous lessons, needs & interests have been presented more explicitly to students. In this lesson, they have the task of extracting that information from a user interview, which motivates the app they will create. Students begin by first interpreting user interviews to determine the needs & interests of a user. They then speculate on the barriers these users are facing or the opportunities that are available for each user. In a group, they share these barriers & opportunities and brainstorm different apps that could be used to address these issues. By the end of the lesson, students will have decided on an app idea that addresses a barrier or opportunity for a user.
Question of the Day: How can user interviews help us create apps to meet the needs of a user?
The focus of this project is on the design process, especially empathizing with their user and the testing & feedback steps of the app design process. Based on user interviews from the previous lesson, each student comes up with an idea for an app that will address their user's problem. Students then get to create their own paper prototype of their app ideas by drawing "screens" on individual notecards. A project guide directs students through the process including building the paper prototype and testing it with their user to see if their assumptions about the user interfaces they created are accurate.
This is a two-day lesson, with specific timings outlined in the lesson plan below.
Question of the Day: How can I develop an app prototype for a user?
This lesson lays the foundation for the project that will last the remainder of the unit. Students first explore a number of apps designed for social impact that have been created by other students. Students form project teams and lay out a contract for how the team will function throughout the development of their app. Finally, they brainstorm a team name, a topic for their app, and potential users. *Teachers can choose to make this lesson pack a bigger punch if they find examples (even those from their own previous classes) that demonstrate local examples of students designing apps for social good.*
Question of the Day: What is an App for Good we want to create?
In this lesson students research apps similar to the one they intend on creating to better understand the needs of their users. Students work within their teams to search the Internet for other apps, then evaluate the ones they find interesting. By the end of the lesson, each team will have a clearer idea about the type of app they want to create and further refine who their target users are. Each team will maintain a list of citations for all the apps they examined for use in their final presentation.
Question of the Day: How can we use existing apps as inspiration for our own apps?
This lesson helps narrow the scope of the types of design elements students can include in their apps since up until now, students have explored and brainstormed apps with a variety of functionality - they may have discovered apps that use maps, or connect to social media, or access data on your phone. However, students will eventually be prototyping these apps in App Lab, so they will be in better shape if their ideas align with the kinds of apps that can be made using AppLab’s tools. Today focuses on having teams look at several example apps made in AppLab and identifying the components of the user interface. They then make a plan for which features could use which components in their app.
Question of the Day: What user interface elements will be useful for our app?
This lesson kicks off the actual design phase of this project. Students work in their teams to create paper prototypes for the apps they’ve been developing. They begin by making a plan for each screen, then assigning different team members to work on each screen so the task can be completed in time. They can use 3x5 index cards to develop their paper prototypes or the Paper Prototype template.
Question of the Day: How can we build a paper prototype for our app?
The primary purpose of developing paper prototypes is that they allow for quick testing and iteration before any code is written. This lesson is focused on giving teams a chance to test their prototypes and gut-check assumptions about how the app should be laid out and navigated before moving to App Lab. Teams develop a plan to test with users before running prototype tests with multiple other students in the class (and potentially outside the class). In order to test the prototype with the users, the students will have to assign roles in the testing (the “narrator”, the “computer” and the “observers”) as well as have some questions prepared for the user to answer after the test is complete.
Question of the Day: How does our prototype work when tested by real users?
Students are introduced to the App Lab programming environment that they will use to build their apps. Students work through a progression of skill-building levels to learn how to use the drag-and-drop design mode of App Lab. Students will build up an exemplar app screen and end the lesson by making a plan to adapt one of their Paper Prototype screens into App Lab, focusing on having unique IDs for each element. In tomorrow’s lesson, they will build a screen from their paper prototype, incorporating the feedback from yesterday’s lesson.
Question of the Day: How can we use App Lab and Design Mode to create apps?
Having collaboratively developed a paper prototype for their apps, groups now divide and conquer to begin work on an interactive digital version based on the paper prototype. Using the drag-and-drop design mode of App Lab, students individually work through a progression of skill-building levels to learn how to build digital versions of a paper prototype. From there, each group member builds out at least one page of their app in App Lab, to be later combined into a single app.
Question of the Day: How can I design a digital prototype from a paper prototype?
In this lesson, students learn how to add screens to their apps, how to import screens created by other students, and how to program events to navigate between screens. Students learn basic event-driven programming by building up the model app that they started in the previous lesson. At the end of the lesson, students make a plan for how they will stay organized when importing each other’s screens in tomorrow’s lesson.
Question of the Day: How can I use events to create an app?
In this lesson, teams combine their digital prototype screens into a single app, which they can then link together using code. They share their project’s import URLs with each other, then import each teammate’s screen into their own app. Each student works independently to add events to their code to link the screens together, completing their digital prototype.
Question of the Day: How can I combine screens to create a complete digital prototype?
By now students should be fairly practiced at testing with users but this time around, the role of the computer is actually done by the computer! This means that the team running the test needs to focus their energy on carefully watching what the user does, and encourage the user to say aloud what they are experiencing. The primary purpose of this lesson is to have the team actually test the app with other people, preferably from the target audience the app is intended for, or from different teams in the class while observers from the team will record the results. As with testing the paper prototypes, teams will start by planning for the specific scenarios before running and observing tests.
Question of the Day: How does our digital prototype work when tested by real users?
Teams have at this point developed an app prototype that has gone through multiple iterations and rounds of user testing. With the information and guidance gained from the last round of user testing, each student has the opportunity to plan for and implement improvements (which could be adding programmatic functionality, a more eye-catching design, more informative text copy, better uniformity of iconography, or any number of other non-programming related features) to the team app. Depending on the time you have available, and student interest, you can run the cycle of testing and iteration as many times as you see fit.
Question of the Day: How can we create a plan to address bugs and features in our prototype?
Teams make a decision about how they will incorporate updates to their app, then they begin updating their app based on their post-its from yesterday’s lesson. They use a “To Do / Doing / Done” chart to organize their work and track their progress. Teams spend the majority of the class working on updating their app, with time at the end to re-combine into a single app if necessary.
Question of the Day: How can I track my work while we make updates to our app?
At this point, teams have researched a topic of personal and social importance, developed and tested both a paper prototype and a digital prototype, and iterated on the initial app to incorporate new features and bug fixes. Now is the time for them to review what they have done and pull together a coherent presentation to not only demonstrate their process of creation, but to also acknowledge the research, design, testing, and iteration that teams have gone through. Using the provided presentation template, teams prepare to present their process of app development, including the problem they set out to solve, the ways in which they've incorporated feedback from testing, and their plans for the future.
Question of the Day: How can I present the steps in our design process to people outside of our team?
In Chapter 1 of this unit, students learn the different representation systems that computers use to represent information. In this first lesson, students get an overview of what data is and how it is used to solve problems. Students start off with a brief discussion to come to a common understanding of data. They then split into groups and use a data set to make a series of meal recommendations for people with various criteria. Each group has the choices of meals represented in a different way (pictures, recipes, menu, nutrition) that gives an advantage for one of the recommendations. Afterward, groups compare their responses and discuss how the different representations of the meal data affected how the students were able to solve the different problems and see that the same objects can be represented in a number of different ways.
Question of the Day: How does data affect decisions we make every day?
In this lesson, students get to explore for themselves the qualities of a good system for representing information by creating their own system for representing information. They begin by brainstorming all the different systems they already use to represent yes-no responses and then move on to create a system that can represent any letter in the alphabet using only a single stack of cards. The cards used have one of 6 different possible drawings (6 animals, 6 colors, etc.) and so to represent the entire alphabet students will need to work with their groups to use patterns of multiple cards to represent each letter. Students create messages with their systems and exchange them with other groups to ensure the system worked as intended. In the wrap-up discussion, the class reviews the pros and cons of the different systems, discussing commonalities between working systems and recognizing that there are many possible solutions to this problem and what's important is that everyone uses the same arbitrary system to communicate.
Question of the Day: How can we create a system for representing information?
This lesson is an opportunity to make some real-world connections from the previous lesson and review some of the concepts students saw in that activity. Students are formally introduced to the concept of binary, learn what a bit of information is, and get practice using a binary system and ASCII, a system for encoding information. At the beginning of the lesson, the teacher introduces the fact that computers must represent information using either "on" or "off". Then students are introduced to the ASCII system for representing text using binary symbols. Students practice using this system before encoding their own message using ASCII. At the end of the lesson, a debrief conversation helps synthesize the key learning objectives of the activity.
Question of the Day: What system do computers use to represent letters and words?
In this lesson, students learn how computers represent images. To begin the lesson they consider the challenge of turning all the complexity of vision into a binary pattern. Through a series of images showing how this transformation is made, students are introduced to the concept of splitting images into squares or "pixels" which can then be turned on or off individually to make the entire image. Students then do a short set of challenges using the Pixelation Widget in order to draw black and white images. Puzzles are designed to call out some of the challenges of representing images in this way. In the wrap-up, students make connections between the system for representing images and the system for representing text they learned in the previous lesson.
Question of the Day: What system do computers use to represent images?
In this lesson, students learn how to use the binary system to represent integers. With a set of cards that represent the place values in a binary (base-2) number system by a collection of dots, students turn bits "on" or "off" by turning cards face up and face down, then observe the numbers that result from these different patterns. Eventually, students extend the pattern to a generic 4-bit system.
Question of the Day: What system do computers use to represent numbers?
In this lesson, students use all three types of binary representation systems (ASCII characters, binary numbers, and images) to decode information in a record. After seeing a series of bits and being asked to decode them, students are introduced to the idea that in order to understand binary information, they must understand both the system that is being used and the meaning of the information encoded. They then decode a record representing a pet based on a given structure.
Question of the Day: How do computers tell the difference between binary codes for letters, numbers, or images?
As students have been encoding and decoding data, they have not been worried about securing the data that they are using even when that information has been highly personal or sensitive (such as addresses or phone numbers). In this lesson, they continue to explore how data is represented in a punchcard and begin to think about how they can ensure that only the intended recipient can read the data that they send. Once students understand the reasons for protecting data, they learn a binary encryption system that lets them encrypt and decrypt data in their punchcards, and eventually, they are able to send secret messages to one another using this method. The class concludes with a discussion on the importance of protecting our information and how encryption is one way we can accomplish this.
Question of the Day: How can we keep data secret and protect it from misuse?
The project serves as a cumulative project for the chapter, bringing together the different representation systems students have learned to design a structure that represents their perfect day. Students will first write a short description of their perfect day and then review with a partner to identify the key pieces of information they think a computer could capture. As a class, students will decide how a punch card of bytes of information will be interpreted to represent those pieces of information. Students will then use the ASCII, binary number, and image formats they have learned to represent their perfect days and then trade punch cards and try to decode what the other student's perfect day is like. This lesson forces students to grapple with some of the challenges of representing information in a computer since computers are good at representing _some_ kinds of information like numbers or characters, but this forces students to represent information in ways that might not always capture the full analog experience of an object or event.
Question of the Day: How can I represent complex information using binary systems?
In this lesson, students use the problem solving process from earlier in the course to solve a data problem. After reviewing the process, the class is presented with a decision: whether a city should build a library, pet shelter, or fire department. Students work in teams to collect information on the Internet to help them decide what should be built, then use this information to build an argument that will convince the city council of their choice. They then map what they have done to the problem solving process that they have been using throughout the course, comparing the general problem solving process to its specific application to data problems.
Question of the Day: How can we use data to solve problems in our community?
In this lesson, students go further into the collection and interpretation of data, including cleaning and visualizing data. Students first look at how presenting data in different ways can help people to understand it better, and they then create visualizations of their own data. Using the results of a preferred pizza topping survey, students must decide what to do with data that does not easily fit into the visualization scheme that they have chosen. Finally, students discuss which parts of this process can be automated by a computer and which need a human to make decisions.
Question of the Day: how can we make it easier for computers to process data?
Students begin the lesson by looking at a cake preference survey that allows respondents to specify both a cake and an icing flavor. They discuss how knowing the relationship between cake and icing preference helps them better decide which combination to recommend. They are then introduced to cross-tabulation, which allows them to graph relationships to different preferences. They use this technique to find relationships in a preference survey, then brainstorm the different types of problems that this process could help solve.
Question of the Day: How can patterns in data help us make decisions?
In this lesson, students get to practice making decisions with data based on problems designed to be familiar to middle school students. Students work in groups discussing how they would use the data presented to make a decision before the class discusses their final choices. Not all questions have "right answers" and in some cases, students can and should decide that they should collect more data. The lesson concludes with a discussion of how different people could draw different conclusions from the same data, or how collecting different data might have affected the decisions they made.
Question of the Day: how can patterns in data help make a decision?
In this lesson, students look at a simple example of how a computer could be used to complete the decision-making step of the data problem-solving process if it's given an algorithm. Students are given the task of creating an algorithm that could suggest a vacation spot. Students then create rules that a computer could use to make this decision automatically. Students share their rules and what choices their rules would make with the class data. They then use their rules on data from their classmates to test whether their rules would make the same decision that a person would. The lesson concludes with a discussion about the benefits and drawbacks of using computers to automate the data problem-solving process.
Question of the Day: How can computers help us make decisions about data?
In this lesson, students look at how data is collected and used by organizations to solve problems in the real world as well as also provide students an opportunity to reflect on the fact that in their own lives, they are intentionally and unintentionally producing data that companies collect and use. Students are presented with three scenarios that could be solved using data and brainstorm the types of data they would need and how they could collect the data. Each problem is designed to reflect a real-world service that exists. After brainstorming, students watch a video about a real-world service and record notes about what data is collected by the real-world service and how it is used. At the end of the lesson, students record whether data was provided actively by a user, was recorded passively, or collected by sensors.
Question of the Day: How is our data collected and why is it useful?
In previous lessons, students have seen how we can use data to make decisions. We've also seen that data can be collected about us constantly, leading to a larger amount of data to analyze - more than a human can handle! In this lesson, students are introduced to the concepts of Artificial Intelligence and Machine Learning using the AI for Oceans widget. First students classify objects as either "fish" or "not fish" to attempt to remove trash from the ocean. Then, students will need to expand their training data set to include other sea creatures that belong in the water. In the second part of the activity, students will choose their own labels to apply to images of randomly generated fish. This training data is used for a machine-learning model that should then be able to label new images on its own.
Question of the Day: How can machines "learn"?
To conclude this unit, students design a recommendation engine based on data that they collect and analyze from their classmates. After looking at an example of a recommendation app, students follow a project guide to complete this multi-day activity. In the first several steps, students choose what choice they want to help the user to make, what data they need to give the recommendation, create a survey, and collect information about their classmates' choices. They then interpret the data and use what they have learned to create the recommendation algorithm. Last, they use their algorithms to make recommendations to a few classmates. Students perform a peer review and make any necessary updates to their projects before preparing a presentation to the class.
Question of the Day: How can I use data to make my own recommendations?
This unit assumes students are already familiar with App Lab, so we recommend starting with the App Lab Hour of Code which is included in this lesson. If your students are already familiar with App Lab, you may decide to skip this lesson, which requires hiding it from students in the unit overview page. Click here to learn more about hiding this lesson, allowing your classes to start right away with Physical Computing
This tutorial is designed to quickly introduce the App Lab programming environment as a powerful tool for building and sharing apps. The tutorial itself teaches students to create and control buttons, text, images, sounds, and screens in JavaScript using either blocks or text. At the end of the tutorial, students are given time to either extend a project they started building into a "Choose Your Own Adventure", "Greeting Card", or "Personality Quiz" app. They can also continue on to build more projects featured on the code.org/applab page.
To kick off a unit devoted to problem-solving and creating apps with devices, students begin by investigating the design of different physical devices and their apps. Students look at a variety of physical designs and attempt to match each design with a potential user. Then students choose a user and attempt to prototype a physical design for them on paper or in a digital template. To conclude the activity, students consider what it means to be a physical designer and create resources for other users.
Question of the Day: How can we design apps with devices based on the needs of a user?
This lesson gives students their first opportunity to write App Lab programs that incorporate the micro:bit physical computing device. After first inspecting the micro:bit boards, investigating some of its physical features and hypothesizing about potential uses, students move online to create applications that use App Lab inputs to control the micro:bit’s main output, its LED display, to show simple pictures, words and numbers.
Question of the Day: How can I control the main output on the BBC micro:bit?
Students should already be familiar with programming in App Lab, specifically using Design Mode to create screen elements and using `onEvent` blocks to create button click events. To expand the kinds of apps that students can make, and to encourage them to think in new ways about how users interact with apps, we introduce the `setProperty()` and `setText()` blocks that allow users to change the properties and content of various UI elements. In this lesson students explore how they can use events to update elements on the screen
Question of the Day: How can you update design elements of an app?
This lesson transitions students from considering the micro:bit as strictly an output device and instead introduces the buttons as tools for input. Starting with the hardware buttons, students learn to use [`onBoardEvent()`(#f78183)](/docs/applab/onBoardEvent/), analogously to [`onEvent()`(#fff176)](/docs/applab/onEvent/), in order to take input from their micro:bit.
Question of the Day: How can the user interact with the micro:bit for input?
In this lesson, students are introduced to variables, the counter pattern, and if-statements. Students will use these concepts in the context of programming the micro:bit and creating more complex input/output behaviors, such as counting the number of button presses before having the micro:bit light up. The concepts in this lesson are used to make more complex and fulfilling apps in future lessons, and students may need to refer back to the videos and examples in this lesson as they continue to master these concepts.
Question of the Day: How can I create more complex programs that keep track of information and make decisions?
In this mini-project, students will use the micro:bit to collect data, then use App Lab to analyze the data that was collected. This is similar to citizen science fieldwork or survey apps where a person collects data on a device "in the field", then returns to a central location to view and analyze the data (such as cataloguing endangered species in the wild). Students will use variables and events to collect data from the micro:bit, then use if-statements to make decisions or recommendations based on the data they collect.
Question of the Day: How can I use events and variables to create an app that collects and analyzes data?
Students learn to use several new design elements - text inputs, dropdowns, and sliders - so they can get user input from the screen of their apps. This lesson also introduces students to the getProperty and getText blocks, which allow them to access their user input in their code. Students first practice using these tools to determine what the user has input in various user interface elements. Students later use getProperty and setProperty together with the counter pattern to make elements move across the screen. A new event trigger, change, is also introduced to represent when a dropdown or slider changes values.
Question of the Day: How can we use the app screen for user input?
In this lesson, students combine inputs and outputs across both the micro:bit and the app screen. For example, students may use dropdowns or sliders to make the LEDs on the micro:bit change. Or, students may use the buttons on the micro:bit to update elements on the screen. This lesson also extends how students use variables and if-statements to make more complex decisions based on user input. There are no new coding commands or micro:bit features in this lesson, but students are combining many elements from previous lessons in new ways.
Question of the Day: How can I use inputs and outputs from both the micro:bit and the app screen?
In this project, students create an app that controls the micro:bit so it interacts with the physical environment around it, similar to many smart phone apps that are used to control devices in a house or car or school. Students use physical materials to help design their physical device, then create an app that lets the user interact with the physical device or change settings.
In this lesson, students explore how the two sensors (light and temperature) can be used to write programs that respond to changes in the environment. The use of these sensors marks a transition in terms of how users interact with a program. By using sensors as an input, the user of an app doesn't have to directly interact with it at all or may interact without actually realizing they are doing so.
Question of the Day: How can I use sensors to detect changes in the environment?
In this lesson, students will explore the accelerometer and its capabilities. They’ll become familiar with its events and properties, as well as create multiple programs utilizing the accelerometer similar to those they’ve likely come across in real world applications.
Question of the Day: How can I use the accelerometer to create apps?
This lesson introduces students to functions as way to organize and group repeated blocks of code together. Then, students learn how to use parameters in their functions as a way to generalize behaviors to work for different contexts. Students will use these concepts in future lessons, and it may be necessary to return to this lesson to reference the resources and videos.
Question of the Day: How can I use functions to organize and simplify my code?
In this lesson, students create an interactive "pet" using the sensors on the micro:bit, the LED Display to represent expressions, and physical materials. Students explore how the micro:bit can augment physical materials to create an interactive experience. This project does not use the App Lab screen except to help with debugging - otherwise, users only interact with the interactive pet itself.
In this lesson, students learn how to attach external LEDs to their micro:bit and use code to light up these LEDs. This allows students to create more flexible devices that mimic real-world products. This lesson requires several external materials, as well as safety protocols to ensure students don’t accidentally damage their micro:bit.
Question of the Day: How can I use external LEDs to create physical prototypes?
In this lesson, students learn how to connect external wires to create input events when the wires touch, simulating a button press. Students learn to use code to recognize these external button events to make changes to their app. This allows students to create more flexible devices that mimic real-world products. This lesson requires several external materials, as well as safety protocols to ensure students don’t accidentally damage their micro:bit.
Question of the Day: How can I use external buttons to create physical prototypes?
In this final project for the course, students team to develop and test a prototype for an innovative computing device based on the micro:bit. Using the inputs and outputs available on the board, groups will create programs that allow for interesting and unique user interactions.
This unit assumes students are already familiar with App Lab, so we recommend starting with the App Lab Hour of Code which is included in this lesson. If your students are already familiar with App Lab, you may decide to skip this lesson, which requires hiding it from students in the unit overview page. Click here to learn more about hiding this lesson, allowing your classes to start right away with Physical Computing
This tutorial is designed to quickly introduce the App Lab programming environment as a powerful tool for building and sharing apps. The tutorial itself teaches students to create and control buttons, text, images, sounds, and screens in JavaScript using either blocks or text. At the end of the tutorial, students are given time to either extend a project they started building into a "Choose Your Own Adventure", "Greeting Card", or "Personality Quiz" app. They can also continue on to build more projects featured on the code.org/applab page.
In this lesson students are introduced to a form of artificial intelligence called machine learning and how they can use the Problem Solving Process to help train a robot to solve problems. They participate in three machine learning activities where a robot - A.I. Bot - is learning how to detect patterns in fish.
Question of the Day: How can we use the Problem Solving Process to solve a problem with machine learning?
In this lesson students will consider how they create “mental” models when learning new concepts, and how those can be similar to a “machine learning” model. They participate in a color pattern activity to simulate building a machine learning model without help, then they play a game called "Green Glass Door" as an example of supervised learning, and finally, they will sort several scenarios into “supervised” or “unsupervised” learning.
Question of the Day: What are different types of machine learning?
In this lesson, students explore an application of AI called Seeing AI and examine how it is supporting people with visual impairments. Then, students research other examples of how AI is impacting society, focusing on users who are impacted by the examples they find. Finally, students share their findings with each other.
Question of the Day: How is AI helping to solve problems around the world?
1) Describe how Artificial Intelligence is having an impact on society
See the activity guide for this lesson as a way to measure each step of the problem solving process.
In this lesson students will examine several apps that make decisions about what shoes to wear, ultimately building up to an understanding of how machine learning can help make this decision. Students are guided to the conclusion that surveying their users can help them make the best decision by looking for patterns in the data and basing their decisions on these patterns.
Question of the Day: What strategies do computer models use to make decisions?
In this lesson students will participate in an unplugged activity simulating one of the machine learning algorithms computers use to separate data into groups to help make decisions. Students will be tasked with helping a computer learn to classify food as fruits or vegetables, graph 20 different fruits on two axes comparing “sweetness” to “easy to eat”, and then try to separate the data into groups - a fruit area, and a veggie area.
Question of the Day: How do computers learn to classify data?
In this lesson students will dive into the AI Lab tool for the first time, where they select features to train a model that predicts a given label. They start by exploring AI Lab and training a model to recognize shapes. Then they pretend they have been hired by several restaurants who would like to make recommendations to new customers based on survey data they’re collected, go through each dataset, and use data visualization tools to identify features with high relationships in the data.
Question of the Day: How can we use machine learning to make recommendations?
In this lesson students are introduced to importing their models into App Lab and linking their model to their screens. They help create a book recommendation app and learn how to add a welcome screen and events to their code. This lesson assumes students are already familiar with App Lab - for classrooms that have not seen App Lab before, consider extending this lesson and including additional videos or activities that are recommended in the lesson plan.
Question of the Day: How can I create an app using machine learning?
In this lesson, students will investigate a model for bias and be introduced to a Model Card, which is a way of representing important information about a trained model that could help uncover bias. They will be investigating a Medical Priority app, which helps a hospital decide how soon to view patients based on their symptoms. As students go through the activity, they realize that the app is biased based on personal information and examine how this could happen.
Question of the Day: How can we evaluate machine learning models once they've been trained?
Students complete the full process of training and saving a model, then importing into App Lab. For the first time, students are able to choose the label they would like to predict and spend time deciding the features they will use to help predict their label of choice. Students also create a model card for their models in order to save them and import it into App Lab
Question of the Day: How can I use Model Cards to document my decisions when training a machine learning model?
In this lesson, students practice importing their models into App Lab, this time including models that have numerical data and using model cards to help improve the user experience of filling out their form. They will then learn how to view the model card within App Lab and use this to add more descriptive elements to an app. Next, they focus on improving the user experience by adding informational text to help guide users through completing the form and adding a style to their app to improve the user experience.
Question of the Day: How can I use a Model Card to improve my app?
In this lesson, students participate in an unplugged activity simulating a zombie outbreak. Students must predict which parts of town have the least amount of zombies using data from a neighboring town. Students will use degrees of similarity and averages to make predictions about the number of zombies at a particular location. Then, students are rescued and get to compare their predictions to the actual numbers as a way to discuss how accuracy is different for numerical data compared to categorical data.
Question of the Day: How do computers learn to make predictions with numerical data?
In this lesson, students will be introduced to numerical data which represents a range of values. Students are presented with a scenario where every feature and label is represented with numerical data, and they learn to use the new data visualization tools within AI Lab to help find patterns.
Question of the Day: How can we use AI Lab to predict numerical data?
In this lesson, students will explore how to customize the code of their app to make additional changes to the design of their app. They will start by exploring a single-screen app and then practice expanding the app to two-screens and updating the code to use the new design mode elements. After this, students help create a Driver Alert app that requires changes to the code using new design mode elements. Using the skills from this lesson, students will be able to create multi-screen apps where questions can appear on multiple screens instead of a single screen.
Question of the Day: How can I customize the code for a machine learning app?
In small groups, students conduct research using articles and videos that expose ethical pitfalls in an Artificial Intelligence (AI) area of their choice. Afterward, each group develops at least one solution-oriented principle that addresses their chosen area. These principles are then assembled into a class-wide “Our AI Code of Ethics” resource (e.g. a slide presentation, document, or webpage) for AI creators and legislators everywhere.
Question of the Day: What are guidelines we can use to create ethical machine learning apps?
In this one or two day project, students apply their skills from the unit so far and create a machine learning app using real-world data. Students are provided with several real-world datasets from a variety of contexts, and they choose which dataset they would like to investigate. They train and save their model, then make a simple App Lab app that uses the model. This mini-project is an opportunity to assess how well students can use features to create accurate machine learning models, and how well they can create apps that use machine learning.
Question of the Day: Can I use real-world data to create an app that uses machine learning?
This is the first of a five-day sequence of lessons that prepare students for the final project. In this lesson, students meet a team of fictional students who want to use machine learning to address an issue in their community. Students participate in an issue brainstorm using the 5 Why's strategy, then they help evaluate the ideas that the other student team came up with. The steps students take in this lesson are identical to the steps students will take in their final project.
Question of the Day: How can machine learning be used to address an issue in your community?
This is the second in a five-day sequence of lessons that prepare students for the final project. In this lesson, students learn that the other team of students would like to create a club recommender app based on the clubs at their school. Students imagine what questions would be most useful to help make this recommendation, then they learn how to use a Google Form template to create a survey. The steps students take in this lesson are identical to the steps students will take in their final project.
Question of the Day: How can I create a survey to gather data for a machine learning app?
This is the third in a five-day sequence of lessons that prepare students for the final project. In this lesson, students learn how to view survey data in Google Sheets and save the data to their computer as a csv file. Then, they upload the saved data to AI Lab and examine the survey results from one of the students to train a model using their data. Then, students use Google Sheets to examine data from another student where the data has errors and then try to fix the errors. The steps students take in this lesson are identical to the steps students will take in their final project, and the problem-solving strategies they develop will help them overcome challenges in their own final project.
Question of the Day: How can I import data into AI Lab to train a machine learning model?
This is the fourth of a five-day sequence of lessons that prepare students for the final project. In this lesson, students examine survey data from other members of the student team and analyze why their models are not working correctly. In examining the data, students develop strategies for avoiding these issues in the future and strategies for coping with these issues should they happen again. These are skills students will use in the final project as they develop their own surveys and collect data.
Question of the Day: What are strategies to make sure our data generates an accurate model?
This is the fifth of a five-day sequence of lessons that prepare students for the final project. In this lesson, students import the club recommender app into App Lab and begin customizing the app. Students add a welcome screen and update the descriptions of each feature, then they can decide how they would like to further customize the app. The steps students take in this lesson are identical to the steps students will take in their final project.
Question of the Day: How can I create a friendly, easy-to-use machine learning app?
To conclude this unit, students develop an AI app that addresses the social issue of their interest. Students follow a project guide to complete this multi-day activity. In the first step, students prepare the data they will use to train their model in AI Lab. After training, testing, and generating a model card, they export their model into App Lab for development. Here they use their model to create a user-friendly app. Students perform a peer review and make any necessary updates to their projects while reflecting on the outcome.
Question of the Day: How can I create an AI App the solves a problem in my community?
Grounded in MCPS Regulation IKA-RA; § refs cite the master regulation. The model gives a daily routine plus daily teacher/parent visibility (Synergy/ParentVue) at low teacher burden.