- The Turtle Center
- Properties of …
- Animals, Birds, Fish and Other Pictures
- Controls (Click on This!)
- Who’s Got the Remote?
- Computing with Numbers
- Computing with Words and Lists
- Operations (Your OUTPUT matters too!)
- Variables (MAKE some THING)
- Dots: A THING, I See!
- Logo Programming
The Turtle Center
The Turtle Center is a dialog box that lets you change some of the turtle characteristics. You can click on the Turtle Center button in the Tool bar or select Turtle Center from the Preferences menu. This Turtle Center is a quick way to change items for all active turtles. If you remove the check mark in Tell all active turtles, then the changes you make will affect just the first turtle in the WHO list (usually turtle 0, but turtle names could change that).
To display the Turtle Center for a specific turtle, put the mouse pointer over a turtle and right click (on a PC) or ctrl-click (on a Mac). The changes you make will affect only the specific turtle. However, all active turtles are affected if you check the Tell all active turtles box.
Did you notice the Run when clicked property? Type
FD 100 RT 90 into
the text box and then click OK. When you click on the turtle in the
Graphics window, these commands are run as if they were typed in the
Listener - all active turtles will respond. You can use
ASK if necessary.
Now make sure the Extended Property Lists option is checked. It’s in the Operation dialog under the Preferences menu.
Properties of …
To display the Properties window of
something, put the mouse pointer over it and right click (on a PC) or
Ctrl-click (on a Mac). You can also type EDP
and give it the name of that something or, in the case of a turtle, you
can use the turtle’s number. EDP stands for
Many things in Terrapin Logo have their own property list - turtles, windows, and things we haven’t seen yet. A property list is a special kind of list containing property pairs; a property pair is a property name and a property value that is associated with that property name. That’s a rather long-winded definition, but it’s important.
Pay close attention to the RUN and RUN2 properties. You can put commands in one or the other, but not both. A single mouse click will run the
commands; it takes a double-click to run the
RUN2 commands. In either
case, the commands are run as if you typed them in the Listener
If the Extended Property List option is not on, then only the most common properties are shown, much like the Turtle Center.
Property List Commands
There are many Logo commands that indirectly affect many of the properties of objects. However, some properties can only be modified with either the property list editors or the property list commands. The property editors are convenient while you’re exploring but, in a procedure, you may have to use the property list commands.
Get a property value
GPROP is an operation that reports (or
outputs) a property value. It needs two inputs - the name of the object
and the property name whose value you want. For example,
“PENWIDTH. If you use a property name that is not in the property
list, GPROP outputs the empty list (a
pair of brackets with nothing between them, ).
Put a property pair
PPROP is a
command that either adds a new property pair or modifies an existing
property value. It needs three inputs - the name of the object, the
property name and the value you want to assign. For example,
Put many property pairs
PPROPS is really a shortcut form of
typing a lot of PPROP commands. It needs
two inputs - the name of the object and a list of property pairs. For
PPROPS 0 [PLANET EARTH RUN [FD 100 RT 90]] is the same as the
PPROP 0 “PLANET “EARTH and
PPROP 0 “RUN [FD 100 RT 90].
Now make sure the ”Extended Property Lists” option is NOT checked. It will make changes quick and convenient while playing with the bitmaps.
Animals, Birds, Fish and Other Pictures
Finally! We’re ready to explore and play
around with some very colorful objects called bitmaps. Bitmaps are a lot
like turtles except they don’t have a pen and they are multicolored.
Terrapin Logo includes many different bitmaps and you can add more of
Open the Toolbox and then select the Sea Creatures panel and drag a whale out to the Graphics window. Right click (on a PC) or ctrl-click (on a Mac) anywhere on the whale to bring up the property dialog. Set the heading, set the velocity, type in the command
PLAY “SPLASH in the Run box, make the whale bigger or smaller with the
Scale slider and click OK. Watch the whale move and then click on it to
hear a splash! Drag out some friends and make an aquarium.
Try running the
SAIL procedure from earlier and then change
it into a whale watch. Use the Vehicles panel and make a car race. Try
PLAY “CARMOTOR and
Controls (Click on This!)
The Toolbox Controls panel has a variety of controls that make your
programs easier for others to use. You have probably seen all of these
controls somewhere before, either in Logo or in other applications that
you run on your computer. They are standard visual programming tools for
developing a Graphical User Interface (GUI). Now, you can put them in
your own Logo programs!
All of the controls can be placed in the Graphics window by dragging them with the mouse. Each control is given a name, like
BUTTON.1 for the first button and
the second button. You can change the name in the properties dialog or
with the PPROP command. You can also
create controls with the DECLARE and
NEW commands. To move a control, hold down
the Shift key while dragging it to a new location. Controls can be given
commands just like bitmaps - using ASK or
TELL. To get rid of a control, type
ERASE and give it the name of the control.
When you type CLEARSCREEN to clear
the screen, all of the controls are erased.
There are eight different controls. The Editbox, Listbox, and Popup listbox are used to get text input; the Checkbox and Radiobutton are used to indicate a choice (like true/false or yes/no); the Textbox is for displaying text; the Scrollbar (or slider) is for getting a number that is always in a certain range; the Button is for starting some action.
Who’s Got the Remote?
This sample project is a “remote control” for moving the turtle around,
drawing lines, and cleaning up the screen. Sometimes, the best way to
learn about new things is to try them out. You can read more in
First, drag five buttons onto the Graphics window and arrange them in a column with a little space between them. Don’t spend a lot of time trying to get them perfect from side to side - let Logo do that! Type
ASK EVERY “BUTTON
[SETX 250]. Now drag out a scrollbar, a static text box and another
button. Your “remote” should look like the illustration here, except for
the labels. The label of a control is the
TEXT property. Use the
property editor to display the properties of each control and change the
label to match the example. Adjust the
POSITION property to line up
the other controls. The first number is the X-coordinate (left-to-right
position) and the second number is the Y-coordinate (up-and-down
position). Change the name of the scrollbar to
ZOOM; it’s more
When you click on a control, it runs the commands in the
RUN property as if you
had typed them in the Listener. Here are all the command
[RT 45] [BK 50] [FD 50] [LT 45] [HOME CLEAN] [SETVELOCITY 0 PPROP "ZOOM "VALUE 0] [SETVELOCITY GPROP "ZOOM "VALUE]
Put the commands in the proper control. The square brackets are already there for you. (The static text box doesn’t need a command list.)
Computing with Numbers
Logo works with numbers in many ways, from simple values to advanced mathematical calculations. Don’t worry, we’ll keep it simple here, but if you want to learn more about logarithms or trigonometry, check out the online Help files to see what else Logo can do.
Have you noticed that every instruction you want Logo to run always
starts out with the command which is followed by its inputs? You can do
arithmetic that way in Logo - type
+ 2 8 in the Listener and Logo will
display the result of 10 - but that’s not how people like to do
arithmetic. So Logo has bent its own rules and made the arithmetic
operators work in a special way called infix (meaning the operator goes
in between the inputs the way people like to see them). Type
2 + 8 in
the Listener and Logo will display the same result as before. Logo uses
the symbols + and - for doing addition and subtraction just like people
do. However, multiplication is done with the * symbol and division is
done with the / symbol. For example, you could move the turtle forward
30 steps with any one of these commands
FD 10 + 10 + 10 FD 50 - 20 FD 15 * 2 FD 90 / 3
You don’t need the space between the symbol and the numbers to do
calculations, but it’s easier to read. However, to make a negative
number, you must not have a space after the - symbol. Try
Computing with Words and Lists
Words and lists are two of the fundamental data types in Logo. We’ve
used words for names of colors (
“ORANGE), objects (
“SAILBOAT), and even as a simple message (
“HELLO). We’ve used a
list of commands for REPEAT, a list of
numbers for SETPC, and a list of property
pairs for PPROPS where the list
contained another list as an element. A list which contains other lists
as elements is called a compound list but just think of it as a list.
A list of words is a sentence – not just for you, but for Logo as well. A sentence is still a list but it can not have another list as an element – just words. If you don’t like computing with numbers (or math) you may find that exploring with words and lists is just the thing for you – areas like poetry, silly sentences, foreign language translation, and linguistics are some examples.
Words and lists are everywhere in Logo. There are many commands and operations that work with both, depending on the input you give. Here are examples of some of the most common operations. Fortunately, with many Logo instructions, you can tell what they’re for just by their name. Check out the Help files for more information. Try using your own name.
|Examples with words||Examples with lists|
MEMBER? “P “COMPUTER
BUTMEMBER “P “COMPUTER
WORD “COM “PUTER
|FIRST [TERRAPIN LOGO]
LAST [TERRAPIN LOGO]
BF [TERRAPIN LOGO]
BL [TERRAPIN LOGO]
MEMBER? “LOGO [TERRAPIN LOGO]
BM “LOGO [TERRAPIN LOGO]
EMPTY? [TERRAPIN LOGO]
LIST “TERRAPIN “LOGO
Result: [TERRAPIN LOGO]
LIST? [TERRAPIN LOGO]
Operations (Your OUTPUT matters too!)
An operation is a command that outputs a value that can be used as input
to another command. Operations are also called reporters because they
report (or output) a value. The procedures we’ve written so far do their
job and then just stop - we didn’t need an output from them. Wouldn’t it
be silly if
SQUARE output the message “I’m done now” every time it
drew a square? You can ignore unwanted outputs by using the IGNORE
command; it takes any input and throws it away. To make your own
operation, use the OUTPUT command in your
procedure. It takes one input - the value you want reported (or output).
When the OUTPUT command is run, your
procedure stops and the value of the input to
OUTPUT is output for input to something else.
So, make sure your procedure has done all its work before the
OUTPUT command is run. Ever heard “garbage
in, garbage out?” Don’t do that.
There is not a built-in operation called
SECOND but we can make one.
SECOND will report the second element of a word or a list in the same
way that FIRST reports the first element. Define
SECOND and then try
some examples using words and some using lists.
TO SECOND :INPUT OUTPUT FIRST BUTFIRST :INPUT END
How about making
THIRD your second operation since
SECOND was your
first? You could use your first operation inside your second because the
third element is the
SECOND of a
BUTFIRST! 4ths anyone? I’ll take the
Big decisions are made with one little word - IF. So far, our procedures have just run commands in the order in which we wrote them. It’s like we were saying “Do what I say!” to our procedure and it did it, no questions asked. Programs that make decisions have a sense of intelligence about them - they seem to be smart enough to do the right thing at the right time for the right reason (usually!). It’s like the program is saying “I can make my own decisions!” One way that decisions are made in Logo is with the IF instruction which is usually put on a line by itself. A simple form of IF is: IF predicate THEN instruction
A predicate is an expression that evaluates to either the word
FALSE. The instruction after
THEN is only run when the
predicate evaluates to
TRUE. It should not be a surprise that most of
the predicates in Logo have a question mark at the end of their name
since a question can determine if something is
of the most commonly used comparison operators are another exception to
the “command first” rule and allow you to put them in between the two
inputs you want compared. For example, the equal sign ( = ) compares two
inputs and reports
TRUE if they are equal and
FALSE if they are not
equal. Both of these examples do the same thing.
IF :SIZE = 10 THEN STOP IF = :SIZE 10 THEN STOP
Most people like the first example better - another infix choice.
With one small decision (and a minor calculation), a simple procedure
can become a masterpiece of design. Without that little decision, things
can get out of control and cause an ‘infinite loop’ - a technical term
for a program that will not stop on its own. Of course, sometimes the
infinite loop is actually a plan, usually for a demonstration of some
kind. Look back at
SHIFT.EYES and you’ll see that the last line causes
SHIFT.EYES to run again. Each time
SHIFT.EYES runs, it runs itself
again and again and again and again … you get the idea.
A procedure that runs itself is said to be recursive - the running of the procedure recurs (or repeats) over and over again. Isn’t this just an infinite loop? It could be, but we are going to control it. How? First, we will have a formal input that we can modify each time the procedure runs itself - something must change each time. And, we must define a way for stopping the procedure from running itself - a condition must be met. All of this may sound really complicated (and it is) but with an example procedure, most of it will be clear as … glass.
Here is a simple procedure that draws a line of length
SIZE and then
turns right 90 degrees.
TO LINE :SIZE FD :SIZE RT 90 END
It’s not very impressive, but suppose we change it so that after a line
is drawn of length
SIZE, it runs
LINE again but with a slightly
LINE and run it. Yes, it is an infinite loop,
but this is just a demo. Press the Stop button to stop it.
TO LINE :SIZE FD :SIZE RT 90 LINE :SIZE + 5 END
So, now we have a formal input and we modify it each time but, we still
need a way to stop
LINE from running itself. Since
SIZE is growing
bigger and bigger, how about checking it each time and then, when it
gets greater than 100, we just stop?
What we need is an IF instruction. If
greater than 100 then stop. An instruction that makes the decision to
stop a recursive procedure is called a stop rule. Where does it go?
Certainly, it has to be before
LINE is run again, but should it be
before a line is even drawn by FORWARD?
You can try it both ways and see what the difference is. Try different
TO LINE :SIZE FD :SIZE RT 90 IF :SIZE > 100 THEN STOP LINE :SIZE + 5 END
Add a second input called
ANGLE so that you can make the turn anything
Add a third input called
INCREMENT and use it to change
There is a lot more to learn about recursion to fully understand it. This is just the beginning. Imagine!
Variables (MAKE some THING)
The only variables we used so far were the formal inputs to procedures. You can create your own variables in the Logo workspace. To see them, type PONS (short for PRINTOUT NAMES). The workspace is also referred to as the “global environment” because variables created there are accessible by procedures as well as you. The formal inputs to procedures only exist while the procedure is running. These variables are created in the “local environment” of the procedure. You can’t get at them while the procedure is running and they go away when the procedure ends. When writing programs, it’s important to know where variables are created.
Every variable has a name. A name is a word. To use a word as itself,
put a double quotation mark in front of it so that Logo won’t think it’s
a command and try to run it. Every variable has a value associated with
it, even if it’s the empty word or the empty list which look like
nothing. To create a variable in the workspace, give
MAKE the name of the variable and the
value you want to assign to it. To use the value of a variable, give the
name of the variable to THING. The
following examples create one variable named
STEPS with a value of 20
and another variable named
INCREMENT with a value of 10.
MAKE "STEPS 20 MAKE "INCREMENT 10
THING is an operation that reports (or outputs) the value associated with the variable whose name you give it as input.
THING can be used wherever you need a value.
FD THING "STEPS
would move the turtle 20 turtle steps. The output of
THING is 20 which is used as the input to
FORWARD. You can change the value of a
variable by using another MAKE command
with a new value. The value can be just a number, a calculation, the
output of an operation, or any Logo data value. It’s usually a good idea
to assign the same type of data to the same variable. For example, since
STEPS for numbers, I shouldn’t put
“LIVELY in it later on.
That just invites trouble and could be very frustrating. Most other
programming languages force you to use the same type of data again but
it’s not a restriction in Logo. Restriction or not - it’s a good idea.
In the following example, you can see that the use of THING can get pretty messy and awkward. Just imagine trying to add four or five values together!
MAKE "STEPS THING "STEPS + THING "INCREMENT
Don’t worry. Help is on the way! Are you familiar with emoticons
(emotion icons) - things like :) for happy and :( for sad? If you treat
this page like a turtle and ‘run’ a
RIGHT 90, you’ll see a smile and a
frown. The colon character looks like a pair of eyes. That’s exactly
what the Logo shortcut is - a colon in front of a variable name acts
like a pair of eyes that lets you ‘see’ what the value of the variable
is. Of course, by ‘see’ I mean it outputs the value.
Dots: A THING, I See!
The colon is called ‘dots’ in Logo. Dots takes the place of both THING and the double quotation mark in front of the variable name. It saves a ton of typing! The example from above can be written much more simply now.
MAKE "STEPS :STEPS + :INCREMENT
When you read instruction lines or say them out loud, it’s a good idea to say the word ‘dots’ for the colon and ‘quote’ for the double quotation mark. So, this line would be said as “Make quote-STEPS dots-STEPS plus dots-INCREMENT.” Without even seeing the line, another Logo person would know that quote-STEPS meant the variable name and that dots-STEPS and dots-INCREMENT meant the values. You’ll find this to be a big help while learning and a good habit to stick with.
Terrapin Logo lets you get away with not using the dots by setting the
“Relaxed syntax” option in the Operation dialog of the Preferences
menu. It’s been handy, hasn’t it? But suppose you wanted to create a
procedure to draw rectangles that uses inputs called
WIDTH. Since WIDTH is a built-in Logo
procedure, your rectangles will not work. Take off the “Relaxed syntax”
option and try it. You could fix it with
FD THING “WIDTH but “dots” is
Note how Logo changes the color of the word
WIDTH. In the left panel,
WIDTH is blue. If the word is a
Logo procedure, its color is blue. In the right panel,
:WIDTH changed to green,
indicating that Logo thinks the word is a name rather than a procedure.
All of the exploring and playing around we’ve done is a part of learning to write programs in Logo. After all, to do any job well, you have to learn what tools are available and how to use them. Logo is much more than turtle graphics, pictures and sounds. It’s a powerful language for problem solving, calculating with numbers, manipulating words and lists, and learning concepts of computer science and programming.
A program can be as simple as one procedure like
MY.GRID. It has a
definite purpose or goal - in this case, to make a small graph for
designing turtle shapes. It uses the tools of the language and puts them
together in a sequence of instructions to get the job done. A person
MY.GRID doesn’t need to know how a graph is made, only
MY.GRID will make a graph every time it’s run. But you, as the
programmer, need to know all the gritty details that make it work
correctly. It’s a challenge at times, but also interesting, intriguing,
fascinating and sometimes frustrating, but always rewarding when your
program works properly.
A big program shouldn’t be just one huge procedure trying to do it all. You may need a lot of little procedures to do a big project, with each procedure doing just a little bit of a big job. You’ll find that many of your small procedures will be useful in other projects. Save them in their own file so you can include them in other projects without defining them again. You can build your own library of special procedures, use them when you need them, and share them with other Logo programmers. There is so much more to Logo programming - I hope you explore!