Module 1: Your First Steps into Scratch

What You'll Learn: How to open Scratch, what all the buttons do, and how to make your first sprite move .

• Definition & Importance: Getting comfortable with the interface is your first step to creating anything.
• Simple Explanation: Think of Scratch like a digital playground where you are the boss.
• Real-Life Example: A teacher opens Scratch to show the class how to program a character to dance.
• School Example: You log in to Scratch for the first time and explore the "Sprites" and "Backdrops" panes.
• Home Example: You and a sibling drag a block to make the cat meow.
• Nigerian Example: A student in Kano creates a simple animation of a "Danfo" bus moving across the screen.
• Illustration:

SCRATCH INTERFACE
+-----------------------------------+
|  [Blocks Palette]  [Code Area]    |
|   - Motion                         |
|   - Looks          [Sprite Area]  |
|   - Sound                          |
|   - Events                         |
|   - Control                        |
+-----------------------------------+
                    

• Mini summary: This module gets you comfortable with the tools you'll use to build everything else.

Module 2: Motion and Looks – Bringing Your Sprites to Life

What You'll Learn: Make your characters move, glide, change costumes, and say things .

• Definition & Importance: Motion blocks control movement. Looks blocks change how a sprite appears. This makes your story interactive!
• Simple Explanation: It's like giving your characters stage directions in a play.
• Real-Life Example: Creating a digital pet that walks around and talks to you .
• School Example: Making a frog sprite glide across a pond backdrop.
• Home Example: Making a family member's sprite wave and say "Hello!"
• Nigerian Example: Making a sprite of a "Mama Put" seller greet the player.
• Illustration:

MOTION & LOOKS BLOCKS
+-----------------------------------+
| Move 10 steps                     |
| Turn 15 degrees                   |
| Go to x: 0 y: 0                  |
| Say "Hello!" for 2 seconds       |
| Switch costume to [costume2]     |
+-----------------------------------+
                    

• Mini summary: These are the tools to animate your characters and tell your story.

Module 3: Events and the Green Flag – Starting the Show

What You'll Learn: How to trigger your code with events like clicking the green flag or pressing a key .

• Definition & Importance: Events tell Scratch "When to start." Without them, your code won't run.
• Simple Explanation: The "When green flag clicked" block is like the "Start" button on a video game.
• Real-Life Example: Clicking "Play" on a streaming service starts your movie.
• School Example: Pressing the spacebar to make a character jump.
• Home Example: Pressing a key to change the background music.
• Nigerian Example: Programming the game to start when you click the green flag after reading the instructions.
• Illustration:

EVENT BLOCKS
+-----------------------------------+
| When green flag clicked           |
| When [space] key pressed          |
| When this sprite clicked          |
| When backdrop switches to [...]  |
+-----------------------------------+
                    

• Mini summary: Events are the triggers that make your project interactive.

Module 4: Sound – Adding Music and Effects

What You'll Learn: How to add sound effects, background music, and voice recordings to your projects.

• Definition & Importance: Sound makes your game or story more immersive and exciting.
• Simple Explanation: It's like adding a soundtrack to a movie.
• Real-Life Example: A video game where you hear a "ding" when you collect a coin.
• School Example: Recording your own voice to narrate a story.
• Home Example: Adding a "pop" sound when a balloon sprite bursts.
• Nigerian Example: Adding "kolo" sound effects for a comedy skit animation.
• Illustration:

SOUND BLOCKS
+-----------------------------------+
| Play sound [Meow]                 |
| Play sound [Meow] until done     |
| Stop all sounds                   |
| Change volume by -10              |
+-----------------------------------+
                    

• Mini summary: Sound turns a simple project into an experience.

Module 5: Control – Making Decisions with If-Then and Loops

What You'll Learn: Use "forever" loops to keep things going, and "if-then" blocks to make decisions .

• Definition & Importance: Loops repeat actions. Conditionals let your program make decisions based on something (like "If the score is 10, then you win!").
• Simple Explanation: A "forever" loop is like a record player that keeps spinning. An "if" block is like choosing between wearing a raincoat or sunglasses based on the weather.
• Real-Life Example: A thermostat checks if the room is too cold, then turns on the heat.
• School Example: Using "if-then" to make a sprite say "You got it!" when the player touches a star.
• Home Example: A "forever" loop to make a fan rotate on your screen.
• Nigerian Example: In a game, if a player touches a "pothole" sprite, they lose a life.
• Illustration:

CONTROL BLOCKS
+-----------------------------------+
| wait 1 seconds                    |
| repeat 10 times                   |
| forever                           |
| if <condition> then                |
| if <condition> then ... else ...   |
+-----------------------------------+
                    

• Mini summary: Control blocks give your code logic and the ability to make choices.

Module 6: Sensing – Making Your Program Aware of the World

What You'll Learn: How to use sensors to detect when sprites touch, use a mouse, or ask for user input .

• Definition & Importance: Sensing blocks let your program "see" and "hear" what's happening.
• Simple Explanation: It's like giving your program eyes and ears.
• Real-Life Example: An automatic door sensor that opens when you walk near it.
• School Example: A quiz game that uses a "ask and wait" block to get the player's answer.
• Home Example: A game where the mouse pointer is used to control a character.
• Nigerian Example: A scavenger hunt game where you must click on a specific sprite to win.
• Illustration:

SENSING BLOCKS
+-----------------------------------+
| touching [mouse-pointer]?        |
| touching [sprite1]?              |
| ask "What's your name?" and wait |
| mouse x                          |
| key [space] pressed?             |
+-----------------------------------+
                    

• Mini summary: Sensing makes your project interactive and responsive to the user.

Module 7: Variables – Keeping Score and Remembering Things

What You'll Learn: How to create and use variables to store information, like a score, lives, or player name .

• Definition & Importance: A variable is like a box where you can store a number or a piece of text.
• Simple Explanation: It's like a scoreboard that keeps track of points.
• Real-Life Example: A shopping list – it "stores" the items you need to buy.
• School Example: Creating a "score" variable that increases by 1 every time the player collects a coin.
• Home Example: A variable called "guessCount" that counts how many tries it takes to guess a number.
• Nigerian Example: A game where your "fuel" variable decreases as your car moves.
• Illustration:

VARIABLE BLOCKS
+-----------------------------------+
| set [score] to 0                  |
| change [score] by 1               |
| show variable [score]             |
| hide variable [score]             |
+-----------------------------------+
                    

• Mini summary: Variables are the memory of your program.

Module 8: Lists – Working with Big Collections of Data

What You'll Learn: How to create and use lists to store multiple things, like a high-score table or a shopping list of items .

• Definition & Importance: A list is a variable that can hold multiple pieces of information at once. It's like a box with many compartments.
• Simple Explanation: It's like a treasure chest that can hold many different gems.
• Real-Life Example: A playlist of songs on your phone.
• School Example: Storing the names of all the players who finished a game.
• Home Example: Creating a list of your favorite movies.
• Nigerian Example: A list of all the states in Nigeria and their capitals for a geography quiz.
• Illustration:

LIST BLOCKS
+-----------------------------------+
| add "thing" to [list]             |
| delete 1 of [list]                |
| item 1 of [list]                  |
| length of [list]                  |
| [list] contains "thing"?          |
+-----------------------------------+
                    

• Mini summary: Lists let you manage collections of data.

Module 9: My Blocks (Functions) – Building Your Own Tools

What You'll Learn: How to create your own custom blocks (functions) to make your code cleaner and reusable .

• Definition & Importance: "My Blocks" let you give a name to a group of commands. This is called a function or procedure.
• Simple Explanation: It's like creating your own magic spell that does exactly what you want.
• Real-Life Example: A recipe – you can call it a "Pancake Recipe" instead of listing all the ingredients and steps each time.
• School Example: Creating a "jump" block that makes a sprite jump and play a sound.
• Home Example: Making a "greetFriend" block that says "Hello!" and waves.
• Nigerian Example: Creating a "celebrateGoal" block that plays a victory sound and changes the score.
• Illustration:

MY BLOCKS (FUNCTIONS)
+-----------------------------------+
| Define [jump]                     |
|   change y by 10                  |
|   wait 0.1 seconds                |
|   change y by -10                 |
+-----------------------------------+
                    

• Mini summary: My Blocks let you build advanced programs by reusing your own code.

Module 10: Building Your Final Game – Putting It All Together

What You'll Learn: How to plan, build, and test your own complete game project from start to finish .

• Definition & Importance: This is where you take all the skills you've learned and combine them to create something unique.
• Simple Explanation: It's like building your own toy from a box of parts.
• Real-Life Example: A game development company planning and building a new video game.
• School Example: Building a maze game with a timer, score, and multiple levels.
• Home Example: Creating a game that you and your friends can play together.
• Nigerian Example: Creating a game about navigating traffic in Lagos, with "danfo" buses and "okada" bikes.
• Illustration:

FINAL PROJECT: MY GAME
+-----------------------------------+
| 1. Plan Game Idea                |
| 2. Design Sprites & Backdrops    |
| 3. Code the Player Movement      |
| 4. Add Obstacles & Enemies       |
| 5. Add Scoring & Levels          |
| 6. Test & Debug                  |
| 7. Share Your Game!              |
+-----------------------------------+
                    

• Mini summary: This module is your chance to become a real game developer.

🇳🇬 Nigerian Examples

• A student in Abuja creates a quiz game about Nigerian presidents.
• A teacher in Ibadan builds a story-telling app about local folklore.
• A student in Lagos creates a game where you have to avoid "pothole" sprites.
• A teenager designs a virtual market where you trade yams and tomatoes.

🎈 Fun Examples for Kids

• Make a virtual pet that follows your mouse.
• Create a "Dance Party" where sprites move to music .
• Build a simple "Catch the Apple" game.
• Design a "Choose Your Own Adventure" story.

🧾 Remember This

• Always save your work!
• Start with small, simple projects and build up.
• It's okay to make mistakes – that's how you learn .

⚠️ Common Mistakes

• Forgetting to connect blocks together properly.
• Not using a "wait" block when needed, so the program runs too fast.
• Using too many sprites and making the project too complex.

✅ Best Practices

• Name your sprites and variables clearly.
• Add comments to your code to explain what it does .
• Test your code often.

🔗 Matching Exercise

Match the term with its description:

• 1. Sprite → (A) A container for storing data, like a score.
• 2. Variable → (B) A character or object in your project.
• 3. Loop → (C) Repeats an action.

Answers: 1‑B, 2‑A, 3‑C

🎭 Scenario-based Exercise

Scenario: You want to make a game where a character collects stars. Every time the character touches a star, the score goes up by 1. What blocks from which categories would you use?

Hint: You would use sensing (touching), variables (score), and control (if-then).

1. Cloning – Making Copies of Sprites

Definition: Cloning means creating a copy (clone) of a sprite while the program is running.

Why important? Clones let you have many enemies, bullets, or items without adding many sprites to the stage.

Simple explanation: Imagine you have a magic mirror that can create a copy of you. That's cloning!

Real-life example: In a game, when an enemy appears, a clone is created from the original enemy sprite.

School example: Creating a "bubble pop" game where many bubbles appear using clones.

Home example: A virtual garden where every flower you plant is a clone.

Nigerian example: A game where "danfo" buses appear as clones and you have to avoid them.

Illustration:

CLONING PROCESS
+-----------------------------------+
| Original Sprite (Enemy)           |
|      |                            |
|      V                            |
| "create clone of [myself]"       |
|      |                            |
|      V                            |
| Clone appears!                    |
|      |                            |
|      V                            |
| Clone does its own thing          |
+-----------------------------------+
                

Mini summary: Cloning lets you create many copies of a sprite, making complex games possible.

2. Clone Events – Controlling Your Copies

Definition: The "when I start as a clone" block is used to give each clone its own instructions.

Why important? Without this block, all clones would just sit there and do nothing.

Simple explanation: When a clone is born, you tell it what to do.

How it works: After creating a clone, Scratch runs the "when I start as a clone" block for that clone.

School example: A clone of a butterfly flies to a random position on the screen.

Nigerian example: A clone of a "masquerade" sprite dances and moves around the stage.

Mini summary: Clone events give each clone its own life.

3. Clone Limits – Managing Your Copies

Definition: Scratch allows a maximum of 300 clones at a time.

Why important? Too many clones can slow down your game.

Simple explanation: You can only create 300 copies before Scratch says "Enough!"

Best practice: Always delete clones when they are no longer needed using the "delete this clone" block.

School example: In a game, when a bullet goes off-screen, delete it.

Nigerian example: In a traffic game, delete buses that leave the screen.

Mini summary: Manage your clones so your game stays fast and smooth.

4. Cloud Variables – Storing Data Online

Definition: Cloud variables are special variables that save their value on the Scratch website, not just on your computer.

Why important? They allow you to save high scores, and they are shared with everyone who plays your game.

Simple explanation: A cloud variable is like a sticky note that stays on the wall, even after you leave the room.

How to use: Cloud variables have a cloud icon next to them. The value is saved online.

Real-life example: A high score board in an arcade game.

School example: A class competition where the highest score is saved for everyone to see.

Nigerian example: A game where the top score is saved and all players in Nigeria can compete.

Illustration:

CLOUD VARIABLE
+-----------------------------------+
| [Cloud Score] = 1500             |
|      |                            |
|      V                            |
| Saved on Scratch Servers         |
|      |                            |
|      V                            |
| Anyone can see it!               |
+-----------------------------------+
                

Mini summary: Cloud variables let you save and share data online.

5. Cloud Variable Limits – Rules of the Cloud

Definition: Cloud variables have rules: you can only have 10 of them, and each can only store a number (no text).

Why important? Knowing the limits helps you plan your game.

Simple explanation: You have 10 cloud boxes, and they can only hold numbers.

How to use wisely: Use one cloud variable for the high score, and maybe another for the current champion's name (using a trick).

School example: A quiz game that keeps track of the highest score.

Nigerian example: A game where the top scorer's name is displayed as a number code.

Mini summary: Use cloud variables wisely – you have a limited number.

6. Custom Blocks with Inputs – Super-Powered Functions

Definition: You can create custom blocks that accept inputs (parameters) – like a number or a piece of text.

Why important? This makes your custom blocks much more powerful and reusable.

Simple explanation: It's like having a magic wand that can turn anything into a frog – you just have to say what!

How to create: In "My Blocks", click "Options" and add number or text inputs.

Real-life example: A block called "move [number] steps" – the input is the number of steps.

School example: A block called "draw [size]" that draws a square of a specific size.

Nigerian example: A block called "celebrate [player_name]" that says "Player X wins!"

Illustration:

CUSTOM BLOCK WITH INPUT
+-----------------------------------+
| Define [square] [size]           |
|   repeat 4                      |
|     move [size] steps            |
|     turn 90 degrees              |
|   end                            |
+-----------------------------------+
                

Mini summary: Inputs make your custom blocks flexible and powerful.

7. Recursion – A Block That Calls Itself

Definition: Recursion is when a custom block calls itself (runs itself).

Why important? It can solve problems that repeat inside themselves – like drawing fractals.

Simple explanation: Like a mirror reflecting a mirror reflecting a mirror – it goes on forever.

How to use carefully: Always have a condition to stop the recursion, or it will never end.

Real-life example: A Russian nesting doll – each doll contains a smaller doll.

School example: Drawing a fractal tree that branches smaller and smaller.

Nigerian example: Creating a pattern that repeats smaller and smaller, like "adire" cloth designs.

Illustration:

RECURSION (Fractal Tree)
+-----------------------------------+
| Define [tree] [size]              |
|   if [size] > 5 then              |
|     move [size] steps             |
|     turn 45 degrees               |
|     tree [size * 0.7]            |
|     turn -90 degrees              |
|     tree [size * 0.7]            |
|     turn 45 degrees               |
|   end                             |
+-----------------------------------+
                

Mini summary: Recursion is a powerful technique, but use it with care.

8. Game Design Principles – Making Fun Games

Definition: Game design is the art of making games that are fun, balanced, and engaging.

Why important? Even the most complex code is useless if the game isn't fun.

Key principles:

• Clear goal: The player should know what to do (e.g., "Collect 10 stars").
• Feedback: The game should respond to the player's actions (sounds, points, messages).
• Challenge: The game should be hard enough to be interesting, but not impossible.
• Progression: Levels get harder as the player gets better.

Nigerian example: A game where you have to collect "balls" (balls) while avoiding "gbejere" (trouble).

Mini summary: Good game design keeps players coming back for more.

9. User Interface (UI) Design – Making It Look Good

Definition: UI design is about making your game's screen look clear, organized, and appealing.

Why important? A good UI helps players understand the game.

Tips:

• Use clear fonts and colors.
• Show important information (score, lives) prominently.
• Use buttons that are easy to click.
• Keep the screen from getting too cluttered.

School example: A score counter in the top left corner of the screen.

Nigerian example: A game where the life counter is a row of "tankers" (small images).

Mini summary: A clear UI makes your game easy and enjoyable to play.

10. Multiplayer Games – Playing Together

Definition: Multiplayer games allow more than one person to play at the same time.

Why important? They are more social and often more fun.

How to make: Use different keys for each player (e.g., WASD for Player 1, arrow keys for Player 2).

Real-life example: A two-player racing game.

School example: A group project where two students control different sprites.

Nigerian example: A "throw-down" game where two players compete in a wrestling match.

Illustration:

MULTIPLAYER CONTROLS
+-----------------------------------+
| Player 1: WASD keys              |
| Player 2: Arrow keys             |
| Both sprites move independently   |
+-----------------------------------+
                

Mini summary: Multiplayer games bring people together.

11. Advanced Broadcasting – Communication Between Sprites

Definition: Broadcasting messages allows sprites to send signals to each other.

Why important? It's how sprites "talk" to each other.

Simple explanation: Like sending a text message to your friend.

How to use: "broadcast [message]" and "when I receive [message]" blocks.

Real-life example: In a game, when the player wins, a message is broadcast to show the victory screen.

Nigerian example: A game where a "messenger" sprite broadcasts a message to start a celebration.

Mini summary: Broadcasting is a powerful way to coordinate sprites.

12. Planning Your Expert Game – From Idea to Reality

Definition: Planning is the process of thinking through your game before you start coding.

Why important? It saves you time and frustration.

Steps to plan:

• Brainstorm: Write down all your ideas.
• Choose the best: Pick one idea that excites you.
• Break it down: List all the features (e.g., sprites, scoring, levels).
• Plan the code: Think about which blocks you will use.
• Test as you go: Build and test small parts of the game.

Nigerian example: Planning a game about "Nigeria's Independence" with a timeline of events.

Mini summary: Good planning is the secret to building amazing games.

🇳🇬 Nigerian Examples

• A student creates a game with "okada" clones that the player must avoid.
• A teacher uses a cloud variable for a class-wide high score competition.
• A kid creates a "market" game where you sell items and the price changes.

🎈 Fun Examples for Kids

• A game where you clone yourself and have a dance-off.
• A "garden" where each flower is a clone.
• A game where you use recursion to draw a beautiful snowflake.

🧾 Remember This

• Clones are powerful – use them wisely.
• Cloud variables are shared – be careful what you put in them.
• Recursion needs a stopping condition.

⚠️ Common Mistakes

• Creating too many clones and slowing down the game.
• Forgetting to delete clones when they are off-screen.
• Using recursion without a stop condition (infinite loop).

✅ Best Practices

• Use a "delete this clone" block when a clone is no longer needed.
• Name your cloud variables clearly.
• Test small parts of your code before building the whole game.

🔗 Matching Exercise

Match the term with its description:

• 1. Clone → (A) A block that calls itself
• 2. Cloud Variable → (B) A copy of a sprite
• 3. Recursion → (C) A variable stored online

Answers: 1‑B, 2‑C, 3‑A

🎭 Scenario-based Exercise

Scenario: You want to create a game where many enemies (clones) chase the player. The player's score is saved online as a high score. How would you use cloning and cloud variables?

Hint: Use clones for enemies and a cloud variable for the high score.

1. What Are Extensions?

Definition: Extensions are extra sets of blocks that add new features to Scratch.

Why important? They allow Scratch to interact with the outside world – cameras, microphones, and even robots.

Simple explanation: Think of extensions as add-ons for a video game. They give you new powers and abilities.

How to add: Click the blue "Add Extension" button at the bottom left of the Blocks Palette.

Real-life example: A DJ uses a music extension to create a virtual drum kit.

School example: A teacher uses the video sensing extension to create a "virtual" dance competition.

Nigerian example: A student uses the Translate extension to create a game that teaches English and Yoruba.

Illustration:

ADDING EXTENSIONS
+-----------------------------------+
| Scratch Interface                 |
|   [Blocks Palette]                |
|       (add extension)  →  Click  |
|          |                        |
|          V                        |
| Choose from list:                 |
|   Music, Video, Translate, etc.   |
+-----------------------------------+
                

Mini summary: Extensions are like adding new tools to your coding toolbox.

2. Music Extension – Creating Melodies

Definition: The Music extension lets you play musical notes, drums, and change instruments.

Why important? It turns Scratch into a music studio.

Simple explanation: It's like having a piano and a drum kit in your program.

Key blocks: "play note [60] for [0.5] beats", "set instrument to [1]", "play drum [1] for [0.5] beats".

Real-life example: A musician uses it to compose a simple tune.

School example: Students create a song about a topic they are learning.

Nigerian example: A student creates a virtual "talking drum" using the Music extension.

Illustration:

MUSIC BLOCKS
+-----------------------------------+
| play note [60] for [0.5] beats   |
| set instrument to [1]             |
| play drum [1] for [0.5] beats     |
| change tempo by [20]              |
| set tempo to [120] bpm            |
+-----------------------------------+
                

Mini summary: The Music extension lets you create your own songs and sounds.

3. Video Sensing – Motion-Controlled Projects

Definition: The Video Sensing extension uses your webcam to detect motion and track your body.

Why important? It lets you create projects that respond to your movements.

Simple explanation: Your webcam becomes a magic wand that controls your game.

Key blocks: "when video motion > [10]", "video [on] on sprite", "set video transparency to [50]".

Real-life example: A fitness app that counts your exercises.

School example: A game where you catch objects by moving your hand.

Nigerian example: A game where you wave to start a traditional dance.

Illustration:

VIDEO SENSING BLOCKS
+-----------------------------------+
| when video motion > [10]          |
| video [on] on sprite              |
| set video transparency to [50]    |
| turn video [on]                   |
+-----------------------------------+
                

Mini summary: Video sensing lets you control projects with your body.

4. Text-to-Speech – Making Sprites Talk

Definition: The Text-to-Speech extension lets your sprites speak typed text in a computer-generated voice.

Why important? It makes projects more interactive and accessible.

Simple explanation: It's like giving your sprites a voice!

Key block: "speak [Hello, world!]".

Real-life example: A virtual assistant that reads the news.

School example: A talking dictionary for learning new words.

Nigerian example: A project that teaches how to pronounce Yoruba words.

Mini summary: Text-to-speech gives your sprites a voice.

5. Translate Extension – Speaking Many Languages

Definition: The Translate extension translates text from one language to another.

Why important? It allows you to build multilingual projects for a global audience.

Simple explanation: It's like having a personal translator!

Key blocks: "translate [Hello] to [Spanish]", "language of [Hello]".

Real-life example: A travel app that helps you say phrases in different languages.

School example: A quiz that asks questions in both English and French.

Nigerian example: A game that teaches English to Hausa speakers.

Mini summary: Translate helps you reach a wider audience.

6. Hardware Extensions – Connecting to the Physical World

Definition: Hardware extensions allow Scratch to connect to physical devices like the micro:bit, LEGO WeDo, and Raspberry Pi.

Why important? They bridge the gap between the digital and physical worlds.

Simple explanation: Your code can make real-world things happen!

micro:bit example: Use the micro:bit's buttons and sensors to control a Scratch game.

LEGO example: Use LEGO motors to move a physical car.

Nigerian example: A student uses a micro:bit to create a traffic light system.

Illustration:

HARDWARE CONNECTION
+-----------------------------------+
| Scratch Code  --->  micro:bit    |
|      |                            |
|      V                            |
| Physical Device (LED, motor)     |
|      |                            |
|      V                            |
| World changes!                    |
+-----------------------------------+
                

Mini summary: Hardware extensions let you control real objects with code.

7. Using micro:bit with Scratch

Definition: The micro:bit extension provides blocks to interact with the micro:bit's buttons, accelerometer, and LEDs.

Why important? You can make projects that respond to physical actions like shaking or button pressing.

Key blocks: "when [A] button pressed", "micro:bit is shaken?", "display [heart]".

School example: A game where you tilt the micro:bit to steer a character.

Nigerian example: A device that measures the strength of a handshake and displays it on screen.

Mini summary: micro:bit brings your code to life in the real world.

8. LEGO WeDo – Building and Coding

Definition: The LEGO WeDo extension lets you control LEGO motors and sensors.

Why important? It combines building with coding – you can make moving machines!

Key blocks: "turn motor on for [1] seconds", "when distance sensor < [10]".

Real-life example: A robot that moves when you clap your hands.

School example: Students build a LEGO car and program it to stop when it reaches a line.

Nigerian example: A LEGO crane that lifts objects when a button is pressed.

Mini summary: LEGO WeDo lets you build and code physical creations.

9. Combining Extensions – Super Projects

Definition: You can use multiple extensions in one project to create amazing experiences.

Why important? The combination is more powerful than each extension alone.

Simple explanation: Like combining ingredients to make a delicious meal.

Example: Use Video Sensing + Music + Text-to-Speech to create a project that changes music based on your movements and speaks the lyrics.

Nigerian example: A project that uses Video Sensing to detect a dance move, plays a drum sound, and says "Oti o je!" in Yoruba.

Mini summary: Combining extensions creates rich, interactive projects.

10. Planning a Real-World Project

Definition: Planning means thinking about your project before you start coding.

Why important? Good planning saves time and makes your project better.

Steps:

• Define your goal: What do you want to achieve?
• Choose extensions: Which extensions do you need?
• Design the user experience: How will people interact?
• Plan the code: What blocks will you use?
• Build and test: Create small parts and test them.

Nigerian example: A student plans a "Smart Classroom" project using micro:bit sensors to monitor temperature.

Mini summary: Planning is the first step to a successful real-world project.

11. Debugging Hardware Projects

Definition: Debugging means finding and fixing problems in your project.

Why important? Hardware projects can have extra problems (like connection issues).

Tips:

• Check connections: Is your hardware connected properly?
• Test small: Test one block at a time.
• Use "say" blocks: Show values on screen to see what's happening.
• Read error messages: They often tell you what's wrong.

School example: A student checks if a motor is plugged in when it doesn't work.

Nigerian example: A learner tests a micro:bit sensor by displaying values on the Scratch stage.

Mini summary: Debugging is a superpower for finding and fixing problems.

12. Sharing Your Project – Showing the World

Definition: Sharing means publishing your project for others to see and use.

Why important? You can inspire others and get feedback.

How to share:

• Click the "Share" button on the Scratch website.
• Write a good description and instructions.
• Tag your project with relevant keywords.
• Share the link with friends and family.

School example: A student shares their project as part of a class exhibition.

Nigerian example: A student shares a game about "Lagos Traffic" and asks for feedback.

Mini summary: Sharing your work helps you connect with others and grow.

🇳🇬 Nigerian Examples

• A student creates a "smart fan" that turns on when the room is hot using micro:bit.
• A teacher uses Text-to-Speech to make a talking chemistry periodic table.
• A kid builds a "Yoruba Translator" using the Translate extension.

🎈 Fun Examples for Kids

• A game where you "dodge" objects using your body movements (video sensing).
• A virtual drum kit using the Music extension.
• A talking animal using Text-to-Speech.

🧾 Remember This

• Extensions are add-ons for Scratch.
• You can use multiple extensions together.
• Test your hardware connections carefully.

⚠️ Common Mistakes

• Forgetting to allow camera access for Video Sensing.
• Not connecting hardware properly.
• Using too many extensions and slowing down the project.

✅ Best Practices

• Test each extension separately before combining them.
• Read the instructions for each extension.
• Share your projects and ask for feedback.

🔗 Matching Exercise

Match the extension with its purpose:

• 1. Music → (A) Detects motion with webcam
• 2. Video Sensing → (B) Translates text
• 3. Translate → (C) Plays musical notes

Answers: 1‑C, 2‑A, 3‑B

🎭 Scenario-based Exercise

Scenario: You want to create a game where a sprite talks to you in different languages and plays music when you wave your hand. Which extensions would you use?

Hint: Text-to-Speech, Translate, Video Sensing, and Music.

1. Game Design Principles – The Secret to Fun Games

Definition: Game design is the art of making games that are fun, engaging, and balanced.

Why important? Even the most complex code is useless if the game isn't enjoyable.

Key principles:

• Clear Goal: The player must know what to do (e.g., "Collect 10 stars").
• Feedback: The game should respond to the player's actions (sounds, points, messages).
• Challenge: The game should be hard enough to be interesting, but not impossible.
• Progression: Levels get harder as the player gets better.
• Fairness: The game should be fair – the player's skill should determine success.

Simple explanation: Like a good story – it has a beginning, a middle, and a satisfying end.

Real-life example: Super Mario – clear goal (rescue Princess), feedback (jumping sound), challenge (enemies), progression (harder levels).

Nigerian example: A game about "The Tortoise and the Hare" – clear goal, feedback, and progression.

Illustration:

GAME DESIGN PRINCIPLES
+-----------------------------------+
| Goal     |  What to achieve       |
| Feedback |  Response to actions   |
| Challenge|  Hard but possible     |
| Progression |  Gets harder       |
| Fairness |  Skill matters        |
+-----------------------------------+
                

Mini summary: Good game design makes games fun and engaging.

2. Planning Your Game – The Blueprint

Definition: Planning is the process of designing your game before you start coding.

Why important? Good planning saves time and frustration.

Steps to plan:

• Brainstorm: Write down all your ideas.
• Choose the best: Pick one idea that excites you.
• Write a story: What is the game about?
• Design the levels: How many levels and what makes each unique?
• List the features: What will the player do? What are the controls?
• Sketch the layout: Draw a rough sketch of the game screen.

Nigerian example: Planning a game about "Nigeria's Independence" – levels for different decades.

Illustration:

GAME PLANNING
+-----------------------------------+
| 1. Idea  (Game about Nigeria)     |
| 2. Story  (A boy travels)        |
| 3. Levels (5 levels)             |
| 4. Features (jump, collect)      |
| 5. Sketch (draw the screen)      |
| 6. Code!                         |
+-----------------------------------+
                

Mini summary: Planning is the first step to building a great game.

3. Creating Levels – Building the Adventure

Definition: Levels are different stages in a game. Each level has unique challenges and goals.

Why important? Levels add variety and progression to the game.

How to create levels:

• Use variables: A "level" variable tracks the current level.
• Change the layout: Use "if" blocks to set different backdrops, enemy positions, and obstacles.
• Increase difficulty: Make enemies faster or more numerous.
• Use costumes: Change the backdrop costume for each level.

School example: A math game with different levels of difficulty.

Nigerian example: A game about Nigerian states – each level focuses on a different region.

Illustration:

LEVELS
+-----------------------------------+
| Level 1: Easy (1 enemy)           |
| Level 2: Medium (3 enemies)       |
| Level 3: Hard (5 enemies)         |
| Level 4: Expert (fast enemies)    |
+-----------------------------------+
                

Mini summary: Levels make your game longer and more interesting.

4. Graphics and Costumes – Making Your Game Beautiful

Definition: Graphics are the visual elements of your game – sprites, backdrops, and animations.

Why important? Good graphics make your game more attractive and immersive.

How to create graphics:

• Use the Paint Editor: Draw your own sprites and backdrops.
• Use costumes: Create multiple costumes for a sprite to animate it (e.g., walking, jumping).
• Use effects: Add colour effects, ghost effects, and size changes.
• Use the Backdrop Library: Choose from pre-made backdrops.

Real-life example: A video game character that runs, jumps, and attacks.

Nigerian example: A sprite wearing traditional Nigerian clothes.

Illustration:

COSTUME ANIMATION
+-----------------------------------+
| Costume 1:  Standing              |
| Costume 2:  Walking left          |
| Costume 3:  Walking right         |
| Costume 4:  Jumping               |
+-----------------------------------+
                

Mini summary: Graphics bring your game to life.

5. Sound Design – Adding Music and Effects

Definition: Sound design is the process of adding music, sound effects, and voice to your game.

Why important? Sound enhances the mood and immerses the player.

How to add sound:

• Use the Sound Library: Choose from pre-made sounds.
• Record your own: Use the microphone to record sounds.
• Use the Music extension: Create your own music.
• Add sound effects: Add sounds for jumping, collecting, losing, etc.

Real-life example: The "coin" sound in Super Mario.

Nigerian example: A game with traditional Nigerian drumming music.

Mini summary: Sound makes your game more exciting.

6. Game Mechanics – The Rules of the Game

Definition: Game mechanics are the rules and systems that make the game work.

Why important? They define how the player interacts with the game.

Common mechanics:

• Movement: How the player moves (arrow keys, mouse).
• Collecting: Picking up items (coins, stars).
• Combat: Fighting enemies.
• Power-ups: Temporary boosts (speed, invincibility).
• Scoring: Tracking points.
• Lives: How many attempts the player has.

Real-life example: In Pac-Man, the mechanics are movement, collecting dots, and avoiding ghosts.

Nigerian example: A game where you collect "balls" while avoiding "trouble."

Mini summary: Game mechanics define how the game works.

7. Power-Ups – Giving Players an Edge

Definition: Power-ups are special items that give the player a temporary advantage.

Why important? They add excitement and strategy to the game.

Types of power-ups:

• Speed Boost: Player moves faster.
• Invincibility: Player cannot be hurt.
• Extra Life: Player gets an extra chance.
• Magnet: Player attracts items.

How to implement: Use a variable to track the power-up state and a timer to end it.

Nigerian example: A "strength" power-up that lets you break through obstacles.

Mini summary: Power-ups make the game more fun and dynamic.

8. Enemies and Obstacles – The Challenge

Definition: Enemies and obstacles are things that make the game harder.

Why important? They create challenge and tension.

How to create enemies:

• Use clones: Create many enemies from a single sprite.
• Give enemies behaviour: Make them move, chase, or shoot.
• Use obstacles: Add walls, pits, and moving objects.
• Increase difficulty: Make enemies faster or more numerous in later levels.

Real-life example: In Mario, the Goombas are enemies.

Nigerian example: A game where you avoid "pothole" obstacles.

Mini summary: Enemies and obstacles make the game challenging.

9. Scoring and Lives – The Status

Definition: Scoring tracks the player's progress. Lives track how many attempts the player has.

Why important? They give the player a sense of progress and feedback.

How to implement:

• Use variables: Create "Score" and "Lives" variables.
• Display on screen: Use the "show variable" block.
• Update score: Increase score when the player collects items or defeats enemies.
• Update lives: Decrease lives when the player hits an enemy or falls.
• Game Over: When lives = 0, show a "Game Over" screen.

Nigerian example: A game where you lose a life when you hit a "pothole."

Illustration:

SCORING AND LIVES
+-----------------------------------+
| Score: 250                        |
| Lives: ❤️❤️❤️                       |
| Level: 3                          |
+-----------------------------------+
                

Mini summary: Scoring and lives give the player feedback on their progress.

10. User Interface (UI) – Making It Clear

Definition: UI is how the game's information is displayed to the player.

Why important? A clear UI helps players understand the game.

UI elements:

• Score display: Show the score prominently.
• Lives display: Show lives with icons (hearts, stars).
• Level display: Show which level the player is on.
• Buttons: Start, restart, and pause buttons.
• Messages: "You Win!" and "Game Over" messages.

Nigerian example: A game with a "Level" display and a "Score" display in the corner.

Mini summary: UI helps the player understand the game.

11. Testing and Debugging – Making It Perfect

Definition: Testing means playing your game to find bugs. Debugging means fixing them.

Why important? Bugs can ruin the player's experience.

Tips:

• Test early: Test small parts as you build.
• Test often: Play your game after every new feature.
• Get feedback: Ask friends to play and point out issues.
• Check edge cases: What happens if the player goes off-screen?
• Use "say" blocks: Display variables to see what's happening.

Nigerian example: A student tests their game and finds that the score doesn't update correctly.

Mini summary: Testing and debugging make your game polished and professional.

12. Polishing and Sharing – The Final Step

Definition: Polishing means making your game look and feel perfect. Sharing means publishing it for others to play.

Why important? Polishing makes a good game great. Sharing lets you show the world your creation.

Polishing tips:

• Add smooth animations: Use "glide" instead of "go to".
• Add particle effects: Use clones for sparkles or explosions.
• Add a title screen: A nice start page.
• Add instructions: Tell the player how to play.

Sharing tips:

• Click "Share": On the Scratch website.
• Write a description: Explain your game.
• Add tags: Help people find your game.
• Share on social media: Show your friends.

Nigerian example: A student shares their game about Nigerian history and gets positive feedback.

Mini summary: Polishing and sharing make your game complete and known.

🇳🇬 Nigerian Examples

• A game about "The Adventures of Soko" across Nigeria.
• A game where you collect "balls" at a market.
• A game about "Nigeria's Independence" with different levels.
• A game with traditional Nigerian music.

🎈 Fun Examples for Kids

• A game where you "fly" through space collecting stars.
• A game where you "surf" on a wave and avoid obstacles.
• A game where you "grow" a garden with plants.

🧾 Remember This

• Plan your game before coding.
• Test your game often.
• Make your game fun and fair.

⚠️ Common Mistakes

• Making the game too hard or too easy.
• Forgetting to add instructions.
• Not testing for bugs.

✅ Best Practices

• Use comments to explain your code.
• Use clear variable names.
• Polish your game before sharing.

🔗 Matching Exercise

Match the term with its description:

• 1. Power-up → (A) A stage in a game
• 2. Level → (B) A temporary boost
• 3. UI → (C) How information is displayed

Answers: 1‑B, 2‑A, 3‑C

🎭 Scenario-based Exercise

Scenario: You have built a game, but players say it's too easy. How would you make it more challenging without making it frustrating?

Hint: Add more enemies, make enemies faster, or reduce the player's lives.

1. Project Planning – The Blueprint

Definition: Project planning is the process of breaking a big project into smaller, manageable tasks.

Why important? Good planning saves time and prevents confusion.

Simple explanation: Like building a house – you need a blueprint before you start.

Steps to plan:

• Define the goal: What do you want to achieve?
• List tasks: Write down everything you need to do.
• Prioritize tasks: Which tasks are most important?
• Estimate time: How long will each task take?
• Create a timeline: When will you do each task?

Real-life example: A software company plans a new app over 6 months.

Nigerian example: A student plans a school project about Nigerian history.

Illustration:

PROJECT PLANNING
+-----------------------------------+
| Goal: Build a game in 2 weeks    |
| Tasks:                           |
|  1. Design (2 days)             |
|  2. Code (5 days)               |
|  3. Test (2 days)               |
|  4. Polish (1 day)              |
|  5. Present (1 day)             |
+-----------------------------------+
                

Mini summary: Planning makes big projects achievable.

2. Time Management – Using Your Time Wisely

Definition: Time management is about using your time efficiently to finish tasks.

Why important? It helps you meet deadlines and avoid stress.

Simple explanation: Like a race – you need to pace yourself.

Tips:

• Set deadlines: Give yourself a time limit for each task.
• Use a timer: Work in focused chunks (e.g., 25 minutes).
• Take breaks: Rest your brain regularly.
• Avoid distractions: Turn off notifications while working.
• Review progress: Check what you have done each day.

School example: A student schedules homework time each day.

Nigerian example: A student in Kano uses a timetable to study for exams.

Illustration:

TIME MANAGEMENT
+-----------------------------------+
| 8:00 – 9:00:  Design             |
| 9:00 – 10:00: Code               |
| 10:00 – 10:15: Break             |
| 10:15 – 11:30: Code              |
| 11:30 – 12:00: Test              |
+-----------------------------------+
                

Mini summary: Good time management helps you finish on time.

3. Task Breakdown – Dividing and Conquering

Definition: Task breakdown means dividing a big task into smaller, easier subtasks.

Why important? Small tasks are easier to complete and less overwhelming.

Simple explanation: Like eating a pizza – you eat one slice at a time.

Example: "Build a game" becomes: design, code, test, polish.

Real-life example: A company breaks down a project into milestones.

Nigerian example: A student breaks down "Write a report" into research, outline, write, edit.

Mini summary: Breaking tasks down makes them manageable.

4. Team Collaboration – Working Together

Definition: Collaboration is working with others to achieve a common goal.

Why important? Teams can do more than individuals.

Tips for good collaboration:

• Communicate: Share your ideas and listen to others.
• Share the work: Divide tasks fairly.
• Help each other: If someone is stuck, offer help.
• Respect each other: Listen to different opinions.
• Celebrate together: Share the success.

School example: A group project where each student does a part.

Nigerian example: A group of students works on a science fair project.

Mini summary: Good teamwork makes projects better.

5. Version Control – Keeping Track of Changes

Definition: Version control is a system that saves different versions of your project so you can go back to an older version if needed.

Why important? It protects you from losing work and helps you experiment.

Simple explanation: Like saving a document with different names – "game_v1", "game_v2".

How to do it in Scratch:

• Use "Save as" with dates: Save different versions with dates.
• Use cloud storage: Save to OneDrive or Google Drive.
• Use comments: Write notes about what you changed.

Real-life example: Software developers use Git to track changes.

Nigerian example: A student saves "project_week1", "project_week2".

Illustration:

VERSION CONTROL
+-----------------------------------+
| game_v1.sb3  (initial)            |
| game_v2.sb3  (added levels)       |
| game_v3.sb3  (added enemies)      |
| game_v4.sb3  (final)              |
+-----------------------------------+
                

Mini summary: Version control saves you from losing work.

6. Documentation – Explaining Your Code

Definition: Documentation is writing comments and explanations about your code so others can understand it.

Why important? It helps others (and your future self) understand what your code does.

Simple explanation: Like writing a user manual for your game.

How to document in Scratch:

• Use comments: Right-click on a block and add a comment.
• Name sprites and variables clearly: Use names like "Player" or "Score".
• Write a README: Explain your project in the description.

Real-life example: Software developers write documentation for their code.

Nigerian example: A student writes comments to explain a complex script.

Illustration:

DOCUMENTATION
+-----------------------------------+
| // This script moves the player  |
| // when the arrow keys are pressed|
| when [up arrow] key pressed      |
|   change y by 10                 |
|   // This makes the player jump  |
+-----------------------------------+
                

Mini summary: Documentation makes your code understandable.

7. Presenting Your Project – Sharing Your Work

Definition: Presenting means showing your project to others and explaining how it works.

Why important? It lets you share your work and get feedback.

Tips for a good presentation:

• Start with the goal: What did you set out to create?
• Show the project: Let them see it in action.
• Explain the code: Tell them about the key parts.
• Talk about challenges: What was hard and how did you solve it?
• Ask for feedback: What could be improved?

School example: Presenting a project to the class.

Nigerian example: A student presents their game at a school exhibition.

Mini summary: Presenting helps you share and improve your work.

8. Feedback and Iteration – Making It Better

Definition: Feedback is comments from others about your work. Iteration means making improvements based on feedback.

Why important? Feedback helps you see blind spots and improve.

Simple explanation: Like a writer who revises their story based on an editor's suggestions.

How to use feedback:

• Listen carefully: Don't get defensive.
• Identify patterns: If many people say the same thing, it's important.
• Make changes: Use the feedback to improve your project.
• Test again: See if the changes work.

Nigerian example: A student asks friends to test their game and then improves it.

Mini summary: Feedback and iteration make your project better.

9. Reflection – Learning from Experience

Definition: Reflection is thinking about what you learned and how you can improve.

Why important? It helps you grow as a learner and a creator.

Questions to ask:

• What went well?
• What was challenging?
• What did I learn?
• What would I do differently next time?
• How can I use what I learned in the future?

School example: A student writes a reflection after a project.

Nigerian example: A student thinks about what they learned from a coding competition.

Mini summary: Reflection helps you learn from your experiences.

10. Sharing and Collaborating Online

Definition: Online sharing means publishing your project on the Scratch website where others can see it and even remix it.

Why important? It lets you connect with a global community.

How to share:

• Click "Share": On the Scratch project page.
• Write a description: Explain your project and how to use it.
• Add tags: Help people find your project.
• Encourage collaboration: Allow others to remix your project.

Nigerian example: A student in Abuja shares a game about Nigeria and gets remixes from other countries.

Mini summary: Online sharing connects you with the world.

11. Managing Project Resources

Definition: Resources are things you need for your project – like time, tools, and people.

Why important? Managing resources helps you avoid running out of what you need.

How to manage:

• List resources: What do you need?
• Plan ahead: Make sure you have what you need before you start.
• Use wisely: Don't waste time or materials.

Nigerian example: A student plans to use the school computer lab for coding.

Mini summary: Resource management helps you finish your project.

12. Becoming a Project Leader

Definition: A project leader is someone who guides a team and ensures the project is completed successfully.

Why important? Leaders help teams stay focused and motivated.

Qualities of a good leader:

• Communicative: Shares ideas clearly.
• Organized: Keeps everything on track.
• Encouraging: Motivates the team.
• Problem-solver: Helps overcome challenges.
• Delegates: Assigns tasks fairly.

Nigerian example: A student leads a group project and ensures everyone contributes.

Mini summary: Leadership skills help you guide projects to success.

🇳🇬 Nigerian Examples

• A student plans a "Nigerian History" game for a school project.
• A team of students collaborates on a science fair project.
• A student shares a game about Lagos and gets feedback from the community.

🎈 Fun Examples for Kids

• Plan a "Birthday Party Planner" project.
• Work with a friend to build a "Two-Player Game".
• Share your project and see how many people play it.

🧾 Remember This

• Plan before you code.
• Document your work.
• Collaborate and communicate.

⚠️ Common Mistakes

• Starting without a plan.
• Not saving different versions.
• Ignoring feedback.

✅ Best Practices

• Use a checklist to track progress.
• Write comments in your code.
• Ask for feedback and use it.

🔗 Matching Exercise

Match the term with its description:

• 1. Version Control → (A) Explaining code
• 2. Documentation → (B) Tracking changes
• 3. Collaboration → (C) Working with others

Answers: 1‑B, 2‑A, 3‑C

🎭 Scenario-based Exercise

Scenario: You are leading a team of 3 students to build a game in 3 weeks. One team member is struggling with their task. How would you handle it?

Hint: Communicate, offer help, and adjust the plan if needed.

1. What are Advanced Extensions?

Definition: Advanced extensions are tools that connect Scratch to the internet, to hardware, or to other software.

Why important? They allow Scratch to do things that are not possible with basic blocks alone.

Simple explanation: Advanced extensions are like adding a jetpack to your Scratch project – they give you superpowers!

Types of advanced extensions:

• Web Extensions: Connect to online services.
• Hardware Extensions: Connect to physical devices.
• Custom Extensions: Built by the Scratch community.

Real-life example: A smart home app that controls lights and temperature.

Nigerian example: A project that shows the current time and weather in Lagos.

Illustration:

ADVANCED EXTENSIONS
+-----------------------------------+
| Scratch Project                   |
|      |                            |
|      V                            |
| Extension (Web, Hardware, etc.)  |
|      |                            |
|      V                            |
| Real World / Internet             |
+-----------------------------------+
                

Mini summary: Advanced extensions connect Scratch to the outside world.

2. Web Services and APIs – Getting Data from the Internet

Definition: A web service is a way for programs to get data from the internet. An API (Application Programming Interface) is the rulebook for how to ask for that data.

Why important? They let you use real-world data in your projects.

Simple explanation: Like making a phone call to a library to ask for a book – the API is the phone number and the instructions.

How it works: Your Scratch project sends a request to a website. The website sends back data (like weather, news, or scores).

Real-life example: A weather app that shows today's forecast.

Nigerian example: A project that shows the top football scores from the Nigerian league.

Mini summary: Web services let you bring the internet into your Scratch projects.

3. Using HTTP Requests – Fetching Data

Definition: HTTP is the protocol used to send requests and receive responses from web servers.

Why important? This is how you get data from an API.

How to do it in Scratch: Use the "HTTP" extension (available in Scratch Lab) or use the "Raspberry Pi" extension which can make HTTP requests.

Simple explanation: Like sending a letter (request) and getting a reply (response).

Steps:

• 1. Find a free API (e.g., weather API).
• 2. Get the API URL (address).
• 3. Use an extension to send a request.
• 4. Parse (read) the response.

Nigerian example: A student uses an API to get the price of yams from an online market.

Mini summary: HTTP requests bring data from the web into your Scratch project.

4. Raspberry Pi – A Tiny Computer

Definition: The Raspberry Pi is a small, affordable computer that can run Scratch and connect to electronic components.

Why important? It allows you to create physical computing projects with Scratch.

Simple explanation: Like a mini computer that can control lights, motors, and sensors.

What you can do:

• Control LEDs: Turn lights on and off.
• Read sensors: Measure temperature, light, or distance.
• Control motors: Make things move.
• Connect to the internet: Run a web server.

Nigerian example: A student uses a Raspberry Pi to control a traffic light model.

Illustration:

RASPBERRY PI SETUP
+-----------------------------------+
| Scratch Code (on Pi)              |
|      |                            |
|      V                            |
| GPIO Pins (General Purpose I/O)  |
|      |                            |
|      V                            |
| LEDs, Motors, Sensors             |
+-----------------------------------+
                

Mini summary: Raspberry Pi brings Scratch into the physical world.

5. Raspberry Pi GPIO – Controlling Electronics

Definition: GPIO (General Purpose Input/Output) pins are the physical connectors on the Raspberry Pi that you can use to connect electronic components.

Why important? They let you control real-world devices.

How to use: Connect an LED to a GPIO pin, then use Scratch blocks to turn it on and off.

Nigerian example: A student creates a "traffic light" project with red, yellow, and green LEDs.

Mini summary: GPIO pins let Scratch talk to electronics.

6. Arduino – The Electronics Platform

Definition: Arduino is an open-source electronics platform used to build interactive objects.

Why important? It's widely used in schools and for robotics.

How to use with Scratch: Use the "Arduino" extension or software like S4A (Scratch for Arduino).

Nigerian example: A student builds a robot that follows a line using Arduino and Scratch.

Mini summary: Arduino brings Scratch to robotics and electronics.

7. Creating Custom Extensions – Building Your Own Tools

Definition: A custom extension is a new set of blocks that you create yourself using JavaScript.

Why important? You can add any feature you can imagine.

How to create: Use the Scratch Extension Developer Tools. You write JavaScript code to define new blocks.

Simple explanation: Like creating your own LEGO pieces.

Nigerian example: A student creates a "Nigerian Naira Exchange" extension that converts currencies.

Illustration:

CUSTOM EXTENSION
+-----------------------------------+
| JavaScript Code                   |
|   define new Scratch blocks      |
|      |                            |
|      V                            |
| Custom Scratch Extension          |
|      |                            |
|      V                            |
| Use your own blocks in Scratch   |
+-----------------------------------+
                

Mini summary: Custom extensions give you unlimited power.

8. Scratch Extension Developer Tools

Definition: These are tools provided by the Scratch Team to help developers build custom extensions.

Why important? They make the process easier.

What you need:

• JavaScript knowledge: Basic understanding of JavaScript.
• Scratch Extension Developer Tools: A browser extension that helps.
• A text editor: To write your code.

Nigerian example: A student in Port Harcourt creates a "Nigerian Market Prices" extension.

Mini summary: Developer tools help you build extensions.

9. Integrating Scratch with Other Platforms

Definition: Integration means connecting Scratch to other tools like MakeCode, Python, or even web apps.

Why important? You can combine the best of different tools.

How to integrate:

• MakeCode: Use the MakeCode extension to control micro:bit.
• Python: Use a web server to send data between Scratch and Python.
• Web Apps: Use the HTTP extension to send data to a web app.

Nigerian example: A student integrates Scratch with a Python program to analyze data from a market.

Mini summary: Integration lets you use the best of many worlds.

10. The Future of Scratch

Definition: The future of Scratch includes new features like cloud-based projects, AI integration, and more advanced extensions.

Why important? Knowing where Scratch is heading helps you stay ahead.

What's coming:

• AI Features: Machine learning blocks.
• Better Collaboration: Real-time editing.
• More Extensions: New hardware and web integrations.
• Scratch 4.0: A complete redesign.

Nigerian example: The future may bring a "Nigerian Languages" extension.

Mini summary: Scratch is always growing – keep learning!

11. Building a Connected Project

Definition: A connected project uses one or more integrations to create something new.

Why important? It shows your ability to combine skills.

Project Idea: A "Smart Home Dashboard". Use an API to get weather data, a micro:bit to control a light, and a custom extension to display the data.

Nigerian example: A "Market Price Tracker" that uses an API to get prices and a custom extension to display them.

Steps:

• 1. Plan the project.
• 2. Choose the integrations.
• 3. Build each part.
• 4. Test and combine.
• 5. Share your project.

Mini summary: Connected projects showcase your advanced skills.

12. Sharing Your Advanced Project

Definition: Sharing means publishing your project and explaining how it works.

Why important? It lets others learn from your work.

How to share:

• Share on Scratch: Click "Share".
• Write a description: Explain what your project does and what extensions you used.
• Create a video: Show your project in action.
• Share on social media: Let the world see your work.

Nigerian example: A student shares their weather project and gets feedback from the global Scratch community.

Mini summary: Sharing your work helps you grow as a creator.

🇳🇬 Nigerian Examples

• A student creates a "Nigerian Weather" project using an API.
• A student controls a traffic light model with a Raspberry Pi.
• A student creates a "Nigerian Naira Exchange" custom extension.

🎈 Fun Examples for Kids

• A project that shows the number of people online in a game using an API.
• A "Smart Lamp" that turns on when you clap (using Arduino).
• A "Custom Calculator" extension that does math in new ways.

🧾 Remember This

• APIs need API keys – keep them secret.
• Hardware projects need the right connections.
• Custom extensions need JavaScript knowledge.

⚠️ Common Mistakes

• Forgetting to connect the hardware properly.
• Not handling API errors gracefully.
• Writing JavaScript with bugs.

✅ Best Practices

• Test your hardware with simple code first.
• Use "try/catch" in JavaScript to handle errors.
• Document your custom extensions.

🔗 Matching Exercise

Match the term with its description:

• 1. API → (A) A small computer
• 2. Raspberry Pi → (B) Rules for getting data
• 3. Custom Extension → (C) Created with JavaScript

Answers: 1‑B, 2‑A, 3‑C

🎭 Scenario-based Exercise

Scenario: You want to create a project that shows the top news headlines from Nigeria. How would you do it?

Hint: Use a news API and the HTTP extension.

1. Advanced Game Design Principles

Definition: Advanced game design is about creating games that are not just fun, but also deep, engaging, and memorable.

Why important? Advanced design makes your game stand out.

Key principles:

• Player Agency: Let the player make meaningful choices.
• Flow: Keep the player in a state of focused engagement.
• Story: A good story can make a game unforgettable.
• Balance: Challenge should be fair but engaging.
• Replayability: Give players a reason to play again.

Real-life example: The Legend of Zelda – player agency, story, and balance.

Nigerian example: A game about "The Tortoise and the Hare" with multiple endings based on choices.

Illustration:

ADVANCED GAME DESIGN
+-----------------------------------+
| Agency   |  Player makes choices  |
| Flow     |  Engaged focus         |
| Story    |  Unforgettable narrative|
| Balance  |  Fair challenge        |
| Replayability |  Play again      |
+-----------------------------------+
                

Mini summary: Advanced game design creates deeper, more engaging experiences.

2. Polishing Your Game – The Final Touches

Definition: Polishing means adding small details that make your game feel professional.

Why important? Polish separates amateur games from professional ones.

Ways to polish:

• Smooth animations: Use glide blocks instead of instant movement.
• Particle effects: Use clones for sparkles, explosions, and trails.
• Sound design: Add ambient music and sound effects.
• Transition effects: Fade in/out between levels.
• UI polish: Use clean fonts, nice colours, and consistent styling.

Nigerian example: A student adds the Nigerian flag colours to the user interface of their game.

Mini summary: Polish makes your game shine.

3. User Experience (UX) Design

Definition: UX design is about how the player feels when playing your game.

Why important? Good UX makes players enjoy your game.

Key UX principles:

• Intuitive controls: Players should know how to play without a manual.
• Clear feedback: The game should respond to every action.
• Onboarding: Teach the player how to play slowly.
• Accessibility: Make your game playable for everyone.
• Emotion: Make the player feel something.

Nigerian example: A game that explains its controls using pictures and simple words.

Mini summary: Good UX makes your game a joy to play.

4. Building a Portfolio – Showcasing Your Work

Definition: A portfolio is a collection of your best work that you can show to others.

Why important? It helps you get opportunities, like jobs or scholarships.

What to include:

• Your best projects: Choose 3-5 games that show your skills.
• Descriptions: Explain each project and your role.
• Screenshots and videos: Show your work visually.
• Reflections: What you learned from each project.

Nigerian example: A student creates a portfolio website using a free website builder.

Illustration:

PORTFOLIO
+-----------------------------------+
| Game 1: Soko's Adventure          |
|   Description, Screenshots, Video |
| Game 2: Lagos Traffic             |
|   Description, Screenshots, Video |
| Game 3: Nigerian History Quiz     |
|   Description, Screenshots, Video |
+-----------------------------------+
                

Mini summary: A portfolio opens doors to new opportunities.

5. Promoting Your Games – Getting Noticed

Definition: Promotion means sharing your games with the world so people can play them.

Why important? No one will play your game if they don't know about it.

Ways to promote:

• Share on Scratch: Click "Share" and add a good description.
• Social media: Share your game on Instagram, Twitter, or TikTok.
• YouTube: Create a game trailer or walkthrough.
• Game jams: Participate in game development competitions.
• Online communities: Share in Scratch forums and Discord servers.

Nigerian example: A student shares their game on a Nigerian tech community group.

Mini summary: Promotion helps your game reach players.

6. Earning from Your Games – Turning Passion into Income

Definition: Earning from games means making money from your creations.

Why important? It can turn a hobby into a career.

Ways to earn:

• Freelancing: Build games for others as a freelancer.
• Game jams: Win prizes in competitions.
• Sponsorships: Get companies to sponsor your games.
• Selling assets: Sell sprites, sound effects, or code.
• YouTube/Twitch: Earn from game-related content.

Nigerian example: A student creates a game for a local business and gets paid.

Mini summary: Your game skills can earn you money.

7. Collaboration – Working with Others

Definition: Collaboration means working with other people to build games.

Why important? Big games are built by teams.

How to collaborate:

• Define roles: Who is the designer, coder, artist, sound designer?
• Use version control: Share code using cloud storage.
• Communicate: Use group chats or video calls.
• Respect each other: Listen to everyone's ideas.

Nigerian example: A team of students builds a game for a school competition.

Mini summary: Teamwork makes big projects possible.

8. Copyright and Licensing – Protecting Your Work

Definition: Copyright protects your creative work from being used without permission. Licensing gives others permission to use your work.

Why important? It protects your rights as a creator.

What to do:

• Add a copyright notice: "© [Your Name] [Year]".
• Choose a license: Creative Commons licenses let you share while protecting your rights.
• Be careful with assets: Only use sounds and images you have permission to use.

Nigerian example: A student adds a Creative Commons license to their game.

Mini summary: Protecting your work is important.

9. Game Testing – Getting Feedback

Definition: Game testing means having people play your game to find bugs and give feedback.

Why important? It helps you improve your game.

How to test:

• Ask friends and family: Get them to play and give honest feedback.
• Use online communities: Share your game and ask for feedback.
• Observe players: Watch how they play to see what confuses them.
• Iterate: Use the feedback to improve your game.

Nigerian example: A student tests their game with classmates and improves it.

Mini summary: Testing makes your game better.

10. The Business of Games

Definition: The business of games includes marketing, monetization, and distribution.

Why important? If you want to make money from games, you need to understand business.

Key business concepts:

• Market research: Understand what players want.
• Pricing: Decide how much to charge (or if it's free).
• Distribution: Where will you sell your game?
• Marketing: How will you tell people about your game?

Nigerian example: A student researches what games are popular in Nigeria.

Mini summary: Business skills help you succeed as a game developer.

11. Preparing for the Future – Next Steps

Definition: Preparing for the future means planning your path as a game developer.

Why important? It helps you achieve your goals.

Next steps:

• Learn new tools: Try Unity, Godot, or Python.
• Build more games: Keep creating and improving.
• Join communities: Connect with other developers.
• Study game design: Read books and take courses.
• Apply to programs: Look for internships or scholarships.

Nigerian example: A student plans to study computer science at a Nigerian university.

Mini summary: Plan your future as a game developer.

12. Your Game Developer Journey

Definition: Your journey is the path you take as a game developer, from beginner to expert.

Why important? It's your story – make it a great one.

Key steps:

• Start where you are: Use the skills you have now.
• Keep learning: Never stop improving.
• Share your work: Show what you create.
• Celebrate successes: Enjoy your achievements.
• Learn from failures: Every mistake is a lesson.

Nigerian example: A student reflects on their journey from beginner to expert.

Mini summary: Your journey is just beginning – enjoy every step!

🇳🇬 Nigerian Examples

• A student creates a game about "Nigeria's Independence" and promotes it in their school.
• A student builds a portfolio to apply for a scholarship.
• A student collaborates with friends to build a game for a competition.

🎈 Fun Examples for Kids

• Create a portfolio website about your games.
• Make a game trailer using a screen recorder.
• Start a game club at your school.

🧾 Remember This

• Polish makes your game stand out.
• A portfolio helps you get opportunities.
• Promotion gets your game noticed.

⚠️ Common Mistakes

• Not testing with enough players.
• Using copyrighted assets without permission.
• Not promoting your game.

✅ Best Practices

• Always test your game with real players.
• Use free or Creative Commons assets.
• Build a portfolio early and update it.

🔗 Matching Exercise

Match the term with its description:

• 1. Portfolio → (A) Adding final touches
• 2. Polish → (B) A collection of your work
• 3. Promotion → (C) Sharing your game

Answers: 1‑B, 2‑A, 3‑C

🎭 Scenario-based Exercise

Scenario: You have built a great game, but no one is playing it. What would you do to get more players?

Hint: Use promotion strategies – share on social media, join communities, and ask for feedback.

1. What Makes a Good Teacher?

Definition: A good teacher is someone who helps others learn in a kind, clear, and patient way.

Why important? Good teachers make learning fun and effective.

Qualities of a good teacher:

• Patient: They don't get frustrated when someone doesn't understand.
• Clear: They use simple language and examples.
• Encouraging: They cheer on their students.
• Knowledgeable: They know their subject well.
• Adaptable: They change their approach to fit the student.

Simple explanation: A good teacher is like a guide on a hike – they show you the way and help you when you struggle.

Nigerian example: A teacher in Lagos who explains Scratch using local examples.

Illustration:

QUALITIES OF A GOOD TEACHER
+-----------------------------------+
| Patient  |  Encouraging           |
| Clear    |  Knowledgeable         |
| Adaptable |  Kind                |
| Use examples |  Listen well      |
+-----------------------------------+
                

Mini summary: Great teachers are patient, clear, and encouraging.

2. How People Learn – Understanding Your Students

Definition: Everyone learns differently. Some learn by watching, some by doing, and some by listening.

Why important? To teach effectively, you need to understand how your students learn best.

Learning styles:

• Visual: Learn by seeing (demonstrations, videos).
• Auditory: Learn by listening (explanations, discussions).
• Kinesthetic: Learn by doing (hands-on practice).

School example: A teacher uses a mix of demonstrations, explanations, and practice.

Nigerian example: A student teacher in Abuja uses storytelling to explain coding concepts.

Mini summary: Know your students to teach them better.

3. Teaching with Projects – Learning by Building

Definition: Project-based learning means teaching by having students build projects.

Why important? It's more engaging and memorable than just listening.

How to do it:

• Start with a goal: "Today we will build a game."
• Break it down: Show the steps.
• Let them try: Give students time to build.
• Celebrate: Show off what they made.

Real-life example: A school where students learn coding by building games.

Nigerian example: A teacher in Kano uses project-based learning to teach Scratch.

Illustration:

PROJECT-BASED LEARNING
+-----------------------------------+
| Goal: Build a Game               |
|  1. Plan the game                |
|  2. Code the game                |
|  3. Test the game                |
|  4. Share the game               |
+-----------------------------------+
                

Mini summary: Projects make learning fun and meaningful.

4. Creating Lesson Plans – Be Prepared

Definition: A lesson plan is a written guide for what you will teach and how.

Why important? It helps you stay organized and focused.

Parts of a lesson plan:

• Topic: What you are teaching.
• Objective: What students will learn.
• Materials: What you need.
• Steps: What you will do.
• Activity: What students will do.
• Review: How you will check understanding.

School example: A teacher writes a lesson plan for a Scratch class.

Nigerian example: A tutor in Lagos prepares a lesson plan for teaching Scratch to beginners.

Mini summary: Lesson plans help you teach with confidence.

5. Making Complex Concepts Simple

Definition: This means explaining difficult ideas in easy-to-understand ways.

Why important? It prevents students from getting confused.

Tips:

• Use analogies: Compare to everyday things.
• Break it down: Explain one small part at a time.
• Use examples: Show real examples.
• Draw pictures: Visuals help understanding.

Simple explanation: Like explaining a smartphone to a grandparent – using simple words.

Nigerian example: A teacher explains "loops" by comparing them to beating a drum.

Mini summary: Simple explanations make learning easier.

6. Handling Questions – Answering with Confidence

Definition: Handling questions means responding to students' questions in a helpful way.

Why important? Questions show that students are thinking.

Tips:

• Listen carefully: Understand what they are asking.
• Be honest: If you don't know, say "Let's find out together."
• Rephrase: Repeat the question to make sure you understand.
• Answer clearly: Use simple words.

School example: A student asks about cloud variables – you explain it with an example.

Nigerian example: A student in Ibadan asks about cloning – you show a demo.

Mini summary: Good teachers welcome questions.

7. Giving Feedback – Helping Students Improve

Definition: Feedback is telling students what they did well and what they can improve.

Why important? It helps students grow.

How to give good feedback:

• Be positive: Start with what they did well.
• Be specific: Say exactly what can be improved.
• Be kind: Don't make them feel bad.
• Encourage: Tell them they can do it.

School example: "Your game is fun! The controls could be a bit smoother."

Nigerian example: A teacher in Enugu gives constructive feedback to a student's project.

Mini summary: Good feedback helps students improve.

8. Leading a Coding Club – Start Your Own

Definition: A coding club is a group of people who meet regularly to learn and share code.

Why important? It builds community and helps more people learn.

How to start:

• Find members: Ask friends and classmates.
• Find a place: A classroom, library, or online.
• Plan meetings: Decide when and how often.
• Prepare activities: Have projects to work on.
• Be a leader: Guide and encourage everyone.

Nigerian example: A student in Abuja starts a coding club at their school.

Illustration:

STARTING A CODING CLUB
+-----------------------------------+
| 1. Find members                   |
| 2. Find a place                   |
| 3. Plan meetings                  |
| 4. Prepare activities             |
| 5. Be a leader                    |
+-----------------------------------+
                

Mini summary: Coding clubs spread the love of coding.

9. Mentoring – Guiding One-on-One

Definition: Mentoring is helping a specific person learn and grow over time.

Why important? It provides personalized support.

How to mentor:

• Listen: Understand their goals and challenges.
• Encourage: Believe in them.
• Guide: Show them the way.
• Celebrate: Celebrate their successes.

School example: A student mentors a younger student in Scratch.

Nigerian example: A teenager in Lagos mentors their little sister in coding.

Mini summary: Mentoring changes lives.

10. Building a Community – Connecting with Others

Definition: A community is a group of people who share a common interest.

Why important? Communities provide support, inspiration, and friendship.

How to build:

• Share your work: Post your projects online.
• Comment on others: Give feedback.
• Join events: Participate in online events.
• Be kind: Help others.

Nigerian example: A student joins a Nigerian Scratch community group.

Mini summary: Communities make us stronger.

11. Inspiring the Next Generation

Definition: Inspiration means motivating others to learn and achieve.

Why important? You can make a lasting impact.

How to inspire:

• Share your story: Tell how you started.
• Show your work: Let them see what you built.
• Encourage: Tell them they can do it too.
• Be a role model: Show what's possible.

Nigerian example: A student shares their journey with younger students.

Mini summary: You can inspire others to dream big.

12. Reflection and Celebration

Definition: Reflection is thinking about what you have achieved. Celebration is enjoying your success.

Why important? It helps you grow and appreciate your journey.

Questions to ask:

• What did you learn?
• What were the best moments?
• What challenges did you overcome?
• How have you grown?
• What will you do next?

Nigerian example: A student reflects on their coding journey and plans to teach others.

Mini summary: Celebrate your journey and look forward to the future.

🇳🇬 Nigerian Examples

• A student starts a coding club at their secondary school in Lagos.
• A teenager in Ibadan mentors younger students in Scratch.
• A teacher in Abuja uses project-based learning to teach coding.

🎈 Fun Examples for Kids

• Teach a friend how to make a game.
• Start a "Coding Hour" at your school.
• Create a tutorial video for a coding project.

🧾 Remember This

• Be patient and kind.
• Use simple language.
• Celebrate others' success.

⚠️ Common Mistakes

• Using too many big words.
• Not being patient.
• Comparing students to each other.

✅ Best Practices

• Plan your lessons.
• Encourage questions.
• Be a positive role model.

🔗 Matching Exercise

Match the term with its description:

• 1. Lesson Plan → (A) A guide for teaching
• 2. Mentor → (B) Someone who guides others
• 3. Community → (C) A group with shared interests

Answers: 1‑A, 2‑B, 3‑C

🎭 Scenario-based Exercise

Scenario: You are teaching a group of beginners. One student is struggling with loops. How would you help them?

Hint: Use an analogy, show an example, and give them practice.