OpenStax-CNX module: m46239 1

Scr0340: Arithmetic Operators in

*
Scratch 2.0

R.G. (Dick) Baldwin

This work is produced by OpenStax-CNX and licensed under the

Creative Commons Attribution License 3.0„

Abstract
The purpose of this module is to teach you about operators and operands in general and arithmetic
operators in particular. You will also learn about expressions and statements, and you will learn how to
write a Scratch program that illustrates the use of arithmetic operators in Scratch.

1 Table of Contents

• Preface (p. 2)
· Viewing tip (p. 2)
* Images (p. 2)
• General background information (p. 3)
Operators (p. 3)
·
Operands (p. 3)
·
Expressions (p. 3)
·
Statements (p. 3)
·
A brief word about type (p. 4)
·
Unary, binary, and ternary operators (p. 4)
·
* Some operators can be either unary or binary (p. 4)
* The minus character as a unary operator (p. 4)
* Binary operators use inx notation (p. 4)
· General behavior of an operator (p. 5)
· Operator categories (p. 5)
• Preview (p. 5)
• Discussion and sample code (p. 5)
· Four variables (p. 6)
· A button (p. 7)
· Two scripts in the rightmost panel (p. 7)
· Variables with sliders (p. 7)
* How to create a slider (p. 7)
* Version 1.1: May 13, 2013 11:52 am +0000
„ http://creativecommons.org/licenses/by/3.0/

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 2

· Expanded view of the rightmost panel (p. 7)

· Initialize the variable values to zero (p. 8)
· Dene the behavior of the button (p. 8)
* Constructing the script (p. 9)
* Not exactly what we want to happen (p. 11)
· The Operators toolbox (p. 11)
* Four arithmetic operators (p. 11)
* Use an asterisk for multiplication (p. 11)
* Use a forward slash for division (p. 11)
* More blocks of the correct shape (p. 11)
* Random numbers (p. 11)
* The modulus (p. 12)
* Various numeric representations (p. 12)
* Rounding a number (p. 12)
· Drag and drop the plus and minus operators (p. 12)
· A few more steps are required (p. 14)
· Operation of the program (p. 14)
· An online version of this program is available (p. 15)
• Run the program (p. 15)
• Student programming project (p. 16)
• Summary (p. 17)
• What's next? (p. 18)
• Resources (p. 18)
• Miscellaneous (p. 19)

2 Preface

Scratch 2.0 1 (released May 9, 2013) is the second major version of Scratch to be released during the life of
the product. Among other things, it features a redesigned editor and website, and allows you to edit projects
directly from your web browser.
This module is one in a collection of modules designed to help beginners of all ages (8 and up) learn
how to create the code for computer programs using Scratch 2.0 2 . Information is provided not only for the
beginners themselves but also for their parents and teachers where appropriate.
The purpose of this module is to teach you about operators and operands in general and arithmetic
operators in particular. You will also learn about expressions and statements, and you will learn how to
write a Scratch 3 program that illustrates the use of arithmetic operators in Scratch.
I will also provide the specications for a student-programming project for you to complete in order to
demonstrate your understanding of what you learned from the rst program.

2.1 Viewing tip

I recommend that you open another copy of this module in a separate browser window and use the following
links to easily nd and view the images while you are reading about them.

2.1.1 Images
• Image 1 (p. 6) . Reduced screen shot of Arithmetic01 programming interface.
1 http://scratch.mit.edu/
2 http://scratch.mit.edu/
3 http://scratch.mit.edu/

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 3

• Image 2 (p. 8) . Expanded view of the rightmost panel.

• Image 3 (p. 10) . Preparing to use the arithmetic operators.
• Image 4 (p. 13) . Result of dropping addition and subtraction operators into variable blocks.
• Image 5 (p. 14) . Stage area of the nished program.
• Image 6 (p. 16) . Making the button say ouch.
• Image 7 (p. 17) . Output from student project program named Arithmetic02.

3 General background information

3.1 Operators
Operators are the action elements of a computer program. They perform actions such as adding two variables,
dividing one variable by another variable, comparing one variable to another variable, etc.

3.2 Operands
According to the current jargon, operators operate on operands .
For example, in the following expression, the plus character is an operator while x and y are operands.
x+y
Assuming that x and y are numeric variables, this expression produces the sum of the values stored
in the variables named x and y . The variable x would be called the left operand and the variable y
would be called the right operand .

3.3 Expressions
Computer programs in many languages consist of statements, which in turn, consist of expressions. (Pro-
gramming blocks substitute for statements in Scratch.)
An expression is a specic combination of operators and operands that evaluates to a particular
result. The operands can be variables, literals, or method calls. (Note that Scratch v1.4 didn't
support methods. However, Scratch 2.0 allows you to design and create your own blocks, which
helps to alleviate that deciency.)
In your past experience, you may have referred to expressions by the names formulas or equations .
Although formulas and equations are not exactly the same thing as expressions, they are close enough to
help you understand what expressions are and how they are used.

3.4 Statements
A statement is a specic combination of expressions. The following is an example of a statement comprised
of expressions in a text-based language such as Java, C++, or C#.
z = x + y;
Operationally, values are retrieved from the variables named x and y in the above statement. These
two values are added together. The result is stored in (assigned to) the variable named z , replacing
whatever value may previously have been contained in that variable.
The plus character (+) would commonly be called the addition operator or the concatenation operator,
depending on the type of data stored in the variables named x and y . The equal character (=)
would commonly be called the assignment operator in Java, Alice, C#, and C++, but we will see in a future
module that it is also used as a relational operator in Scratch.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 4

3.5 A brief word about type

As a very crude analogy, you can think of variables as the pens at the animal shelter and think of type
as the kinds of animals that reside in those pens. Dogs and cats are dierent types of animals that don't
usually coexist very well in the same pen. Therefore, they are normally put in dierent pens.
Similarly, dierent types of data don't coexist well in the same variable in type-sensitive languages.
Therefore, in type-sensitive languages, there are very stringent rules as to the types of data that can be
stored in each variable.
Scratch has two types of data that can be stored in a variable (numeric and string) . However, Scratch
is not a type-sensitive language so type is not an issue in Scratch. (Scratch also has a semblance of a
boolean type but it tends to take care of itself.)

3.6 Unary, binary, and ternary operators

Many programming languages provide operators that can be used to perform an action on one, two, or three
operands. I believe that operators in Scratch are conned to only one or two operands.
An operator that operates on one operand is called a unary operator. An operator that operates on two
operands is called a binary operator. An operator that operates on three operands is called a ternary
operator.

3.6.1 Some operators can be either unary or binary

Some operators can behave either as a unary or as a binary operator in languages such as Java and C#.
The best-known operator that can behave either way in those languages is the minus character (-).
As a binary operator, the minus character causes its right operand to be subtracted from its left operand.
For example, the third statement below subtracts the variable y from the variable x and assigns the
result of the subtraction to the variable z . After the third statement is executed, the variable z contains
the value 1.
• x = 6;
• y = 5;
• z = x - y;

3.6.2 The minus character as a unary operator

As a unary operator, the minus character causes the algebraic sign of the right operand to be changed. For
example, the second statement below causes a value of -5 to be assigned to (stored in) the variable x .
• y = 5;
• x = -y;

3.6.3 Binary operators use inx notation

To keep you abreast of the current jargon, binary operators in Scratch always use inx notation. This
means that the operator appears between its operands.
Some other programming languages have unary operators that use prex notation and postx
notation. For prex notation, the operator appears before (to the left of) its operand. For postx notation,
the operator appears after (to the right of) its operand.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 5

3.7 General behavior of an operator

As a result of performing the specied action, an operator can be said to return a value (or evaluate to a
value) of a given type. The type of value returned depends on the operator and the type of the operands.
To evaluate to a value means that after the action is performed, the operator and its operands
are eectively replaced in the expression by the value that is returned.

3.8 Operator categories

There are many dierent kinds of operators. Therefore, the easiest way to study them is to divide them into
categories such as the following
• arithmetic
• relational
• logical
• bitwise
• assignment
This module will concentrate on arithmetic operators. Future modules will deal with other kinds of operators.

4 Preview

In this module, I will present and explain a Scratch program named Arithmetic01 . This program
illustrates the use of the following arithmetic operators (see the bottom script in the rightmost panel of
Image 4 (p. 13) ):
• + (addition)
• - (subtraction)

Variables with the following names are created and displayed on the stage (see Image 5 (p. 14) ):
• LeftOperand - has a slider
• RightOperand - has a slider
• Sum
• Di
In addition, a button is displayed on the stage.
The user adjusts the values of the LeftOperand and RightOperand variables with a pair of sliders.
When the user clicks the button, the variable named Sum displays the sum of the values of the left and
right operands. The variable named Di displays the result of subtracting the right operand from the left
operand.

5 Discussion and sample code

I'm going to walk you through the steps required to develop this program, being brief on those things that
you already know about and being more verbose on the new material.
To begin with, Image 1 (p. 6) shows a reduced screen shot of the online programming interface in the
browser window. Note that the source code in the rightmost panel was reduced in size to help it t into
this presentation format. The stage was also switched to the small format by clicking the little triangle
immediately below the stage.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 6

Image 1. Reduced screen shot of Arithmetic01 programming interface.

Figure 1: Image 1. Reduced screen shot of Arithmetic01 programming interface.

Image 1 (p. 6) lacks detail due to the requirement to reduce the size of the image for publication in this
format, but there are some aspects of Image 1 (p. 6) that can be seen.

5.1 Four variables

The center panel (and the stage) shows that four variables have been created. In case you can't read the
names of those variables, I will list them here:
• LeftOperand
• RightOperand
• Sum
• Di
You can probably see that the checkbox next to each variable has been checked. As you learned in an earlier
module, checking this box causes the variable to be displayed in the Stage area on the upper left. Thus you
can see all four variables being displayed in the upper left corner of the Stage.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 7

5.2 A button
Skipping to the area immediately below the Stage, you can see that a button sprite has been added to the
program. That button has been selected in Image 1 (p. 6) , making it possible to drag blocks from the
toolboxes into the rightmost panel to control the behavior of the button.

5.3 Two scripts in the rightmost panel

Although you probably can't read the details in Image 1 (p. 6) , you can see that there are two scripts
showing in the rightmost panel. (I will show you an expanded screen shot of the rightmost panel later in
Image 2 (p. 8) .)
For now, suce it to say that the top script initializes the values stored in all four variables when the user
clicks the green ag in the upper right of the stage in Image 1 (p. 6) . The bottom script in the rightmost
panel denes the behavior of the program when the user clicks the button in the Stage area.

5.4 Variables with sliders

If you look carefully, you can tell that the top two variables that are displayed in the Stage area look dierent
from the bottom two variables. This is because a slider has been assigned to each of the top two variables
(see Image 5 (p. 14) ) . This makes it possible for the user to manually set the values stored in each of
these two variables by moving the thumb or pointer on the slider.

5.4.1 How to create a slider

To create a slider for a variable, right click on the display of the variable in the Stage area and select slider
in the popup menu that appears.
Once you have caused a slider to appear with the variable display, you can right-click on the variable
display again and select set slider min and max in the popup menu to specify the range of the slider.
This will cause a simple dialog box to appear into which you can enter the minimum value and the maximum
value and then click an OK button. In this program, I have both sliders set to a minimum value of -10 and
a maximum value of +10.

5.5 Expanded view of the rightmost panel

Image 2 (p. 8) shows an expanded view of the rightmost panel after having selected the button icon in the
area immediately below the Stage in Image 1 (p. 6) .

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 8

Image 2. Expanded view of the rightmost panel.

Figure 2: Image 2. Expanded view of the rightmost panel.

5.6 Initialize the variable values to zero

As I mentioned earlier, the top script in Image 2 (p. 8) sets the value of each of the four variables to zero
when the user clicks the green ag. The code in that script should be completely familiar to you by now and
no explanation should be necessary.

5.7 Dene the behavior of the button

The bottom script in Image 2 (p. 8) denes the behavior of the program when the button is clicked. Basically,
that code says to set the value of the variable named Sum to the sum of the contents of the two variables
named LeftOperand and RightOperand and to set the value of the variable named Di to the
value of the LeftOperand minus the value of the RightOperand .

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 9

5.7.1 Constructing the script

That seems straightforward enough. However, the process of constructing that script contains some new
material, so I will walk you through the process.
Image 3 (p. 10) shows the state of the development process immediately after
• the set blocks for the variables named Sum and Di have been dragged from the Data toolbox
to the rightmost panel and connected to the block that reads when this sprite clicked , and
• the Operators toolbox has been selected.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 10

Image 3. Preparing to use the arithmetic operators.

http://cnx.org/content/m46239/1.1/
Figure 3: Image 3. Preparing to use the arithmetic operators.
OpenStax-CNX module: m46239 11

5.7.2 Not exactly what we want to happen

In Image 3 (p. 10) , as it stands now, the variables named Sum and Di will be set to a value of zero
when the user clicks the button. That isn't what we want, so we have some more programming to do.
The desired behavior is for the value of the variable named Sum to be set to the sum of the variables
named LeftOperand and RightOperand when the user clicks the button. Similarly, we want the value
of the variable named Di to be set to the dierence between those two variables.

5.8 The Operators toolbox

The left panel in Image 3 (p. 10) shows the blocks that are exposed when the green button labeled Oper-
ators is clicked.
Some of those blocks are of the correct shape to t into the white boxes in the two bottom orange blocks
in the rightmost panel. This means that we could drag any one of those blocks and drop it into one of the
white boxes.

5.8.1 Four arithmetic operators

The top four green blocks in the left panel of Image 3 (p. 10) are particularly interesting. They contain the
following arithmetic symbols as part of their labels:
• +
• -
• *
• /
These are the symbols that are commonly used for addition, subtraction, multiplication, and division in
computer programming. The top two match what you are accustomed to seeing on your hand calculator,
but the bottom two probably don't match.

5.8.2 Use an asterisk for multiplication

Most programming languages use the * character instead of the X character for multiplication in order
to keep the multiplication operator from being confused with the letter that uses the X symbol.

5.8.3 Use a forward slash for division

Insofar as division is concerned, most computer keyboards don't have a symbol that matches the symbol
commonly used for division on hand calculators, so the / character is used instead.

5.8.4 More blocks of the correct shape

Before leaving the discussion of the left panel in Image 3 (p. 10) , I will explain the behavior of four additional
blocks that are of the correct shape for being dropped into the white boxes in the blocks in the rightmost
panel. (The remaining blocks beyond those four deal with strings, which I will ignore for now.)

5.8.5 Random numbers

The block labeled pick random 1 to 10 lets you enter other values in place of 1 and 10. Then this block
will deliver a random number within that range when it is called upon to do so. Random numbers are often
used in game programs to simulate the throwing of dice or the spinning of a wheel of fortune.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 12

5.8.6 The modulus

The block labeled mod will produce the modulus of two values when called upon to do so. The modulus of
two numbers is the remainder that results from dividing one number by another number. You may remember
the remainder from when you learned to do long division in elementary school but before you learned about
decimals.

5.8.7 Various numeric representations

The block labeled sqrt will deliver about a dozen dierent representations of numeric values, depending
on what is selected from the pull-down list. This includes the square root, trigonometric functions, absolute
value, etc.

5.8.8 Rounding a number

Finally, the block labeled round will round a decimal number to the nearest whole number.

5.9 Drag and drop the plus and minus operators

Image 4 (p. 13) shows the result of dragging the top two green blocks from the Operators toolbox and
dropping them into the white boxes in the bottom two orange variable blocks in the rightmost panel of Image
3 (p. 10) .

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 13

Image 4. Result of dropping addition and subtraction operators into variable blocks.

http://cnx.org/content/m46239/1.1/

Figure 4: Image 4. Result of dropping addition and subtraction operators into variable blocks.
OpenStax-CNX module: m46239 14

5.10 A few more steps are required

If you compare Image 4 (p. 13) with Image 2 (p. 8) , you will see that Image 4 (p. 13) is close to what we
need but we aren't quite there yet. In order to cause the bottom two blocks in the rightmost panel in Image
4 (p. 13) to match the bottom two blocks in Image 2 (p. 8) , we need to do the following:
• Click the orange Data button in the upper left of Image 4 (p. 13) to expose the variables as shown
in Image 1 (p. 6) .
• Drag the blocks for the variables named LeftOperand and RightOperand from the Data
toolbox and drop them into the white boxes in the bottom two blocks in Image 4 (p. 13) to make them
match the bottom two blocks in Image 2 (p. 8) .
That's the solution. The upper left portion of your Stage area should now look similar to Image 5 (p. 14) .
Note however that you may need to use the mouse to arrange the four variables and the button to get your
Stage arranged like Image 5 (p. 14) .

Image 5. Stage area of the nished program.

Figure 5: Image 5. Stage area of the nished program.

5.11 Operation of the program

Once you reach this point, you can click the green ag to initialize all four variables to zero.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 15

Then you can move the sliders back and forth to manually set the values for the variables named Left-
Operand and RightOperand .
If you click immediately to the right or left of the thumb on a slider, that will cause the thumb
to move a small distance in that direction.
Then when you click the button at the bottom of Image 5 (p. 14) , the variable named Sum will display
the sum of the values of the top two variables, and the variable named Di will display the value of
LeftOperand minus the value of RightOperand .
5.12 An online version of this program is available
A copy of this program has been posted online for your review (see Resources (p. 18) for the URL) . If
you don't nd the program using that URL, search the Scratch site for the user named dbal.

6 Run the program

I encourage you to use the information provided above to write this program. Experiment with the code,
making changes, and observing the results of your changes. Make certain that you can explain why your
changes behave as they do.
Just for fun, move the button a little to the right and cause it to say Ouch for about ve seconds each
time you click it as shown in Image 6 (p. 16) . Hint: See the purple button labeled Looks in Image 3 (p.
10) .

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 16

Image 6. Making the button say ouch.

Figure 6: Image 6. Making the button say ouch.

I also encourage you to write the program described below.

7 Student programming pro ject

Write a Scratch program named Arithmetic02 that produces the output shown in Image 7 (p. 17) when
the user adjusts the sliders to the values shown and clicks the button. Make the word Ouch! appear and
then go away after about ve seconds.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 17

Image 7. Output from student project program named Arithmetic02.

Figure 7: Image 7. Output from student project program named Arithmetic02.

A copy of this program has been posted online for your review (see Resources (p. 18) for the URL) . If
you don't nd the program using that URL, search the Scratch site for the user named dbal .

8 Summary

I began by teaching you about operators and operands in general. I also taught you about expressions
and statements . I gave a very brief introduction of the concept of type .
I presented and explained a sample Scratch program that illustrates how to use arithmetic operators in
Scratch.

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 18

Finally, I provided the specications for a student-programming project for you to write in order to
demonstrate your understanding of what you learned from the rst program.
Copies of both programs have been posted online for your review (see Resources (p. 18) for the URL)
. If you don't nd the program using that URL, search the Scratch site for the user named dbal.

9 What's next?

This module concentrated on arithmetic operators. The next few modules will deal with relational and
logical operators as well as selection and loops.

10 Resources

• Scratch home 4
• Scratch tutorials 5
• Scratch explanatory video 6
• Scratch tutorials from MIT 7
• Scratch tutorial - Digital Art for All 8
• Scratch for Budding Computer Scientists 9
• Learn Scratch at learnscratch.org 10
• Scratch Tutorial - Space Shuttle Mission STS-2020 11
• SCRATCH TUTORIALS ICT In Primary Education 2012-2013 12
• Scratch Wiki 13
• Scratch WikiTable of ContentsWebsite - Scratch Wiki 14
• Scratch WikiTable of ContentsTutorials - Scratch Wiki 15
• Scratch WikiTable of ContentsProgram - Scratch Wiki 16
• Tutorial about Variables - Scratch Wiki 17
• Scratch support MIT web site 18
• Scratch resources at Scratch.ie 19
• ScratchEd Resources 20
• Scratch project Day Dream 21
• Scratch project Son of String Art 22
• Scratch Project Scratch Tutorial 23
• Variable01 24 - Online version of program
4 http://scratch.mit.edu/
5 http://mit.edu/∼sil/www/scratch/
6 http://www.code.org/learn/scratch
7 http://info.scratch.mit.edu/Video_Tutorials
8 http://www.digitalartforall.com/category/scratchtutorials/
9 http://cs.harvard.edu/malan/scratch/
10 http://learnscratch.org/
11 http://scratched.media.mit.edu/resources/scratch-tutorial-space-shuttle-mission-sts-2020
12 http://ictinprimary.webnode.es/scracth-tutorials/
13 http://wiki.scratch.mit.edu/wiki/Main_Page
14 http://wiki.scratch.mit.edu/wiki/Scratch_Wiki:Table_of_Contents/Website
15 http://wiki.scratch.mit.edu/wiki/Scratch_Wiki:Table_of_Contents/Tutorials
16 http://wiki.scratch.mit.edu/wiki/Scratch_Wiki:Table_of_Contents/Program
17 http://wiki.scratch.mit.edu/wiki/Tutorial_about_Variables
18 http://info.scratch.mit.edu/Support
19 http://www.scratch.ie/resources
20 http://scratched.media.mit.edu/resources
21 http://scratch.mit.edu/projects/cremeglace/40150
22 http://scratch.mit.edu/projects/Paddle2See/89023
23 http://scratch.mit.edu/projects/turkey3/2576871
24 http://scratch.mit.edu/projects/dbal/154446

http://cnx.org/content/m46239/1.1/
OpenStax-CNX module: m46239 19

• Variable02 25 - Online version of student programming project

• Variable03 26 - Online version of student programming project
• IfSimple01 27 - Online version of program
• IfWithVar01 28 - Online version of student programming project
• Arithmetic01 29 - Online version of program
• Arithmetic02 30 - Online version of student programming project

11 Miscellaneous

This section contains a variety of miscellaneous information.

note: Housekeeping material
• Module name:Scr0340: Arithmetic Operators in Scratch 2.0
• File: Scr0340.htm
• Published: 05/13/13

note: Disclaimers: Financial : Although the Connexions site makes it possible for you to
download a PDF le for this module at no charge, and also makes it possible for you to purchase a
pre-printed version of the PDF le, you should be aware that some of the HTML elements in this
module may not translate well into PDF.
I also want you to know that, I receive no nancial compensation from the Connexions website even
if you purchase the PDF version of the module.
In the past, unknown individuals have copied my modules from cnx.org, converted them to Kindle
books, and placed them for sale on Amazon.com showing me as the author. I neither receive
compensation for those sales nor do I know who does receive compensation. If you purchase such
a book, please be aware that it is a copy of a module that is freely available on cnx.org and that it
was made and published without my prior knowledge.
Aliation : I am a professor of Computer Information Technology at Austin Community College
in Austin, TX.
-end-

25 http://scratch.mit.edu/projects/dbal/154452
26 http://scratch.mit.edu/projects/dbal/154457
27 http://scratch.mit.edu/projects/dbal/155966
28 http://scratch.mit.edu/projects/dbal/155971
29 http://scratch.mit.edu/projects/dbal/156614
30 http://scratch.mit.edu/projects/dbal/156618

http://cnx.org/content/m46239/1.1/