Part Four

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 edit properties.

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 RUN 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 window.

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, GPROP 0 “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, PPROP 0 “PLANET “EARTH.

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 example, PPROPS 0 [PLANET EARTH RUN [FD 100 RT 90]] is the same as the two commands 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 your own.

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 PLAY “CARHORN.

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 BUTTON.2 for 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 Help.

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 descriptive.

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 lists:

[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 FD -30.

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 (“TURTLE), files (“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
FIRST “COMPUTER
Result: C
LAST “COMPUTER
Result: R
BUTFIRST “COMPUTER
Result: OMPUTER
BUTLAST “COMPUTER
Result: COMPUTE
MEMBER? “P “COMPUTER
Result: TRUE
BUTMEMBER “P “COMPUTER
Result: COMUTER
EMPTY? “COMPUTER
Result: FALSE
WORD “COM “PUTER
Result: COMPUTER
WORD? “COMPUTER
Result: TRUE
FIRST [TERRAPIN LOGO]
Result: TERRAPIN
LAST [TERRAPIN LOGO]
Result: LOGO
BF [TERRAPIN LOGO]
Result: [LOGO]
BL [TERRAPIN LOGO]
Result: [TERRAPIN]
MEMBER? “LOGO [TERRAPIN LOGO]
Result: TRUE
BM “LOGO [TERRAPIN LOGO]
Result: [TERRAPIN]
EMPTY? [TERRAPIN LOGO]
Result: FALSE
LIST “TERRAPIN “LOGO
Result: [TERRAPIN LOGO]
LIST? [TERRAPIN LOGO]
Result: TRUE

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.

SECOND.lgo
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 fifth.

Decisions

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 TRUE or 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 TRUE or FALSE. Some 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.

Recursion

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 bigger SIZE? Define 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 SIZE is 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 inputs.

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 you want.

Add a third input called INCREMENT and use it to change SIZE instead of 5.

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 I used 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 HEIGHT and 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 simpler.

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.

Logo Programming

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 running MY.GRID doesn't need to know how a graph is made, only that 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!