Course D

Course D was made for students who read at about a third-grade level. Videos and hints help explain angles and other math ideas along the way.

The course starts with a review of ideas from Courses A, B, and C. This review helps students remember or learn basic ideas like repeat loops and events. Students will get better at understanding algorithms (lists of steps for finishing a task), nested loops, while loops, conditionals, and events. There are also lessons about being safe and kind online, called digital citizenship. This course helps students build a strong foundation before moving on to new and exciting topics.

Journaling

The lessons in this course include journal writing prompts. Journals are also great for scratch paper — students can use them to build ideas, fix mistakes, and plan out their thinking. Journals can become a great tool to look back on old answers when a new problem feels tricky.

Think Spot Journal Student Handout

Debugging

Everyone from beginners to professional programmers spends time debugging. Debugging means finding and fixing mistakes in code. In fact, most of the time spent "coding" is really spent fixing bugs! To help students take charge of this skill, we give them a handy guide to use while they code. Check the "Debugging" section of our CS Fundamentals Curriculum Guide for more tips and classroom strategies.

Debugging Guide Student Handout

Chapter 1: Sequencing

Lesson 1: Graph Paper Programming — Unplugged | Sequencing
In this lesson, you will program your classmate to draw pictures!

Lesson 2: Introduction to Online Puzzles — Skill Building | Sequencing
This lesson will help you practice the skills you'll need for this course.

Lesson 3: Relay Programming — Unplugged | Sequencing
Remember when you made drawings with code at the start of the course? In this lesson, you will work with a team to do something very similar!

Lesson 4: Debugging with Laurel — Skill Building | Sequencing
Have you ever run into problems while coding? In this lesson, you will learn the secrets of debugging — finding and fixing problems in your code.

Chapter Commentary: Sequencing

Chapter 2: Events

Lesson 5: Events in Bounce — Skill Building | Events
Ever wish you could play video games in school? In this lesson, you get to make your own!

Lesson 6: Build a Star Wars Game — Skill Building | Events
Feel the force as you build your own Star Wars game in this lesson.

Chapter Commentary: Events

Chapter 3: Loops

Lesson 7: Loops in Ice Age — Skill Building | Loops
In this lesson, you'll use the repeat block to help Scrat reach the acorn in the smartest way possible.

Lesson 8: Drawing Shapes with Loops — Skill Building | Loops
In this lesson, loops make it easy to create cool pictures with the Artist!

Lesson 9: Nested Loops in Maze — Skill Building | Loops
Loops inside loops inside loops — what does that mean? This lesson will teach you what happens when you build a nested loop.

Chapter Commentary: Loops

Chapter 4: Conditionals

Lesson 10: Conditionals with Cards — Unplugged | Conditionals
It's time to play a game where you only earn points under certain conditions!

Lesson 11: If/Else with Bee — Skill Building | Conditionals
Now that you understand conditionals, it's time to program Bee to use them while collecting honey and nectar.

Lesson 12: While Loops in Farmer — Skill Building | Conditionals
Loops are so useful in coding. This lesson will teach you about a new kind of loop: while loops!

Lesson 13: Until Loops in Maze — Skill Building | Conditionals
You can do some amazing things using until loops!

Lesson 14: Harvesting with Conditionals — Skill Building | Conditionals
It's not always easy to know which conditional to use. This lesson will help you practice making that choice.

Chapter Commentary: Conditionals

Chapter 5: Binary

Lesson 15: Binary Images — Unplugged | Binary
Learn how computers store pictures using a language with only two options.

Lesson 16: Binary Images with Artist — Skill Building | Binary
In this lesson, you will learn how to make images using only 0s and 1s.

Chapter Commentary: Binary

Chapter 6: Digital Citizenship

Lesson 17: Digital Citizenship — Unplugged | Online Safety
Some information isn't safe to share online. This lesson will help you learn the difference between safe and private information.

Chapter Commentary: Digital Citizenship

Chapter 7: End of Course Project

Lesson 18: Dance Party — End of Course Project
Time to celebrate! In this lesson, you will program your own interactive dance party.

Chapter Commentary: End of Course Project

If you are interested in licensing Code.org materials for commercial purposes, contact us.

---

Lesson 1: Graph Paper Programming

Overview

By "programming" each other to draw pictures, students get to try out some of the main ideas behind computer programming in a fun, easy way. First, students will use symbols to tell each other how to color squares on graph paper, trying to copy a picture exactly. If there's time left, students can finish by making their own pictures for others to copy.

Purpose

This activity builds critical thinking skills and gets students excited for the course. It also introduces basic programming ideas that will be used throughout the course. By teaching ideas like sequencing (putting steps in order) and algorithms through an unplugged activity, even students who feel nervous about computers can build a strong understanding of these ideas. In this lesson, students will learn how to create an algorithm and turn it into a program.

Agenda

• Warm Up (10 min): Introduction to Graph Paper Programming
• Main Activity (30 min): Practice Together, The Students' Turn
• Wrap Up (15 min): Journaling / Flash Chat
• Optional Assessment (10 min): Extended Learning

Objectives

Students will be able to:

• Turn a sequence of steps into a coded program
• Explain the challenges of turning problems written in human language into a "machine language"

Preparation

• (Optional) Watch the Lesson in Action video.
• Print one worksheet and one assessment for each student.
• Make sure every student has a journal.

Vocabulary

• Algorithm — A list of steps used to finish a task.
• Program — An algorithm that has been coded so a machine can run it.

---

Teaching Guide

Warm Up (10 min): Introduction to Graph Paper Programming

In this activity, students give each other coded instructions to help draw a picture — without letting their partner see the original image first. This warm-up sets up the activity for the rest of the class.

Display: Watch one of these videos to show students the kinds of things robots can do:

• Asimo by Honda (3:58)
• Dancing Lego Robot (1:35)

Discuss: How do you think robots know how to do the things they do? Do they have brains that work like ours?

Guide the discussion toward the idea that people have to program robots to do specific things, using specific commands.

Discussion goal: The point of this quick discussion is to show that even though robots may seem to act like people, they are really just following their programming. Students might mention robots from movies or TV that act like humans. Encourage them to think about real robots too, like Roombas or digital assistants such as Amazon Alexa.

Main Activity (30 min): Practice Together

In this activity, students take turns being the "programmer" and the "robot," coloring squares based on programs they write for each other.

Distribute: Give students 4x4 grids (or graph paper with 4x4 boxes marked off), plus the image worksheet.

Display: Show these commands, or write them on the board. Students won't need to remember them long, but the commands will help them see how an algorithm turns into a program:

• Move one square right
• Move one square left
• Move one square up
• Move one square down
• Fill in square with color

Say: "Today, we all get to program robots — and they're already here in the room! It's you! We're going to write programs using symbols with special meanings, to help each other recreate a picture. First, we'll practice together, with me as the robot and you as the programmers. Then we'll break into groups so everyone gets a turn."

Display: Show the picture the class will walk you through, along with a blank grid you will color in using your "ARM." Keep the instructions, grid, and image all visible at the same time.

Remarks: Here is a picture. Pretend I am a robot with an Automatic Realization Machine, or "ARM." These are the only instructions I understand. Starting at the top-left corner, tell my ARM out loud what to do.

Model: Students might give instructions like these. Each time you hear an instruction you plan to follow, repeat it out loud so students can track what you're doing:

• Move One Square Right
• Fill In Square with Color
• Move One Square Right
• Move One Square Down
• Fill In Square with Color

Keep going until the sample picture is finished.

Capture: Write down each command so students can see every step that went into making the picture.

Say: "You just gave me a list of steps to finish a task. In programming, we call that an algorithm. Algorithms are great because they're easy for you, the programmer, to understand. But what happens when we want to write down the algorithm for a picture like this one?"

Display: Show students a more complicated picture. Begin writing out the instructions it would take to copy that image. Students will likely notice that spelling out every single step would take a very long time — maybe a dozen or more extra instructions!

Display: Show students this list of symbols.

Teaching tip: Notice that the program is written left to right, the same way you'd read a book in English. Some students may prefer this. Others like to start a new line of instructions for each row of the grid. How students write their program matters less than whether their teammates can follow it!

Discussion: How could we use these symbols to make our instructions shorter and easier?

Guide students toward the idea of turning spoken instructions into symbols. Once they get there, explain that switching from listing every detailed step to using symbols instead is called "programming." For example, the sentence:

"Move one square right, move one square right, fill in square with color"

...can now be written as a short program using symbols.

Model: Now have the class help you draw the larger image using only symbols.