Knock, Knock
Experience: 1st year, 2nd quarter
Practice: Creating computational artifacts, Testing and refining computational artifacts, and Communicating about computing
Concept: Algorithms, Control, and Program Development
Length: 50+
Overview and Purpose
Coders use a variety of blocks and sprites to create their own knock, knock joke. The purpose of this project is to reinforce using the wait block to accurately time algorithms running in parallel.
Project Extensions
Suggested extensions
Reverse engineering our example project (10+ minutes each):
1 minute intro demonstration
Demonstrate one of the following example sprites on the board without displaying the code (they are in order of complexity):
- Barn sound
- Chicken
- Pig
- The following sprites include motions corresponding with the recorded voices; these algorithms are long and should be broken down into chunks corresponding for each sound
4+ minute reverse engineering and peer-to-peer coaching
Ask coders to see if they can figure out how to use their code blocks to create an algorithm that makes a sprite do something similar to what was demonstrated. Facilitate by walking around and asking guiding questions.
1 minute explanation demonstration
If coders figured out how to get their sprite to do something similar, have them document in their journal, share with a partner, or have a volunteer show the class their code and thought processes that led to the code. Otherwise, reveal the code, walk through each step of the algorithm, and explain any new blocks.
4+ minute application and exploration
Encourage coders to try something similar, and leave your code up on display while they work. Facilitate by walking around and asking questions about how coders might change their code so it’s not the same as yours.
Resources, suggestions, and connections
Standards reinforced:
- 1A-AP-10 Develop programs with sequences and simple loops, to express ideas or address a problem
- 1A-AP-11 Decompose (break down) the steps needed to solve a problem into a precise sequence of instructions.
- 1A-AP-14 Debug (identify and fix) errors in an algorithm or program that includes sequences and simple loops.
Practices reinforced:
- Communicating about computing
- Testing and refining computational artifacts
- Creating computational artifacts
Concepts reinforced:
- Algorithms
- Control
Video: Suggestions for reverse engineering (4:25)
Note: It is not recommended to show each of these ideas at once, but to show one idea, give time for application and exploration, show another idea, give time for application and exploration, etc. This process could take multiple classes. Also, some of these examples may be difficult for young coders, so go slow and encourage copying and modifying code as it’s good practice.
Alternative suggestion: If reverse engineering is too difficult for the coders you work with, you could display the source code and have coders predict what will happen.
Suggested guiding questions:
- What kind of blocks do you think you might need to do something like that?
- Do you see a pattern where we might use a repeat?
- What trigger blocks do you think I used for that sprite?
- Did I use one trigger block or more than one?
- What makes you think that?
Suggested application and exploration questions:
- What other code blocks could you use?
- What other sprites might use similar code?
- What sounds might you hear in your knock, knock joke?
- What background might the joke have?
- Do you need to create your own or can you use one already made?
Advanced - Using messages instead of wait blocks (30+ minutes):
10+ minute unplugged
Divide the class into 3 groups and have each group come up with an action that lasts no more than two seconds (e.g., a dance move, funny sound, facial expression, stomp feet, clap hands, etc.).
Tell each group they cannot do their action until you give them a message to start their action, and that your message is when you point at their group. Act like a conductor cuing an ensemble and message each group by pointing to each group separately and randomly.
Now tell the class that when group one completes their action, they are to send a message to group two, and so on (1 → 2 → 3 → 1 → repeat). Have the class go through this process for a couple of loops.
Now tell the class they can only do their action when someone sends them a message (individual message, not a group message), and that you’re going to start by only messaging one coder at a time. Once a coder completes their action, they will pick someone else to send a message to by pointing at them. As the process begins add in a couple more people by pointing at others (maybe 3-5 messengers at once).
10+ minute demonstration
Demonstrate how to send a message in ScratchJr and make note that when one sprite sends a message, another sprite needs to receive a message with the same color. Walk through step-by-step how to create a knock, knock joke by sending and receiving each message. Once each part of the joke is completed, explain we add another send message block with a new color to start the next part of a joke.
Sample code:
- Chicken
- Pig
- The following sprites include motions corresponding with the recorded voices; these algorithms are more complicated as it uses parallelism with each message
10+ minute application and exploration
Encourage coders to try and use message in their knock, knock jokes, and leave your code up on display while they work. Facilitate by walking around and asking questions about how coders might change their code so it’s not the same as yours.
Standards reinforced:
- 1A-AP-10 Develop programs with sequences and simple loops, to express ideas or address a problem
Practices reinforced:
- Communicating about computing
- Testing and refining computational artifacts
- Creating computational artifacts
Concepts reinforced:
- Algorithms
- Control
Note: This is recommended only for coders who are doing very well on the projects so far as this is a concept that is introduced much later in our curriculum.
Facilitation suggestion: I would recommend sending a message to everyone at the very end so that everyone has an opportunity to do their action. Yes, this will be chaotic, but it’s better than potential tears and hurt feelings if someone does not receive a message. To reduce the chaos, you could have a message that indicates everyone is to sit down quietly and listen for directions (e.g., turning off the lights).
Facilitation suggestion: You could demonstrate the entire process and then have coders go through it on their own, or you could walk through it step-by-step with the class. If walking through step-by-step have coders get together in pairs or small groups to work together to follow your directions. Once they’ve completed the process on one coder’s project, they will work together to repeat the process on other projects in their group. At that point you could facilitate each group independently.
Adding even more (5+ minutes):
If time permits, encourage coders to explore what else they can create in ScratchJr. Although future lessons will explore different features and blocks, early experimentation should be encouraged.
While facilitating this process, monitor to make sure coders don’t stick with one feature for too long. In particular, coders like to edit their sprites/backgrounds by painting on them or taking photos. It may help to set a timer for creation processes outside of using blocks so coders focus their efforts on coding.
Standards reinforced:
- 1A-AP-10 Develop programs with sequences and simple loops, to express ideas or address a problem
Practices reinforced:
- Testing and refining computational artifacts
- Creating computational artifacts
Concepts reinforced:
- Algorithms
- Control
Suggested questions:
- What else can you do with ScratchJr?
- What do you think the other blocks do?
a. Can you make your sprites do ____? - What other sprites can you add to your project?
a. What else could you add to make the joke funnier? - What sounds could you add to make this project more unique/creative?
- What other trigger blocks might we use?
Similar projects:
Have coders explore the sample projects built into ScratchJr (or projects from other coders), and ask them to find code similar to what they worked on today.
Standards reinforced:
- 1A-AP-10 Develop programs with sequences and simple loops, to express ideas or address a problem
Practices reinforced:
- Testing and refining computational artifacts
Concepts reinforced:
- Algorithms
Note: Coders may need a gentle reminder we are looking at other projects to get ideas for our own project, not to simply play around. For example, “look for five minutes” or “look at no more than five other projects.”
Generic questions:
- How is this project similar (or different) to something you worked on today?
- What blocks did they use that you didn’t use?
a. What do you think those blocks do? - What’s something you like about their project that you could add to your project?
Differentiation
Less experienced coders
ScratchJr is simple enough that it can be picked up relatively quickly by less experienced coders. However, for those who need additional assistance, pair them with another coder who feels comfortable working cooperatively on a project. Once coders appear to get the hang of using ScratchJr, they can begin to work independently.
More experienced coders
Because ScratchJr is not inherently difficult, experienced coders might get bored with simple projects. To help prevent boredom, ask if they would like to be a “peer helper” and have them help out their peers when they have a question. If someone asks for your help, guide them to a peer helper in order to encourage collaborative learning.
Another approach is to encourage experienced coders to experiment with their code or give them an individual challenge or quest to complete within a timeframe.
Debugging Exercises (1-5+ minutes each)
Debugging exercises
Why does the chicken keep interrupting the pig? 1) no parallel motion; 2) with parallel motion
- The parameters for the wait blocks need to be 10, not 1
Why does the pig keep saying the same thing repeatedly? 1) no parallel motion; 2) with parallel motion
- We need to use the three different play sound blocks, not the first one each time
Resources and suggestions
Standards reinforced:
- 1A-AP-14 Debug (identify and fix) errors in an algorithm or program that includes sequences and simple loops
Practices reinforced:
- Testing and refining computational artifacts
Concepts reinforced:
- Algorithms
- Control
Display one of the debugging exercises and ask the class what they think we need to fix in our code to get our project to work correctly. Think out loud what might be wrong (e.g., did I use the wrong trigger block, did I forget to repeat something, did I put a block in the wrong place, am I missing blocks, etc.). Ask the class to talk with a neighbor how we might fix the code. Have a volunteer come up to try and debug the code (or demonstrate how). Repeat with each debugging exercise.
Unplugged Lessons and Resources
Standards reinforced:
- 1A-AP-08 Model daily processes by creating and following algorithms (sets of step-by-step instructions) to complete tasks
Although each project lesson includes suggestions for the amount of class time to spend on a project, BootUp encourages coding facilitators to supplement our project lessons with resources created by others. In particular, reinforcing a variety of standards, practices, and concepts through the use of unplugged lessons. Unplugged lessons are coding lessons that teach core computational concepts without computers or tablets. You could start a lesson with a short, unplugged lesson relevant to a project, or use unplugged lessons when coders appear to be struggling with a concept or practice.
Reflection and Sharing
Reflection suggestions
Coders can either discuss some of the following prompts with a neighbor, in a small group, as a class, or respond in a physical or digital journal. If reflecting in smaller groups or individually, walk around and ask questions to encourage deeper responses and assess for understanding. Here is a sample of a digital journal designed for Scratch (source) and here is an example of a printable journal useful for younger coders.
Sample reflection questions or journal prompts:
- How did you use computational thinking when creating your project?
- What’s something we learned while working on this project today?
- What are you proud of in your project?
- How did you work through a bug or difficult challenge today?
- How did you help other coders with their projects?
- What did you learn from other coders today?
- What’s a fun algorithm you created today?
- What’s something you could create next time?
- What questions do you have about coding?
- What was challenging today?
- How did your storyboard help you plan out your project?
- What did you end up adding that you didn’t originally plan for in your storyboard?
- How can you use code to make projects funny?
- What other jokes could you animate using code?
- What algorithms might you use?
- When would you want to trigger more than one algorithm at the same time?
- More sample prompts (may need adapting for younger coders)
Sharing suggestions
Standards reinforced:
- 1A-AP-15 Using correct terminology, describe steps taken and choices made during the iterative process of program development
Practices reinforced:
- Communicating about computing
- Fostering an inclusive culture
Concepts reinforced:
- Algorithms
- Control
- Modularity
- Program development
Peer sharing and learning video: Click here (1:33)
At the end of class, coders can share with each other something they learned today. Encourage coders to ask questions about each other’s code or share their journals with each other. When sharing code, encourage coders to discuss something they like about their code as well as a suggestion for something else they might add.