🎯 Learning Objective

By the end of this lesson, students will be able to create Scratch programs that respond to user actions—including keyboard presses, mouse clicks, and sprite interactions—by using event blocks, sensing blocks, and conditional statements (if...then and if...else).

📌 What Is Interactivity?

An interactive program is one that responds to the user's actions in real time. Instead of simply running from start to finish on its own, an interactive program “listens” for events—such as a key being pressed, the mouse being clicked, or a sprite being touched—and reacts accordingly. This is what makes games, apps, and websites feel engaging and responsive.

🎛️ Event Blocks — The “Listeners” of Your Program

Event blocks tell your program when to start running. Think of them as ears that are always listening for something specific to happen. Without event blocks, your scripts would have no trigger and would not run.

New Event Blocks to Learn:

🧠 Conditional Statements — Making Decisions in Code

A conditional statement allows your program to make decisions. It asks a question (a condition), and depending on whether the answer is true or false, it runs different blocks of code.

• if <> then block: Checks a condition. If the condition evaluates to true, the blocks inside are executed. If false, the program skips over those blocks and continues.
• if <> then else block: An extended version. If the condition is true, it runs the first set of blocks. If false, it runs the blocks inside the else section instead. This allows your program to handle both outcomes.
• Nested conditionals: You can place an if block inside another if block to check multiple conditions in sequence.

🔍 Sensing Blocks — How Your Program Gathers Information

Sensing blocks are the tools your program uses to check conditions. They act like the program's senses—detecting what's happening on the stage, what the user is doing, and what state the sprites are in.

Common Sensing Blocks:

📝 Example Project 1: “Pet the Cat”

Concepts used: Event block (when this sprite clicked), conditional (if...then), sensing (touching mouse-pointer?), sound, and looks.

when this sprite clicked
forever
    if <touching [mouse-pointer]?> then
        say [Purr! 🐱] for (1) seconds
        play sound [meow v]
    end
end

How it works:

1. When the user clicks the cat sprite, the script starts.
2. The forever loop keeps checking over and over again.
3. Each time through the loop, the program checks: “Is the cat touching the mouse pointer?”
4. If yes → the cat says “Purr!” and plays the meow sound.
5. If no → nothing happens this time through the loop, and it checks again immediately.

📝 Example Project 2: “Keyboard Mover”

Concepts used: Event block (when green flag clicked), conditional (if...else), sensing (key pressed?), motion.

when green flag clicked
forever
    if <key [right arrow v] pressed?> then
        change x by (10)
    end
    if <key [left arrow v] pressed?> then
        change x by (-10)
    end
    if <key [up arrow v] pressed?> then
        change y by (10)
    end
    if <key [down arrow v] pressed?> then
        change y by (-10)
    end
end

How it works:

1. When the green flag is clicked, the script starts.
2. The forever loop constantly checks which arrow keys are being pressed.
3. Depending on which key is pressed, the sprite moves in that direction by 10 steps.
4. Multiple keys can even be pressed at the same time for diagonal movement!

📝 Example Project 3: “Ask and Respond”

Concepts used: Event block (when green flag clicked), sensing (ask and wait, answer), conditional (if...else), looks, and sound.

when green flag clicked
ask [What is your name?] and wait
if <(answer) = [Alice]> then
    say [Hi Alice! Welcome back! 👋] for (2) seconds
    play sound [pop v]
else
    say (join [Nice to meet you, ] (answer)) for (2) seconds
end

How it works:

1. The program asks the user to type their name.
2. The user's response is stored in the answer variable.
3. The program checks: “Did the user type ‘Alice’?”
4. If yes → a personalized welcome message is shown.
5. If no → a general greeting using the user's name is shown (using the join block to combine text).

🏋️ Practice Activities

1. Interactive Quiz: Create a sprite that asks the user three questions using ask and wait. Use if...else to check if each answer is correct and keep score with a variable.
2. Character Controller: Program a sprite that moves in four directions using arrow keys and plays a different sound for each direction.
3. Mouse Chase Game: Create a sprite that follows the mouse pointer using point towards [mouse-pointer] and move (steps), and use if <touching [mouse-pointer]?> to trigger a “caught you!” message.

🎯 Learning Objective

By the end of this lesson, students will be able to identify, diagnose, and fix errors (bugs) in Scratch programs using systematic debugging strategies. Students will understand the difference between syntax errors, logic errors, and runtime errors.

📌 What Is Debugging?

Debugging is the process of finding, analyzing, and fixing errors (called bugs) in your code. Even professional software engineers spend a significant portion of their time debugging—it is a normal and essential part of programming, not a sign that something went wrong. The word “bug” in computing dates back to 1947, when engineers found an actual moth trapped in a computer relay!

⚠️ Types of Errors

🔧 Debugging Strategies

Strategy 1: Read Your Code Aloud

Slowly read through each block in your script and explain out loud what each block does. Often, saying it out loud will reveal a mismatch between what you meant to code and what you actually coded. You can also explain your code to a partner or even a rubber duck (this is known as “rubber duck debugging”—a real technique used by professional programmers!).

Strategy 2: Test Early, Test Often

Don’t wait until you’ve written 50 blocks of code to test your program. Run and test small parts as you build them. After adding each new feature or block, click the green flag and verify that everything still works as expected. This makes it much easier to pinpoint where things went wrong.

Strategy 3: Use the say Block as a Debugging Tool

Temporarily insert say [message] blocks at key points in your code to track what’s happening. For example:

• Place say "Inside the if block" inside an if statement to verify whether the condition is ever true.
• Place say (variable name) to display the current value of a variable at a specific moment.
• Place say "This point was reached" to confirm that a particular part of your script is actually running.

Strategy 4: Check Your Assumptions

Ask yourself targeted questions:

• Is the sprite I’m working with actually the one with the script, or did I accidentally put the script on the wrong sprite or the stage?
• Is the sprite really touching the color or sprite I think it is? (Use touching [mouse-pointer]? or touching color []? to verify.)
• Is my loop set to repeat the correct number of times? Could it be running forever or stopping too early?
• Are my variables set to the right starting values?
• Did I choose the correct event block to trigger the script?

Strategy 5: Use Scratch’s Built-In Tools

• Green Flag 🟢: Click it to restart your program fresh. Always test from a clean state.
• Red Stop Sign 🛑: Use this to stop all running scripts if something goes into an infinite loop.
• Single Stepping: In Scratch 3.0, you can use “Turbo Mode” (hold Shift + click the green flag) to run scripts at maximum speed, or step through scripts carefully to observe behavior.
• Commenting: Use Scratch’s comment feature (right-click on a block or script area) to leave notes for yourself about what each section is supposed to do.

Strategy 6: Isolate the Problem

If your program is complex, comment out (disable) parts of your code and test smaller sections individually. Once you find which section is behaving incorrectly, focus your debugging efforts there. You can also create a simplified test version of your project with just the problematic code to experiment without distractions.

Strategy 7: Take a Break and Come Back Later

If you’ve been staring at the same code for a while and can’t find the bug, step away for a few minutes. When you come back with fresh eyes, you’ll often spot the error immediately. This is a well-known and effective debugging strategy used by programmers at every level.

Strategy 8: Compare With a Working Version

If you have a version of the project that was working before you made changes, compare the two versions side by side. Look for differences in blocks, values, or structure. This “diffing” approach is commonly used in professional software development.

Strategy 9: Ask a Peer

Sometimes another person can see a bug you’ve missed because they’re looking at your code with fresh eyes. Pair up with a classmate and explain the problem. Even if they don’t solve it for you, the act of explaining the problem often leads you to the solution.

when green flag clicked
forever
    if <touching [edge]?> then
        change color effect by (25)
        if on edge, bounce
    end
end

when green flag clicked
forever
    move (10) steps
    if <touching [edge]?> then
        change color effect by (25)
        if on edge, bounce
    end
end

when green flag clicked
if <key [space v] pressed?> then
    change x by (10)
end

when green flag clicked
forever
    if <key [space v] pressed?> then
        change x by (10)
    end
end