Learn to Program using Alice

Data Types and Variables

This lesson will teach you about data types and variables. In addition,
the lesson presents and explains two Alice programs. The first program
illustrates the use of local variables for storing data that is completely internal to a
function. The second program illustrates the use of variables for saving input
data provided by the user for later use by the program.

Preface

This tutorial lesson is part of a series designed to
teach you how to program using the Alice programming environment under the
assumption that you have no prior programming knowledge or experience.

Have some fun

Because Alice is an interactive graphic 3D programming environment, it is not
only useful for learning how to program, Alice makes learning to program fun.
Therefore, you should be sure to explore the many possibilities for being
creative provided by Alice while you are learning to program using these
tutorials. And above all, have fun in the process of learning.

In the previous lesson titled "Functions that Return Values" I taught you
about functions that return values in Alice. I taught you how to use existing
functions. I also taught you how to write your own new functions.

In this lesson, I will teach you about data types and variables, and will
illustrate those concepts with a pair of working programs.

If you were the manager of the city animal shelter, you probably wouldn't put
dogs and cats into the same pens. Dogs and cats are not only different
types of animals, they also happen to be different types that don't co-exist
very well in the same confined quarters.

Think of data as dogs, cats, bears, etc.

The same concepts apply to data in a computer program. Data comes in a
variety of different types that don't co-exist well in the same space. For example, Java recognizes eight different primitive
data types as well as numerous abstract types. While Alice doesn't
categorize data into that many different types, it does categorize data into the
following types:

Number

Boolean

Object

Other

String

Color

TextureMap

Sound

Pose

Position

Orientation

PointOfView

ReferenceFrame

Transformable

Light

Direction

Four types are somewhat general purpose

Of the fifteen types listed above, the following four types are somewhat general
purpose types and the remainder are more specialized types.

Number

Boolean

Object

String

The Transformable typeWhen I inquired about this type I was told:

"Transformable
is an internal data type that is not intended to be
directly manipulated by end users. If you have managed to see
the word
'transformable,' that probably indicates that you've gotten the
system to cough up some internal information."

Bottom line, just ignore the Transformable data type.
Apparently you can't use it.

I will explain these four types in some detail in this lesson. You will
learn about the specialized types on an as-needed basis during the remaining
tutorial lessons in this series.

Type Number

Probably the most significant distinguishing characteristic of data of the type
Number is that you can perform arithmetic using that data. Several
examples of data of the type Number follow:

The width of a Coach object.

The distance that an object moves.

The number of revolution that an object rotates.

The price of a loaf of bread.

Java subdivides the general numeric type into six different types,
some of which are whole (integer) values, and some of which are allowed
to have fractional parts. The main differences among these different
numeric types have to do with the accuracy of arithmetic that can be performed
using the different numeric types. However, to make life easier for you,
Alice treats all numeric types as the single
type Number.

Type Boolean

This is probably the simplest of all types in that data of this type can only have
one of two different values: true or false.

Data of the Boolean type originates primarily as a result of tests that
compare one thing with another such as:

True or false, a penguin is taller than an ice skater?

True or false, the hole in the ice is large enough for the penguin to dive through?

True or false, this particular task has been performed the specified number of times?

You will learn a great deal more about data of type Boolean in future lessons
that address selection and loop structures along with relational operators.

Type Object

Data of type Object contains references to objects on which you call methods
and functions, such as:

Telling a Penguin object to move RIGHT by 3 meters.

Telling the Camera object to turn FORWARD by 0.65 revolutions.

Telling a ToyPlane object to roll LEFT by one-half revolution.

You can create variables of the Object type and save references to such
objects in those variables.

Creating a new type
If you right-click on an object in the object tree, you will see an item
labeled save object... in the popup menu. In effect, this makes
it possible for you to create a new class that extends the class from which
the original object was created. Creating a new class also results in
the creation of a new type. However, this is a rather complex topic,
which will be deferred until a future lesson that deals with saving
and importing
objects.

Type String

Along with type Number, this is probably the most commonly used type of all.
Typically, data of type String contains what might be thought of as a label in
the non-technical world. For example, you could use a variable of type
String to store your name or your telephone number.

I mention your telephone number for a very special reason.
If you store
a telephone number as type String, you cannot perform arithmetic using that data
even if it consists solely of the digits from 0 through 9 inclusive. You
can only perform arithmetic using data of type Number.

Can only store data in compatible types

Every local variable is identified as belonging to a specific type.
This means that the memory that has been set aside to be used as a variable can
only be used to store a specific type of data.

That sums it up

That pretty well sums up the topic of data types. Not all programming
languages require data to be categorized into different types, but Alice is one
of the programming languages that does have that requirement. However,
particularly with respect to the Number type, Alice is somewhat less demanding than other
languages such as Java, C++, and C#.

Some people throw all of their clothes in a big pile on a shelf in their
closet. That is analogous to programming languages that don't deal with
data types. Hopefully the meaning of this sentence will become clear as
you read the following paragraphs.

Other people are careful to hang each item of clothing on its own hanger.
If you are one of those people and you are really fastidious, you will have
different types of hangers for the different items of
clothing.

A special type of hanger for trousers

For example, trousers will probably be hung on hangers of a type
that prevents horizontal creases from forming at about the knee-level on the
trouser legs. (The cheap version of this type of hanger is an ordinary
wire hanger with a cardboard roll on it.)

Special hangers for suit coats and shirts

The hangers for suit coats may be made of material that is thicker than an
ordinary wire hanger and slightly
curved forward under the shoulder pads of the suit coat. This will prevent
damage to the shoulder pads.

Shirts may be
hung on simple wire hangers such as those that seem to originate at the
commercial laundry, or they may be hung on more decorative plastic hangers.

Variables are similar to hangers

Variables in Alice are similar to hangers in a closet. A variable is a
place in memory where data of a specific type can be stored for later retrieval
and use. The hangers in a closet provide a place where clothing items of
different types can be stored for later retrieval. However, unlike the hangers in a closet,
each variable is given a
unique name to make it easy to find in order to store and retrieve data into it.
(The hangers in my closet don't have unique names.)

Local variables, instance variables, and propertiesVariables that exist inside methods or functions are often
called local variables in other programming environments.

Variables
that exist inside an object but outside of a method or function are often
called instance variables in other programming environments.
However, they are called properties in Alice.

The locations of variables

In Alice, variables can exist in at least two different locations in a program:

Inside a method or function. (local variable)

Inside an object but outside of a method or function. (instance
variable or property)

One of the primary differences between the two different locations has to do with the lifetime of
the variable.

The lifetime of local variables

When
a method or function is called, control passes to that method or function.
The local variables belonging to that method or function come into existence at
that point. They can be used while control remains in the method or
function. However, they cease to exist and become unavailable for use when control returns from the method or
function to the method or function that performed the call. Therefore,
local variables can't be used to carry data forward from one method call to the
next call to the same method.

The lifetime of object variables (properties)

In Alice, variables that belong to objects are called properties.
They come into existence when the object is created, and they cease to exist
when the object ceases to exist. As a practical matter, objects cannot be
created or destroyed in Alice while a program is running, so properties
belonging to an object exist during the entire running time of the program.

Just like local variables, every property is identified as belonging to a
specific type.

In this lesson, I have begun by teaching you about data types and variables.
Next, I will present and explain two Alice programs. The
first program will illustrate the use of local variables for storing data that
is completely internal to a function. The second program will illustrate the
use of variables for saving input data provided by the user for later use by the
program (data obtained from an external source).

I will not illustrate property variables in this lesson, but I will explain
how to declare and initialize them. Once they have been declared, except
for the fact that they have a much longer lifetime, the procedures for using
property variables is pretty much the same as the procedures for using local
variables.

Discussion
and sample code

This program is an upgraded version of the program named Alice0135a
that I developed and explained in the earlier lesson titled "Learn to Program
using Alice, Functions that return values" (see
Resources).

Coach displayed width in a comic-strip bubble

As you may recall, that program constructed and executed a call to the say
method to cause a coach object to display his width in a comic-strip bubble
above his head. Both the construction of the statement and the
explanation of that construction were very complicated. At that time, I
told you that the code in that program could be simplified (made less
cryptic) through the use of
local variables. However, since we hadn't studied local variables at that
point, I was unable to use them.

The time has come to simplify that code using variables

Well, now we have studied, or at least are currently studying local
variables, so it is time to show you how to use local variables to simplify the
code in that earlier program.

Procedure for writing the program

The easiest way to write the program named Alice0140a is to load the
earlier
program named Alice0135a into your Alice development environment, save it
as Alice0140a, and then edit the code to produce the desired behavior for
the upgraded version.

Screen shots from the program

Four screen shots from the upgraded version of the program are shown in Figures 1 through 4.
Figure 1 shows the screen output from the early part of the program that uses
the code from the earlier version of the program to get and to display the
coach's width. This code doesn't use variables, and is presented simply to
serve as a baseline against which to compare the upgraded code.

Figure 1. Coach reporting width without variables in
program Alice0140a.

Do a little dance

Figure 2 shows the coach doing a little dance (he turns one revolution) to signal the transition of the
program from the old code that doesn't use variables to the upgraded code that
does use variables.

Figure 3 shows the screen output for the upgraded code that uses variables to
get and display the coach's width. Let me emphasize at this point that the
results are the same. Neither approach is either right or wrong as
compared to the other approach. However, the code that uses variables is
considerably less cryptic and should be easier to understand than the code that
doesn't use variables.

Figure 3. Coach reporting width using variables in
program Alice0140a.

More output from code that uses variables

Figure 4 shows the screen output for the upgraded code that uses variables to
get and display the coach's width after he raises his arms, thereby making his
bounding box narrower.

Figure 4. Coach reporting width using variables in
program Alice0140a.

Source code for the program named Alice0140a

The source code for this program is presented in Listing 1 near the end of
the lesson. An executable version of the program is also available for
downloading (see Resources).

The first call to the say method on the coach object shown in Listing
1 was copied from
the earlier version of the program named Alice0135a. I explained
the construction of this statement in the earlier lesson titled "Learn to
Program using Alice, Functions that return values" (see
Resources) so I won't repeat that explanation in this lesson. I
included that statement in this program simply for comparison with the new
version of the code.

Interesting new code

The interesting new code occurs at the very beginning of the main
method (variable declarations) and further down beginning at the comment
that reads "Coach reports his current width using variables."

Declaring and initializing variables

Figure 5 shows a partial screen shot of the edit pane during the development of the
program named Alice0140a.

Creating a new property variable
Use the same procedure for creating a new property variable, except click the
button with the same label on the properties tab below the object tree after
selecting an object in the object tree.

Procedure for creating a new local variable

The procedure for creating (more properly called declaring) and
initializing a new local variable is to click the button labeled create new
variable shown in the upper-right corner of Figure 5. This causes the dialog
shown in Figure 6 to appear on the screen.

Enter the name of the new variable in the text field. Good
programming practice says to begin the name with a lower case character, use
camel-case format (see the variable names in Figure 5), and make the
variable name meaningful.

Specify the type of the new variable by clicking the appropriate radio
button, and possibly selecting a type from the pull-down list (in case
you click the radio button labeled other).

Enter the initial value in the field showing <None> in Figure 6.
(You can optionally skip this step and accept the default initial value.)

Click the OK button.

Variables used in this program

Once you complete those four steps, the type, the name, and the specified
initial value of the new variable will appear at the top of the program code as
shown in Figure 5, which shows four variables having the following names:

coachesWords - Used to store the data to produce the words to the
left of the numeric values in Figures 1, 2, and 4.

coachesWidth - Used to store the numeric width of the coach
object.

widthAsString - Used to store the width value after it has been
converted from type Number to type String.

extendedString - Used to store the string that results from
concatenating the contents of coachesWords and widthAsString.
This is the string value that is displayed on the screen as shown in Figures
1, 3, and 4.

The purpose of each of the four variables is also briefly described in the
above list.

Procedure for using local variables in program code

Whenever you need to use a local variable in your program code, you drag it down
and drop it at the appropriate location in the program code.

If you drop the variable on a new line all by itself, the skeleton of a new
statement such as the statement that begins with "coachesWords.set..." in
Listing 1 will be created automatically. You then use the normal Alice
drag and drop paradigm to complete the statement.

If you need to insert the variable in an existing skeleton of a statement,
you use the normal Alice drag and drop paradigm to drag the variable and drop it on top of a
placeholder that already exists in that skeleton statement. (See the
statement in Listing 1 that contains "coachesWidth.toString()" for example.)

Description of the program code

The doInOrder block of code following the comment that reads "Coach
reports his current width using variables" in Listing 1 contains four statements
that set the values of the four variables. These relatively simple
statements were constructed using the normal Alice drag and drop
paradigm. The last such statement, when executed, results in the variable named
extendedString containing a string that is the concatenation of the contents
of the variable named coachesWords and the string that results from:

Getting the width of the coach object.

Converting the numeric width value from type Number to type
String.

The contents of the variable named extendedString are then passed to
the method named say, which is called on the coach object to produce the
screen output shown in Figure 3.

Behavior of the remainder of the program

The remaining code in the program does essentially the same thing again after
causing the coach object to lift both arms skyward, thereby causing the bounding
box containing the coach object to become narrower. This produces the
screen output shown in Figure 4.

If you examine Listing 1 carefully, you will find a statement that instructs
the coach object to turn RIGHT by 1 revolution in the default duration
time of one second. The program named Alice0140b upgrades this
program to allow the user to specify the number of revolutions that the coach
object should turn at that point in the program. As such, the changes that
were required to the program named Alice0140a to produce the program
named Alice0140b were very modest.

Source code for the program named Alice0140b

The source code for this program is presented in Listing 2. You can
also download an executable version of this program (see
Resources). The first
thing to notice in Listing 2 is the addition of a new variable of type Number
named numberRevs with an initial value of 5. (In this program,
the initial value is of no consequence and might just as well have been left at
the default value of zero.)

Get the number of revolutions from the user

The second thing to notice in Listing 2 is the call to the world's function named
NumberDialog very near the beginning of the program. This results in
the dialog shown in Figure 7 being displayed on the screen for the purpose of
soliciting numeric input from the user. (The world object also provides
similar functions for soliciting Boolean and String input from the user.)

This is a so-called modal dialog, meaning that it won't go away and
the program won't continue running until the user clicks the OK button.
Some programming languages provide non-modal dialogs that can remain on
the screen while the program continues to run, but I don't believe that
non-modal dialogs are provided by Alice.

If the user enters a non-numeric value in the text field in Figure 7 and
clicks the OK button, the program will fail with a runtime error. When the
user enters a numeric value in the text field and clicks the OK button, the
value entered by the user is returned by the function named NumberDialog
in Listing 2, and the returned value is stored in the variable named
numberRevs.

Using the user-input value

The third thing that to notice about the code in Listing 2 is the modification
of the call to the turn method so as to use the value stored in the
variable named numberRevs to specify how many revolutions the coach
object is to turn when he does his little dance. Thus, user input data is
used to control this aspect of the behavior of the program.

Otherwise no different

Beyond that, there are no differences between the program named Alice0140b
and the earlier program named Alice0140a. Except for the number of
revolutions turned by the coach, the screen output for the two programs is the
same. Since I am unable to capture that difference in a screen shot, I
didn't provide any screen shots for this program.

Run the programs

Executable versions of the programs that I explained in this lesson are available for downloading
(see Resources). I encourage you to either
download those programs, or copy the code from Listings 1 and 2 into your Alice development
environment and play the world. Experiment with the code, making
changes, and observing the results of your changes.

In this lesson, I provided an explanation of data types and variables.
Then I presented and explained two Alice programs. The first program
illustrates the use of local variables for storing data that is strictly
internal to a function. The second program illustrates the use of variables for
saving input data provided by the user for later use by the program.

I did not illustrate property variables in this lesson, but I did explain how
to declare and initialize them. Once they have been declared, except for
the fact that they have a much longer lifetime, the procedures for using
property variables is pretty much the same as the procedures for using local
variables.

Save your world in a file named Alice140LabProjA.a2w and be prepared
to deliver it to your instructor in whatever manner the instructor specifies.

Make certain that your preferences are set to Java Style in Color.

Select Export Code For Printing... on the File menu and save
your source code in a file named Alice140LabProjA.html. Also be prepared
to deliver this file to your instructor in whatever manner the instructor
specifies.

View a movie of the lab project

You can download and play a small, low-quality movie of my
version of the lab project as it being executed from the Resume button
(see Resources). This movie was designed to give
you a rough idea of how your program should behave. The movie was purposely
recorded in low-quality wmv format in a small window in order to reduce the file
size and hence reduce the download time.

Because of the low quality of the movie, the execution of your
program should provide much smoother animation than the movie, and should be
much less grainy than the movie. Also, because of the low quality of the movie,
the timing in the movie doesn't necessarily match the duration times specified
for the lab project.

I attempted to synchronize the beginning of the recording with
the beginning of the program execution by starting, then quickly pausing, and
then resuming the execution. If you watch closely, when the movie starts
running, you will see the mouse pointer click the Resume button, and the
movie will show one complete pass through the program.

You should view this movie in its original size. If you allow
the media player to enlarge it, the quality will be poor.

Copyright 2007, Richard G. Baldwin. Faculty and staff of public and private
non-profit educational institutions are granted a license to reproduce and to
use this material for purposes consistent with the teaching process. This
license does not extend to commercial ventures. Otherwise, reproduction in
whole or in part in any form or medium without express written permission from
Richard Baldwin is prohibited.

Richard Baldwin is a
college professor (at Austin Community College in Austin, TX) and private
consultant whose primary focus is a combination of Java, C#, and XML. In
addition to the many platform and/or language independent benefits of Java and
C# applications, he believes that a combination of Java, C#, and XML will become
the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects and he
frequently provides onsite training at the high-tech companies located in and
around Austin, Texas. He is the author of Baldwin's Programming
Tutorials, which have gained a
worldwide following among experienced and aspiring programmers. He has also
published articles in JavaPro magazine.

In addition to his programming expertise, Richard has many years of
practical experience in Digital Signal Processing (DSP). His first job after he
earned his Bachelor's degree was doing DSP in the Seismic Research Department of
Texas Instruments. (TI is still a world leader in DSP.) In the following
years, he applied his programming and DSP expertise to other interesting areas
including sonar and underwater acoustics.

Richard holds an MSEE degree from Southern Methodist University and has
many years of experience in the application of computer technology to real-world
problems.