Programming with Scratch

A program is a set of instructions written in a language that a computer can follow, and the person who writes it is a programmer. Before a single instruction is typed or dragged, the programmer must work out the algorithm — a finite, step-by-step method that solves the problem in a definite order.

Most programming languages are text-based. In a text-based language such as Python, Java or C++, every instruction is typed as a line of text and must obey the grammar of that language exactly. Miss a bracket or spell a keyword wrongly, and the computer reports a syntax error — an error caused by breaking the grammar rules of the language — and refuses to run the program at all. A beginner can then lose a whole lab period hunting a missing semicolon instead of learning logic.

Block-based programming, also called visual programming, was created to remove exactly that obstacle. Instructions come as ready-made blocks shaped like jigsaw pieces; the learner drags one out of the palette and snaps it under another. Because the wording, spelling and punctuation are already printed inside the block, a syntax error is impossible. Because every block has a shape, blocks that do not belong together simply refuse to join. The learner's attention goes entirely to the part that matters: what should happen, in what order, under what condition, and how many times.

Scratch is the best known block-based language. It was developed by the Lifelong Kindergarten group at the MIT Media Lab and is free to use. It runs in a web browser or as an offline editor installed on the computer, so a lab with a slow connection can still use it. A piece of work made in Scratch is called a project. In current versions a saved project file carries the extension .sb3; older versions used .sb2, so quote the extension only if your textbook does.

Advantages an examiner expects you to list: syntax errors cannot happen; the output is visible immediately on the stage, so a mistake in logic is spotted at once; blocks are colour-coded, so the right instruction is easy to find; sound, pictures and animation are built in; and the same three control structures — sequence, selection and iteration — reappear in Python and Java, so the thinking transfers.

Know the limits as well, because a state two limitations question is common. Dragging is slower than typing, so long programs are tiring to build; large scripts become hard to read; block languages are not normally used to build professional software; and, apart from a few ready-made extensions, they do not work easily with files, databases or hardware. Scratch is a learning language — the logic it teaches is later rewritten in a text-based language.

What the examiner wants: define block-based programming as a way of writing programs by dragging and joining ready-made instruction blocks instead of typing text, and then give one advantage in your own words.

The Scratch editor is one window divided into four working areas. Learn all four names: questions often ask simply where a project runs or where blocks are joined, and labelling a diagram of the window is a standard practical-file task. The exact arrangement shifts between editors and versions, so describe the areas by what they do rather than by a fixed corner of the screen.

1. The stage. The stage is the rectangular area, usually at the upper right, where the project actually runs. It is the output area — everything the viewer sees happens here. The stage uses a coordinate system: the centre is x = 0, y = 0; x runs from −240 on the left to 240 on the right, and y from −180 at the bottom to 180 at the top, so the stage is 480 units wide and 360 units tall. The picture behind everything is called the backdrop. A project may hold several backdrops and switch between them to change scene. The stage can hold scripts of its own, but it cannot move, and it has backdrops rather than costumes.

2. The sprite list, also called the sprite pane. A sprite is an object or character in the project that can be given instructions — the cat, a ball, a car, a button. Every sprite owns its own scripts, its own costumes and its own sounds. The sprite pane, normally just below the stage, shows a small picture of every sprite and lets you set its name, its x and y position, its size, its direction and whether it is shown or hidden. New sprites come from the sprite library, the paint editor or a file.

3. The blocks palette. This is the tall column on the left listing every instruction available, arranged in colour-coded categories. Nothing in the palette runs the project — blocks must first be dragged out of it.

4. The code area, also called the script area. This is the large working space in the middle. Blocks dragged here and snapped together form a script: one connected stack that runs as a single unit. A sprite may hold several separate scripts side by side, and they can run at the same time. Clicking a script once runs it straight away, a quick way to test part of a project.

Above the code area sit three tabs — Code, Costumes and Sounds. When the stage is selected instead of a sprite, the Costumes tab becomes Backdrops. Above the stage are the green flag, which starts the project, the red stop sign, which stops every running script, and a full-screen button that hides the editor. The File menu offers New, Save to your computer and Load from your computer, though the exact wording differs between the online and offline editors.

What the examiner wants: keep two pairs straight. Sprite versus stage — the sprite is a movable object, the stage is the fixed area it moves on. Costume versus backdrop — a costume belongs to a sprite, a backdrop belongs to the stage.

In the current version of Scratch the palette groups blocks into nine categories; older versions grouped them differently, so follow your textbook. Colours also differ between versions, so learn the names and the jobs rather than the colours.

Motion blocks move and turn a sprite: move 10 steps, turn 15 degrees, go to x: y:, glide 1 secs to x: y:, if on edge, bounce. Motion blocks work only on sprites, never on the stage. Looks blocks change appearance: say [Namaste!] for 2 seconds, think, switch costume to, next costume, show and hide. Sound blocks play and control sound: start sound, play sound until done, change volume by.

Events blocks start scripts when something happens — when green flag clicked, when [space] key pressed, when this sprite clicked, when I receive [message]. Control blocks decide the order in which instructions run: wait, repeat, forever, if ... then, if ... then ... else, repeat until, stop. Sensing blocks let the project notice the outside world: touching [edge]?, key [space] pressed?, mouse down?, and ask [ ] and wait together with the answer reporter.

Operators blocks do the arithmetic and the comparing: +, −, *, /, pick random 1 to 10, the comparisons >, < and =, the logic blocks and, or, not, and the text block join. Variables blocks create and change stored values, and also hold lists. My Blocks lets you build your own named block from instructions you keep repeating.

Every block also has a shape, which decides where it is allowed to go. A hat block has a curved top, sits at the very top of a script and starts it — every Events block is a hat block. A stack block is the ordinary jigsaw shape with a notch on top and a bump below; it does one job and passes control to the block underneath. A reporter block is rounded and reports a value — a number or text — such as x position, answer, pick random and every variable. It never sits in a stack on its own but drops into a rounded hole inside another block. A Boolean block is hexagonal — pointed at both ends — and reports only true or false — touching [edge]?, key pressed?, ( ) > ( ). It fits only into a hexagonal hole. A cap block is flat along the bottom and ends a script, so nothing can be attached below it: stop [all] and the forever loop behave this way.

Sequence is the first and simplest control structure: instructions are carried out one after another from the top of the script to the bottom, each block finishing before the next starts. Order therefore changes the result — in the script below, swapping the last two blocks would make the sprite move before it speaks, which is a different program built from identical blocks.

when green flag clicked
go to x: 0 y: 0
point in direction 90
say [Namaste! Watch me move.] for 2 seconds
move 100 steps

What the examiner wants: for name the category questions, connect the verb to the group — moving is Motion, saying is Looks, deciding or repeating is Control, detecting is Sensing, calculating or comparing is Operators.

A control structure decides the order in which the instructions of a program are carried out. There are only three, and every program in every language is built from them in some combination. Scratch shows all three as visible shapes.

1. Sequence. Instructions run one after another, top to bottom, each finishing before the next begins; a plain stack of blocks under a hat block is a sequence. Making tea is a sequence — boil water, add tea leaves, add milk, strain — and changing the order changes the result.

2. Selection, also called branching or decision. The program tests a condition and chooses which instructions to run. A condition is anything that is either true or false, so in Scratch it is always a hexagonal Boolean block dropped into the hexagonal hole. Scratch offers two selection blocks. The if ... then block runs the blocks inside its mouth only when the condition is true. The if ... then ... else block has two mouths: the first runs when the condition is true, the second when it is false. Exactly one of the two always runs, never both, never neither.

when green flag clicked
ask [What is 12 x 8?] and wait
if <(answer) = 96> then
    say [Correct!] for 2 seconds
else
    say [Wrong. The answer is 96.] for 2 seconds

Putting a second if inside the else mouth of the first is called nesting, and it is how a program grades marks into A, B and C.

3. Iteration, also called looping or repetition. A group of instructions is carried out more than once, so the same block need not be dragged twenty times. Scratch has three loop blocks, and the difference between them is commonly asked.

repeat (10) is a counted loop: the blocks inside run a fixed number of times that you type in. forever is an infinite loop: the blocks inside repeat endlessly until the red stop sign is clicked or a stop block runs. It is a cap block — flat along the bottom — so nothing can be attached below it, because nothing below it could ever run. repeat until <condition> is a conditional loop: it checks the condition before each pass and keeps repeating while the condition is false, stopping the moment it becomes true. Because the test comes first, a repeat until loop may run zero times — if the condition is already true when the loop is reached, the blocks inside are never carried out at all. That single sentence answers many questions about loops.

when green flag clicked
go to x: -200 y: 0
repeat until <(x position) > 200>
    change x by 10
    next costume
say [I reached the other side.] for 2 seconds

A loop inside another loop is a nested loop, used for patterns — an outer repeat 4 that turns a corner with an inner repeat 10 that draws a dotted edge.

What the examiner wants: name all three in order — sequence, selection, iteration — define each in one line, and give one block as evidence for each: a plain stack, if ... then ... else and repeat. If the question says with an example, a short script answers better than a paragraph.

An event is something that happens which a program can notice and respond to — a click, a key press, a message arriving. Scratch is event-driven, which means no script runs on its own; each script waits under a hat block until its event occurs, which is how the software on a phone or a computer behaves.

The commonest hat block is when green flag clicked. The green flag above the stage is the start button. Clicking it fires every such script in every sprite and in the stage at the same moment, so several scripts run side by side. The red stop sign beside it stops all running scripts at once. Other Events hat blocks include when [space] key pressed, which is how arrow-key control of a game is built; when this sprite clicked, used for buttons; when backdrop switches to [ ]; and when loudness > (10), which reacts to sound from the microphone.

A single sprite may carry several scripts, each with its own hat block, running independently: one can hold a forever loop that moves the sprite while another waits for a key press, which is how a game character moves and jumps at once.

Broadcasting is the way sprites talk to one another. A broadcast is a message sent by one sprite (or by the stage) that every sprite in the project can hear. It is like an announcement over the school public address system: the office speaks once, and every class told to act on it does so. Messages are made in the Events category with New message and should be given meaningful names such as correctAnswer or gameOver.

Three blocks are involved. broadcast [message] sends the message and the sending script carries straight on. broadcast [message] and wait sends it and then pauses the sending script until every script that received it has finished. when I receive [message] is a hat block: any sprite carrying it starts that script the moment the message is sent. One message may be received by many sprites, and a sprite may listen for several messages.

Here two sprites are synchronised: the Teacher sprite asks a question, and the Star sprite stays hidden until it hears the message.

Sprite: Teacher
when green flag clicked
ask [Capital of India?] and wait
if <(answer) = [Delhi]> then
    broadcast [correctAnswer]
else
    say [Not quite. It is Delhi.] for 2 seconds

Sprite: Star
when green flag clicked
hide

when I receive [correctAnswer]
go to x: 0 y: 100
show
repeat 10
    change size by 5
    wait 0.1 seconds
set size to 100 %

Without broadcasting the Star sprite could not know what the Teacher sprite found out, because a sprite cannot read another sprite's script. Broadcasting is therefore the method of communication and synchronisation between sprites.

What the examiner wants: define broadcasting as sending a message from one sprite that other sprites can receive, so their scripts start at the right moment, name the pair broadcast and when I receive, and add that broadcast and wait pauses the sender.

A variable is a named location in the computer's memory that holds a value which can change while the program runs. The name stays the same; the value varies — which is why it is called a variable. It can hold a number such as 250 or text such as Anita.

A variable is created in the Variables category with Make a Variable. You type a meaningful name — score, lives, total — and choose one of two options. For all sprites makes a global variable that every sprite and the stage can read and change, so a game score should be global. For this sprite only makes a local variable belonging to that one sprite. The new variable appears in the palette as a rounded reporter block.

Three blocks handle it. set [score] to (0) puts a value in, replacing whatever was there — always use it at the start of a project to reset. change [score] by (1) adds to the current value, so it is used for counting; change [score] by (-1) subtracts. The tick box beside the variable, or the show variable block, displays it on the stage in a small watcher panel — the easiest way to check a program while it runs.

A shop example in rupees:

when green flag clicked
ask [Price of one notebook in rupees?] and wait
set [price] to (answer)
ask [How many notebooks?] and wait
set [quantity] to (answer)
set [total] to ((price) * (quantity))
say (join [Total: Rs ] (total)) for 3 seconds

Notice that answer is only a temporary Sensing reporter — it is replaced by the next ask. That is why the value is copied into a variable straight away.

A costume is one of the alternative pictures of a sprite. A sprite may have many costumes, managed in the Costumes tab, where they can be painted, uploaded or chosen from the library. Only one is visible at a time. The Looks blocks switch costume to [ ] and next costume change which one is shown; next costume moves to the following costume and wraps round to the first after the last.

Animation is created by switching costumes quickly one after another so that the eye reads the change as movement — the same principle as a flip book. Two costumes showing a character with legs apart and legs together are enough for a walk. A wait block inside the loop controls the speed: without it the costumes change too fast to see.

when green flag clicked
go to x: -180 y: 0
point in direction 90
forever
    next costume
    move 10 steps
    if on edge, bounce
    wait 0.1 seconds

The stage does the same with backdrops: switch backdrop to [classroom] changes the scene, and next backdrop steps through them.

What the examiner wants: define a variable as a named memory location whose value can change during the program, and state the difference between set (replaces the value) and change (adds to it). For animation, say costumes switched rapidly with a wait between them, not just the sprite moves.

Dragging blocks before the logic is clear wastes a lab period. The correct order of work is problem, algorithm, flowchart, program, testing, and questions are often set on the planning stages alone.

An algorithm is a finite sequence of unambiguous steps that solves a problem. It must have a definite start and stop, take input, produce output, and use steps clear enough that two people would carry them out identically. A flowchart is the same algorithm drawn as a diagram, using standard symbols joined by arrows called flow lines. A loop or a branch is visible at a glance, but a long flowchart is clumsy to draw and to change.

The symbols to memorise: an oval (terminal) marks Start and Stop; a parallelogram marks input and output; a rectangle marks a process such as a calculation; a diamond marks a decision, with one arrow in and two out labelled Yes and No; a small circle is a connector; and arrows show the flow.

The worked project: Guess the Secret Number. The computer picks a secret number from 1 to 20. The player keeps guessing; after each guess the sprite says whether it is too low or too high, and the tries are counted. When the guess is correct a second sprite appears to celebrate.

The algorithm, in plain language:

1. Start.
2. Set secret to a random whole number from 1 to 20.
3. Set tries to 0 and guess to 0.
4. Repeat until guess equals secret: ask for a guess; store it in guess; add 1 to tries; if guess is less than secret say Too low, otherwise if it is greater say Too high.
5. Broadcast the message winner.
6. Display the number of tries.
7. Stop.

The flowchart begins with an oval Start and a rectangle for the three variable settings, then a diamond asking guess = secret? Its No arrow leads to an input parallelogram, a rectangle for tries = tries + 1 and a second diamond guess < secret?, whose two outputs loop back. Its Yes arrow leads to an output for the tries and an oval Stop.

The first sprite holds the logic:

Sprite: Cat
when green flag clicked
set [secret] to (pick random (1) to (20))
set [tries] to (0)
set [guess] to (0)
repeat until <(guess) = (secret)>
    ask [Guess my number from 1 to 20] and wait
    set [guess] to (answer)
    change [tries] by (1)
    if <(guess) < (secret)> then
        say [Too low - guess higher.] for 1 seconds
    else
        if <(guess) > (secret)> then
            say [Too high - guess lower.] for 1 seconds
broadcast [winner]
say (join [Correct! Tries: ] (tries)) for 3 seconds

Two details matter. guess is set to 0 at the start because 0 can never equal a secret number from 1 to 20, so the repeat until loop is guaranteed to run at least once. The inner if is nested inside the else, so when the guess is neither lower nor higher — that is, correct — nothing is said and the loop ends.

The second sprite waits for the message:

Sprite: Balloon
when green flag clicked
hide

when I receive [winner]
go to x: (0) y: (100)
show
repeat 10
    change size by (5)
    wait 0.1 seconds
set size to (100) %

Finally, test the project. A bug is an error in a program and debugging is finding and removing it. Test with a guess of 1, a guess of 20 and a wrong guess, and tick the variable watchers to see secret and tries change.

What the examiner wants: when a question says write an algorithm and the Scratch blocks, give numbered steps ending in Stop, then the script. Never skip the algorithm.