Welcome to the World of Variables!
Have you ever played a computer game where your character earns points, loses lives, or races against a countdown clock? If you have, you have already seen variables in action! Don't worry if this seems a bit mysterious at first — by the end of these notes, you will know exactly how computer programs remember information and keep track of everything happening in a game.
In this chapter, you will discover what a variable is, how to create and use one in your code, and how to avoid the most common coding traps that catch beginners out!
1. What is a Variable?
In computer programming, a variable is a named space in a computer's memory that stores a value which can change while a program is running.
Think of it like a Mini-Whiteboard:
Imagine you have a small whiteboard with a label on top that says Score. When your game starts, you write 0 on the whiteboard. When you catch a coin, you wipe out the 0 and write 1. The whiteboard can only show one number at a time. That whiteboard is your variable!
Key Terms to Remember:
• Variable: The named storage space in memory.
• Value: The specific piece of information (like a number or a word) currently held inside the variable.
How to Name Your Variables
When you create a variable, you must give it a clear, meaningful name. A good name tells anyone reading your code what information is inside.
• Great names: score, timer, player_lives
• Poor names: x, stuff, thing1 (These are confusing because you cannot tell what they are storing!)
• Important rule: Variable names should not contain spaces.
Key Takeaway: A variable holds one piece of information (a value) that can change while the program runs, and it always needs a clear, sensible name!
2. Types of Variables
Variables can store different kinds of values depending on what your program needs to remember.
Numeric Variables
These hold numbers. They are used whenever you need to count, calculate, or track quantities.
Examples: Points in a game (100), remaining lives (3), or seconds left on a clock (60).
String Variables
These hold text, such as letters, words, or sentences.
Examples: A player's username ("PixelHero") or a character's dialogue.
Global vs. Local Variables
• Global Variables: These can be seen, used, and changed by all characters or sprites in your whole project.
• Local Variables: These belong to only one specific sprite and cannot be changed directly by other sprites.
Key Takeaway: Numeric variables hold numbers, string variables hold words, and variables can be shared across all sprites (global) or kept for just one (local).
3. The Four Golden Steps of Using Variables
When you build a project in block-based programming (such as Scratch), working with a variable follows four simple steps:
Step 1: Creation (Declaration)
This is where you make a new variable and give it a meaningful name (for example, clicking "Make a Variable" and typing score).
Step 2: Initialization (Setting the Start Value)
This means giving your variable its very first value right at the beginning of the program. For example: Set score to 0 when the green flag is clicked.
Step 3: Updating (Changing the Value)
As the program runs, you modify the value stored inside the variable. For example: Change score by 1 every time a player catches a star.
Step 4: Using (Reading the Value)
Your program checks the value to make a decision or show information on screen. For example: If \(score = 10\), then say "You Win!"
Simple Memory Trick: Remember C-I-U-U — Create it, Initialize it, Update it, Use it!
Key Takeaway: Always create your variable, set its starting value at the very beginning, change it when events happen, and use it to make decisions in your game!
4. Pitfalls and Common Mistakes (Debugging Superpowers!)
Even expert coders make mistakes with variables. Here are the top misconceptions to watch out for:
1. The "Box" Misconception
The Mistake: Thinking a variable is a big box that stores a collection of lots of items all at once.
The Fact: A variable can only hold one value at a time! When you store a new value inside it, the old value is completely erased and replaced.
2. "Set" vs. "Change" Confusion
The Mistake: Writing Set score to 1 when you really want to add a point.
Why it breaks: If you use "Set score to 1" every time a coin is collected, the score will stay at 1 forever! To make it count up \(1, 2, 3, \dots\), you must use Change score by 1.
3. The "Naming Power" Myth
The Mistake: Believing the computer automatically knows what to do just because you named the variable timer.
The Fact: The computer does not understand the meaning of human words. Naming a variable timer will not make it count down seconds on its own. You, the programmer, must write the code to change the value every second!
4. The Forgotten Reset (Initialization Error)
The Mistake: Forgetting to put Set score to 0 at the start of your game.
Why it breaks: When a player clicks the green flag to start a new game, they will still have the points from their previous game instead of starting fresh at 0!
5. Maths vs. Programming Equals
In maths class, writing \(x = x + 1\) is impossible because a number cannot equal itself plus one.
In computer programming, \(x = x + 1\) is a very common instruction! It simply means: "Take the current value of \(x\), add 1 to it, and make that the brand new value of \(x\)!"
Key Takeaway: Remember that "Set" assigns an exact value, "Change" adds or subtracts from the current value, and names don't do the coding for you!
5. Quick Chapter Summary
• A variable is a named space in memory that holds a single value which can change during a program.
• Numeric variables hold numbers (points, timers); string variables hold text (player names).
• Variable names must be meaningful and contain no spaces.
• Always initialize your variables at the start (e.g., Set score to 0).
• Use Change to increase/decrease values, and use Set to give an exact starting or reset value.