Scout's Scratch Expedition Part 2
Click to Start Lesson
Scout's Scratch Expedition Part 2
45min
This lesson is part of a sequential story-driven unit. Students will follow along with a story. Students will add sprites in Scratch and create a sequence to animate a story.
Lesson Preparation
* This lesson represents Part 2 of a 4-part story-based sequence designed to introduce students to programming concepts through Scratch, using Scout as the primary character. To facilitate a seamless teaching experience, we recommend utilizing the Ready-to-Go slides, which are equipped with embedded videos and interactive activities tailored to engage students effectively. These materials are crafted to ensure minimal preparation time while maximizing instructional impact. As this is the beginning of the story arc, focus on familiarizing students with the narrative and basic Scratch functionalities through Scout's adventures.
Lesson Plan
Lesson Slides
Lesson Standards
| Standard | Description |
|---|---|
| AR CS 3: CSK8.G3.5.4 | Identify and correct multiple errors within an algorithm that accomplishes a level-appropriate task or solves a level-appropriate problem. |
| AR CS 4: CSK8.G4.5.4 | Identify and correct multiple errors within an algorithm that accomplishes a level-appropriate task or solves a level-appropriate problem. |
| AR CS 5: CSK8.G5.5.4 | Identify and correct multiple errors within a level-appropriate algorithm. |
| AZ CS 3: 3.AP.M.1 | Decompose problems into smaller, manageable subproblems to facilitate the program development process. |
| AZ CS 3: 3.AP.PD.3 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| AZ CS 5: 5.AP.M.1 | Decompose problems into manageable subproblems to facilitate the program development process. |
| AZ CS 5: 5.AP.PD.3 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| AZ CS K-5: 3.AP.M.1 | Decompose problems into smaller, manageable subproblems to facilitate the program development process. |
| AZ CS K-5: 3.AP.PD.3 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| AZ CS K-5: 5.AP.M.1 | Decompose problems into manageable subproblems to facilitate the program development process. |
| AZ CS K-5: 5.AP.PD.3 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| CA CS 3-5: 3-5.AP.13 | Decompose problems into smaller, manageable tasks which may themselves be decomposed. |
| CA CS 3-5: 3-5.AP.17 | Test and debug a program or algorithm to ensure it accomplishes the intended task. |
| CA CS K-5: 3-5.AP.13 | Decompose problems into smaller, manageable tasks which may themselves be decomposed. |
| CA CS K-5: 3-5.AP.17 | Test and debug a program or algorithm to ensure it accomplishes the intended task. |
| CO CS 5: CS.5.1.2a | Students can decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| CSTA 1B: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| CSTA 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| CT 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| DE 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| FL 3-5 Unplugged CS: SC.4.PE.3.2 | Create a list of steps (algorithm) to solve a real-world problem. |
| FL 3-5 Unplugged CS: SC.K12.CTR.2.1 | Demonstrate understanding by decomposing a problem. |
| FL 3-5 Unplugged CS: SC.K12.CTR.5.1 | Create an algorithm to achieve a given goal. |
| FL CS 3-5: SC.35.CS-CS.2.6 | Write an algorithm to solve a grade-level appropriate problem (e.g., move a character through a maze, instruct a character to draw a specific shape, have a character start, repeat or end activity as required or upon a specific event), individually or collaboratively. |
| FL CS 3-5: SC.35.CS-CS.2.7 | Identify and correct logical errors in algorithms; written, mapped, live action, or digital. |
| FL CS 3-5: SC.35.CS-CS.2.8 | Systematically test and identify logical errors in algorithms. |
| FL GR3 CS Foundations: SC.3.PE.3.3 | Use graphical programming or visual cues to represent a set of instructions (algorithm) that includes repetition. |
| FL GR3 CS Foundations: SC.K12.CTR.2.1 | Demonstrate understanding by decomposing a problem. |
| FL GR3 CS Foundations: SC.K12.CTR.5.1 | Create an algorithm to achieve a given goal. |
| FL GR3 CS Foundations: ELA.K12.EE.4.1 | Use appropriate collaborative techniques and active listening skills when engaging in discussions in a variety of situations. |
| FL GR4 CS Foundations: SC.4.PE.3.2 | Create a list of steps (algorithm) to solve a real-world problem. |
| FL GR4 CS Foundations: SC.K12.CTR.2.1 | Demonstrate understanding by decomposing a problem. |
| FL GR4 CS Foundations: SC.K12.CTR.5.1 | Create an algorithm to achieve a given goal. |
| FL GR5 CS Foundations: SC.5.PE.1.4 | Detect and correct program errors. |
| FL GR5 CS Foundations: SC.K12.CTR.2.1 | Demonstrate understanding by decomposing a problem. |
| FL GR5 CS Foundations: SC.K12.CTR.5.1 | Create an algorithm to achieve a given goal. |
| FL GR5 CS Foundations: ELA.K12.EE.5.1 | Use the accepted rules governing a specific format to create quality work. |
| GA CS 3-5: CSS.CT.3-5.5.3 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| HI 1B: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| HI 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| IA 1B: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| IA 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| IL 3-5: 3-5.AP.11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| IL 3-5: 3-5.AP.15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| IN 3-5 CS 2023: 3-5.DI.1 | Decompose problems and subproblems into parts as a means to solving complex problems. (E) |
| IN 3-5 CS 2023: 3-5.PA.3 | Test and debug (i.e., identify and fix errors) a program or algorithm to ensure it runs as intended. |
| KS CS 3: 3.AP.M.01 | Decompose (break down) the steps needed to solve a problem into a precise sequence of instructions. |
| KS CS 3: 3.AP.PD.03 | Analyze and debug (identify/fix errors) a program that includes sequencing, repetition and variables in a programming language. |
| KS CS 4: 4.AP.M.01 | Decompose (break down) large problems into smaller, manageable subproblems. Then form algorithms to solve each subproblem. |
| KS CS 4: 4.AP.PD.03 | Analyze, debug (identify/fix errors), and create a program that includes sequencing, repetition and variables in a programming language. |
| KS CS 5: 5.AP.M.01 | Decompose (break down) large problems into smaller, more manageable subproblems to facilitate the program development process. |
| KS CS 5: 5.AP.PD.03 | Analyze, debug (identify/fix errors), and create a program that includes sequencing, repetition and variables in a programming language. |
| KY CS K-5: E-AP-08 | Identify and correct errors in an algorithm. |
| KY CS K-5: E-AP-04 | Decompose precise steps needed to solve a problem. |
| KY CS K-5: E-AP-03 | Routinely create programs using a variety of tools to express ideas, address a problem or create an artifact, individually and collaboratively. |
| LA CS K-5: E.AP.3A. | Define and apply decomposition to a complex problem in order to create smaller subproblems that can be solved through step-by-step instructions |
| LA CS K-5: E.AP.4B. | Test and debug a program or algorithm to ensure the program produces the intended outcome. |
| MA DLCS 3-5: 3-5.CT.a.3 | Make a list of sub-problems to consider, while addressing a larger problem. |
| MA DLCS 3-5: 3-5.CT.b.5 | Detect and correct logical errors in various algorithms (e.g., written, mapped, live action, or digital). |
| MA DLCS 3-5: 3-5.CT.d.3 | Use interactive debugging to detect and correct simple program errors. |
| MD CS 3: 3.AP.M.01 | Decompose a simple problem into a precise set of sequenced instructions. |
| MD CS 3: 3.AP.PD.03 | Analyze and debug an existing program or algorithm that includes sequencing, repetition, and variables in a programming language. |
| MD CS 4: 4.AP.M.01 | Decompose a large problem into smaller, manageable sub-problems to facilitate the program development process. |
| MD CS 4: 4.AP.PD.03 | Create and debug a program or algorithm that includes sequencing, repetition, and variables in a programming language. |
| MD CS 5: 5.AP.M.01 | Decompose a large problem into smaller, manageable sub-problems and then further into sets of sequenced instructions to facilitate the program development process. |
| MD CS 5: 5.AP.PD.03 | Create, test, and debug a program that includes sequencing, repetition, and variables in a programming language to ensure it runs as intended. |
| MD CS K-5: 3.AP.M.01 | Decompose a simple problem into a precise set of sequenced instructions. |
| MD CS K-5: 3.AP.PD.03 | Analyze and debug an existing program or algorithm that includes sequencing, repetition, and variables in a programming language. |
| MD CS K-5: 4.AP.M.01 | Decompose a large problem into smaller, manageable sub-problems to facilitate the program development process. |
| MD CS K-5: 4.AP.PD.03 | Create and debug a program or algorithm that includes sequencing, repetition, and variables in a programming language. |
| MD CS K-5: 5.AP.M.01 | Decompose a large problem into smaller, manageable sub-problems and then further into sets of sequenced instructions to facilitate the program development process. |
| MD CS K-5: 5.AP.PD.03 | Create, test, and debug a program that includes sequencing, repetition, and variables in a programming language to ensure it runs as intended. |
| MI CS 3-5: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| MI CS 3-5: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| MO CS 3: 3.AP.PD.03 | Analyze and debug a program that includes sequencing, repetition, and variables in a programming language. |
| MO CS 4: 4.AP.M.01 | Decompose (break down) large problems into smaller, manageable subproblems to facilitate the program development process. |
| MO CS 4: 4.AP.PD.03 | Analyze, create, and debug a program that includes sequencing, repetition, conditionals, and variables in a programming language. |
| MO CS 5: 5.AP.M.01 | Decompose (break down) large problems into smaller, manageable subproblems and then into a precise sequence of instructions. |
| MO CS 5: 5.AP.PD.03 | Analyze, examine, create and debug a program that includes sequencing, repetition, conditionals and variables in a programming language. |
| MS CS 3-5: AP.1B.4 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| MS CS 3-5: AP.1B.8 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| MT CS 1: CS.AP.1.3 | Arrange sequences and simple loops in correct order |
| MT CS 2: CS.AP.2.3 | Develop programs with sequences and simple loops to express ideas or address a problem |
| MT CS 4: CS.AP.4.3 | Test and debug a program or algorithm to ensure it runs as intended |
| MT CS K-5: CS.AP.1.3 | Arrange sequences and simple loops in correct order |
| MT CS K-5: CS.AP.2.3 | Develop programs with sequences and simple loops to express ideas or address a problem |
| MT CS K-5: CS.AP.4.3 | Test and debug a program or algorithm to ensure it runs as intended |
| NC CS 3-5: 35.AP.03 | Construct programs that include sequences. |
| NC CS 3-5: 35.AP.06 | Decompose problems into smaller, manageable, subproblems to facilitate the program development process. |
| NC CS 3-5: 35.AP.10 | Identify and debug erros in an algorithm or program to ensure it runs as intended. |
| ND CS 3: 3.PSA.1 | Solve a task by breaking it into smaller pieces. |
| ND CS 3: 3.PSA.2 | Debug a program that includes sequencing. |
| ND CS 4: 4.PSA.1 | Decompose (break down) a large task into smaller, manageable subtasks. |
| ND CS 4: 4.PSA.2 | Debug a program that includes sequencing or loops. |
| ND CS 5: 5.PSA.1 | Create a sequence of instructions from a previous decomposed task. |
| ND CS 5: 5.PSA.2 | Debug a program that includes sequencing, loops, or conditionals. |
| NE 1 Technology: 1.CS.1 | Create algorithms, or series of ordered steps, to solve problems. |
| NE 1 Technology: 1.CS.2 | Decompose a problem into smaller more manageable parts. |
| NE 1 Technology: 1.CS.8 | Write programs using visual (block-based) programming languages (scratch, code.org). |
| NE 2 Technology: 2.CS.1 | Create algorithms, or series of ordered steps, to solve problems. |
| NE 2 Technology: 2.CS.2 | Decompose a problem into smaller more manageable parts. |
| NE 2 Technology: 2.CS.8 | Write programs using visual (block-based) programming languages (scratch, code.org). |
| NE 3 Technology: 3.CS.1 | Create algorithms, or series of ordered steps, to solve problems. |
| NE 3 Technology: 3.CS.2 | Decompose a problem into smaller more manageable parts. |
| NE 3 Technology: 3.CS.8 | Write programs using visual (block-based) programming languages (scratch, code.org). |
| NE 4 Technology: 4.CS.1 | Create algorithms, or series of ordered steps, to solve problems. |
| NE 4 Technology: 4.CS.2 | Decompose a problem into smaller more manageable parts. |
| NE K Technology: K.CS.1 | Create algorithms, or series of ordered steps, to solve problems. |
| NE K-5 Technology: NE.K5.52 | Create algorithms, or series of ordered steps, to solve problems. |
| NE K-5 Technology: NE.K5.53 | Decompose a problem into smaller more manageable parts. |
| NE K-5 Technology: NE.K5.59 | Write programs using visual (block-based) programming languages (scratch). |
| NH 1B: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| NH 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| NJ CS 3-5: 8.1.5.AP.4 | Break down problems into smaller, manageable sub-problems to facilitate program development. |
| NJ CS 3-5: 8.1.5.AP.6 | Develop programs using an iterative process, implement the program design, and test the program to ensure it works as intended. |
| NM 1B: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| NM 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| NS ICT 3: 3.CCT.b.3 | decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process |
| NS ICT 3: 3.CCT.c.2 | debug (identify and fix) errors in a program that includes sequences, simple loops, events, or conditions |
| NS ICT 4: 4.CT.b.1 | with teacher assistance, students break complex problems into smaller parts and extract key information to facilitate problem-solving. |
| NS ICT 4: 4.CT.c.3 | debug (identify and fix) errors in an algorithm or program that includes sequences, simple loops, events, conditions or variables |
| NS ICT 5: 5.CT.b.1 | break complex problems into smaller parts and extract key information to facilitate problem-solving. |
| NS ICT 5: 5.CT.c.3 | debug (identify and fix) errors in an algorithm or program that includes sequences, simple loops, events, conditions or variables |
| NS ICT 6: 6.CT.b.1 | break complex problems into smaller parts and extract key information to facilitate problem-solving |
| NS ICT 6: 6.CT.c.3 | debug (identify and fix) errors in an algorithm or program that includes sequences, simple loops, events, conditions , variables or functions |
| NV CS 3: 3.AP.PD.1 | Debug (identify and fix) errors in an algorithm or program that includes sequences and loops. |
| NV CS 4: 4.AP.M.1 | Explore how complex tasks can be decomposed into simple tasks and how simple tasks can be composed into complex tasks. |
| NV CS 4: 4.AP.PD.1 | Test and debug (identify and fix) errors in a program or algorithm to ensure it runs as intended. |
| NY CS K-1: K-1.CT.6 | Follow an algorithm to complete a task. |
| NY CS K-1: K-1.CT.9 | Identify and fix (debug) errors within a simple algorithm. |
| NY CS K-6: K-1.CT.6 | Follow an algorithm to complete a task. |
| NY CS K-6: K-1.CT.9 | Identify and fix (debug) errors within a simple algorithm. |
| OH CS 3: ATP.M.3.a | Decompose (i.e., break down) the steps needed or not needed (i.e., abstraction) into precise sequences of instructions to design an algorithm. |
| OH CS 3: ATP.PD.3.b | Using a given program known to contain errors, identify and debug errors to ensure it works. |
| OH CS 4: ATP.M.4.a | Decompose (i.e., break down) the steps needed or not needed (i.e., abstraction) into precise sequences of instructions to design an algorithm. |
| OH CS 4: ATP.PD.4.b | Using guided questions, work through a program to identify errors and discuss possible solutions to repair the program. |
| OH CS 5: ATP.M.5.a | Decompose (i.e., break down) the steps needed or not needed (i.e., abstraction) into precise sequences of instructions to design an algorithm. |
| OH CS 5: ATP.PD.5.b | Using guided questions, work through a program to identify errors and discuss possible solutions to repair the program. |
| OK CS 3: 3.AP.M.01 | Decompose (break down) the steps needed to solve a problem into a precise sequence of instructions. |
| OK CS 3: 3.AP.PD.03 | Analyze and debug a program that includes sequencing, repetition and variables in a programming language. |
| OK CS 4: 4.AP.M.01 | Decompose (break down) large problems into smaller, manageable subproblems to facilitate the program development process. |
| OK CS 4: 4.AP.PD.03 | Analyze, create, and debug a program that includes sequencing, repetition, conditionals and variables in a programming language. |
| OK CS 5: 5.AP.M.01 | Decompose (break down) large problems into smaller, manageable subproblems and then into a precise sequence of instructions. |
| OK CS 5: 5.AP.PD.03 | Analyze, create, and debug a program that includes sequencing, repetition, conditionals and variables in a programming language. |
| PA 1B: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| PA 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| RI CS 1B: 1B-CT-CD-2 | Debug errors in an algorithm or program that includes sequences and simple loops. |
| RI CS K-5: 1B-CT-CD-2 | Debug errors in an algorithm or program that includes sequences and simple loops. |
| SC CS 4: 4.AP.3.2 | Decompose a complex task (e.g., getting ready for school) into simple tasks (e.g., eating breakfast; brushing your teeth; walking to the bus stop). |
| SC CS 5: 5.AP.3.2 | Decompose a complex task of higher complexity (e.g., cooking a meal) into simple tasks (e.g., selecting a recipe, getting the ingredients, preparing the food, and serving the meal, where the task of getting the ingredients can be decomposed into writing a shopping list, going to a store, selecting and buying the ingredients, and going home). |
| SC CS K-5: 4.AP.3.2 | Decompose a complex task (e.g., getting ready for school) into simple tasks (e.g., eating breakfast; brushing your teeth; walking to the bus stop). |
| SC CS K-5: 5.AP.3.2 | Decompose a complex task of higher complexity (e.g., cooking a meal) into simple tasks (e.g., selecting a recipe, getting the ingredients, preparing the food, and serving the meal, where the task of getting the ingredients can be decomposed into writing a shopping list, going to a store, selecting and buying the ingredients, and going home). |
| SD CS 3-5: 3-5.AP.04 | Decompose (break down) problems into subproblems to facilitate the program development process, including incorporating portions of existing programs and proper documentation. |
| Texas 4 Technology Applications: 4.1.D | Debug algorithms (set of procedures) by identifying and removing errors. |
| TN CS 5: 5.AT.2 | Create an algorithm to solve a problem while detecting and debugging logical errors within the algorithm. |
| TN CS 5: 5.PC.2 | Identify bugs (errors) in basic programming. |
| TN CS K-5 2022: 5.AT.2 | Create an algorithm to solve a problem while detecting and debugging logical errors within the algorithm. |
| TN CS K-5 2022: 5.PC.2 | Identify bugs (errors) in basic programming. |
| TX K-5 CS: 4.1.D | Debug algorithms (set of procedures) by identifying and removing errors. |
| UT CS 3: 3.AP.3 | Test and debug a program or algorithm to ensure it accomplishes the intended task. |
| UT CS 3: 3.CT.1 | Decompose problems into smaller manageable tasks which may themselves be decomposed. |
| UT CS K-5: 3.AP.3 | Test and debug a program or algorithm to ensure it accomplishes the intended task. |
| UT CS K-5: 3.CT.1 | Decompose problems into smaller manageable tasks which may themselves be decomposed. |
| VA CS 3: 3.AP.3 | The student will use the iterative design process to create, test, and debug programs containing events, loops, and conditional structures in a block-based programming tool. |
| VA CS 4: 4.AP.3 | The student will use the iterative design process to create, test, and debug programs containing sequencing, loops, variables, user inputs, and conditional control structures in a block-based programming tool. |
| VA CS 5: 5.AP.3 | The student will use the iterative design process to create, test, and debug programs containing sequencing, loops, variables, user inputs, nested conditional control structures, and two-way branching conditional control structures in a block-based programming tool. |
| VA CS K-5: 3.AP.3 | The student will use the iterative design process to create, test, and debug programs containing events, loops, and conditional structures in a block-based programming tool. |
| VA CS K-5: 4.AP.3 | The student will use the iterative design process to create, test, and debug programs containing sequencing, loops, variables, user inputs, and conditional control structures in a block-based programming tool. |
| VA CS K-5: 5.AP.3 | The student will use the iterative design process to create, test, and debug programs containing sequencing, loops, variables, user inputs, nested conditional control structures, and two-way branching conditional control structures in a block-based programming tool. |
| WA 1B: 1B-AP-11 | Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. |
| WA 1B: 1B-AP-15 | Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. |
| WI CS 3-5: AP1.a.5.i | Decompose a larger computational problem into smaller sub-problems independently or in a collaborative group. |
| WI CS 3-5: AP5.a.4.i | Understand there are many resources that can be used or tapped to solve a problem. |
| WI CS 3-5: AP6.a.2.i | Analyze and debug an algorithm, which includes sequencing, events, loops, conditionals, parallelism, and variables. |
| WV CS 3-5: T.3-5.13 | With support and guidance, select appropriate technology tools to solve problems and communicate information. |
| WY CS 3-5: 5.AP.M.01 | Using grade appropriate content and complexity, decompose (break down) problems into smaller, manageable sub-problems to facilitate the program development process. |
| WY CS 3-5: 5.AP.PD.03 | Using grade appropriate content and complexity, test and debug (i.e., identify and fix errors) a program or algorithm to ensure it runs as intended. |