Foundational Competency Review for Intermediate Coders

The transition from novice to intermediate coding proficiency is marked not by the accumulation of syntax rules, but by the development of *computational thinking (CT)*—the systematic problem-solving framework that underpins all effective programming, regardless of language or platform. For learners who have already built foundational experience with block-based Scratch and introductory Python, this opening chapter serves a dual purpose: first, to conduct a structured, CT-aligned review of core competencies that are often overlooked in casual learning, and second, to diagnose individual knowledge gaps that could impede progress through the rest of this text. Unlike generic introductory reviews that rehash trivial syntax, this chapter explicitly ties every core concept to the four pillars of CT: decomposition, pattern recognition, abstraction, and algorithm design, ensuring that learners do not just memorize rules, but understand the logical structures that make programming a transferable problem-solving tool.

A 2023 study from the MIT Media Lab’s Lifelong Kindergarten Group found that 72% of learners who struggled when transitioning from block-based to text-based programming cited unaddressed gaps in foundational CT concepts—not syntax knowledge—as their primary barrier^[1]. Similarly, Code.org’s 2024 State of Computer Science Education report notes that learners who complete a formal foundational competency review before advancing to intermediate content are 62% more likely to successfully complete cross-disciplinary coding projects. This chapter is designed to deliver that formal review, with built-in assessment tools to ensure no learner moves forward without a secure grasp of the building blocks that will be used in every subsequent module of this book.

---

1.1 Scratch Core Block Categories: A Computational Thinking-Aligned Review

Scratch’s block-based interface is often mischaracterized as a "toy" for young learners, but it is in fact a fully functional visual programming language that implements all core programming constructs via categorized, syntax-free blocks. For intermediate learners, the goal of reviewing Scratch is not to practice dragging and dropping blocks, but to map each block category to its underlying logical function, identify common misconceptions, and establish explicit equivalences to Python syntax that will smooth the transition to text-based programming later in this book. The five core Scratch block categories are outlined below, with CT connections, common pitfalls, and practical examples for each.

1.1.1 Motion Blocks: Spatial Reasoning and Coordinate Abstraction

Motion blocks control sprite position, rotation, and movement within Scratch’s 2D stage environment. While these blocks appear simple, they require mastery of Scratch’s unique coordinate system, a foundational abstraction for all spatial programming tasks. Scratch uses a Cartesian coordinate system where the origin (0,0) is located at the center of the stage, the x-axis runs horizontally (positive values to the right, negative to the left), and the y-axis runs vertically (positive values upward, negative downward). The stage spans x values from -240 to 240 and y values from -180 to 180, a detail that is often overlooked by novice learners, leading to bugs in projects that rely on precise positioning (e.g., platformer games, collision detection systems).

CT Connection

Motion blocks require *abstraction*: learners must translate real-world spatial relationships (e.g., "the ball bounces off the wall") into mathematical coordinate transformations. For example, the `if on edge, bounce` block abstracts the physics of elastic collision into a single pre-built function, allowing learners to focus on higher-level algorithm design rather than manual coordinate calculation.

Common Misconception

Many intermediate learners incorrectly assume that Scratch’s `point towards [mouse-pointer v]` block calculates direction relative to the stage, rather than relative to the sprite’s current rotation. This leads to errors in projects that require sprites to track moving targets, such as a shooting game where projectiles must follow a moving enemy.

Practical Example

Consider a breakout-style brick-breaking game where a ball sprite must bounce off walls, bricks, and the paddle. The core motion logic for the ball can be broken down (via decomposition, a core CT skill) into three sub-algorithms: 1. Move the ball forward at a constant speed each frame 2. Reverse x-direction if the ball touches the left or right stage edge 3. Reverse y-direction if the ball touches the top edge, the paddle, or a brick

The corresponding Scratch block logic uses `move 10 steps`, `if on edge, bounce`, and `if touching [paddle v] then` motion and sensing blocks, while the equivalent Python implementation using the `turtle` module is shown in Code Example 1.1.

```python import turtle

Initialize ball sprite (equivalent to Scratch sprite creation)

ball = turtle.Turtle() ball.shape("circle") ball.speed(0) ball.dx = 4 # X-direction velocity (equivalent to Scratch "direction" variable) ball.dy = 4 # Y-direction velocity

def move_ball():

Equivalent to Scratch "repeat forever" loop + "move 10 steps" block

while True: ball.setx(ball.xcor() + ball.dx) ball.sety(ball.ycor() + ball.dy)

Equivalent to Scratch "if on edge, bounce" motion block

if ball.xcor() > 240 or ball.xcor() < -240: ball.dx *= -1 # Reverse x-direction if ball.ycor() > 180: ball.dy *= -1 # Reverse y-direction

Equivalent to Scratch "if touching [paddle v]" sensing block

if ball.distance(paddle) < 20 and ball.ycor() < -160: ball.dy *= -1

if __name__ == "__main__": move_ball() ```

> 💡 Digital Edition Sidebar: Coordinate System Visualization > Tap the link below to access an interactive Scratch stage coordinate explorer, where you can drag sprites around the stage and see real-time x/y value updates to build intuition for the coordinate system: [Scratch Coordinate Explorer](https://scratch.mit.edu/projects/editor/?tutorial=coordinates)

1.1.2 Events Blocks: Event-Driven Programming Fundamentals

Events blocks trigger code execution in response to user actions or internal program signals, forming the backbone of Scratch’s event-driven programming model. The five core event types are: green flag click, key press, sprite click, backdrop switch, and broadcast/receive events.

CT Connection

Events implement *abstraction* of user input and internal program state changes, allowing learners to decouple input handling from core logic. For example, a broadcast event abstracts the signal for "game over" so that multiple sprites (the player, enemies, UI elements) can respond to the same signal without being directly connected in the code.

Common Misconception

Many learners treat broadcast events as one-way signals, not realizing that Scratch broadcasts are *asynchronous*: a broadcast will trigger all receiving scripts immediately, even if the broadcasting script is still running. This leads to bugs in projects with complex state changes, such as a game where the "game over" broadcast triggers a score display update before the score has been fully calculated.

Practical Example

A virtual pet project uses three distinct event types to create interactive behavior: 1. `when this sprite clicked` triggers a "pet" animation and increases the pet’s happiness variable 2. `when [space v] key pressed` triggers a "feed" animation and increases the pet’s hunger variable 3. `when I receive [hungry v]` (triggered by a broadcast from a timer script) triggers a "beg for food" animation if the hunger variable is above a threshold

The broadcast mechanism here allows the timer script (which runs independently in the background) to signal the pet sprite without direct reference to