PILOT YOUR ATARI

ATARI LOGO LOOKING GOOD

New language joins Turtle tuss

by Ken Harms

With this issue, our department PILOT Your ATARI will alternate with LOGO, both under the surveillance of Contributing Editor Ken Harms. Articles or programs for either of these languages will be considered by Ken, in care of ANTIC.

The buzzword to cope with in the classroom these days is no longer "computer," it's "Logo." If your computer doesn't have Logo you can forget the educational market. Atari has taken heed and marched in with its version of Logo, built into a 16K cartridge, ready for school this year.

Logo is a versatile computer language designed to ease exploration and discovery of computer functions and power. It is easy enough for children to use, yet complex enough to, permit very advanced work by expert programmers. It side7 steps the cumbersome rituals of BASIC - its most serious competitor in the classroom.

Based on LISP, the most powerful of the artificial intelligence languages, Logo has been in development for about ten years, principally by Seymour Papert at MIT, and by Logo Computer Systems, Inc. of Quebec, Canada. The development of Logo is a story we won't go into. Suffice it to say that most of the popular micro computers have a version of Logo, some of them several versions. Atari Logo, from Atari, Inc., is the first for ATARI computers, and though it is a latecomer, it is a good one. It runs on all ATARI computers (even the 400 with 16K RAM) and sells for $99.95.

Atari Logo gives the user extraordinary power to manipulate and create lists of words. A simple yet elegant turtle graphics system allows even novice programmers to create microworlds and explore them. Imagine a BASIC which would allow you to create new commands - Logo does just that!

Why Logo?

So why Logo, anyway? Simply put, Logo is the language of learning. It is designed to be easy to begin. Like PILOT, a few simple graphics commands move a "turtle" around the screen to create beautiful designs; a few text manipulation commands allow construction of sophisticated question-and-answer quizzes or games. In brief, Logo has a low threshold.

But, like the piano which can be played at a simple level, while also serving as the instrument of Liszt, Logo has no ceiling. The individual author creates new commands (called "procedures") and incorporates them in later programs as naturally as a boy puts stones in his pocket. Let's illustrate this latter feature with a simple example. Logo does not include an "absolute" command - one which converts negative numbers to their positive values. If you needed this often, you would teach Logo how "to absolute" as follows:

TO ABSOLUTE :NUMBER
OUTPUT IF :NUMBER <0[ -:NUMBER] [NUMBER]

As defined above the procedure ABSOLUTE will take any number and if that number is less than 0, output the negative of the number (a negative of a negative is a positive, so one gets a positive number). If the number is greater than 0, it outputs the number (which is already positive).

Using our new command is simplicity itself. For instance "PRINT ABSOLUTE -3" prints a "3." Later the command could be used in any new programs just as simply. There is no need to recode the command, change line numbers or use complicated GOTOs or PERFORMS.

Logo is often self-documenting; i.e., it is easy to read compared to BASIC or other less structured languages. In Logo, a problem is automatically written as a series of small procedures which talk to one another in a simple, direct way to produce the overall output.

Yet, unlike PASCAL and the similar "structured" languages, Logo is interactive - you can instruct it to do something and immediately see the results without compiling programs, etc. This makes it easy to write and debug programs.

Logo's design welcomes experimentation. Throughout, the word "error" is not used. For instance, if the command ABSOLUTE had not been defined, and you issued the command ABSOLUTE - 5, Logo would respond with "I don't know how to absolute." Other messages are similarly positive - "You don't say what to do with ... " "PRINT doesn't like XXXX as input" or "file XXXX not found." (Boy, won't you miss the old "ERROR 170"!)

As a friendly language with virtually no prerequisites anyone can do interesting things right away) and no limits (no one gets bored), Logo has found a natural home in schools. It deserves a similar place in home computing. It, and PILOT, are critical tools to teach more than programming - they develop logical thinking.

Atari Logo

Let's turn to Atari's Logo. Programmed permanently into one of those nearly indestructible cartridges, Atari Logo appears much more durable than the disk-based versions for Apple or the Commodore 64. Atari Logo can operate completely effectively with a cassette-based system and as little as 16K of memory (TI Logo needs 48K RAM). As a result, an Atari start-up package is much cheaper than virtually any other Logo system.

As I prepared this article, I poured through material on three versions of Logo for Apple, one for the TRS Color Computer and one for the Texas Instruments TT 99/4A. Without ex ception, the Atari product offers advantages over each of these products.

That's a pretty strong statement, yet I feel it's easily supported. Simply put, Atari Logo benefits from being late on the scene and thus incorporates advanced features. It builds on the superior sound, graphics and keyboard capabilities of the 800/400 systems (compared to alternative machines).

Other Logos

Logo in general offers two outstanding programming features - turtle graphics and list processing. Although graphics are undoubtedly the initial exposure for most people, the language's true power becomes apparent with the extensive set of commands to control lists of words (sentences) in a learning environment. The Color Computer's Logo does not even have list-processing capabilities. It's a bit like a BASIC with numeric computing but no graphics. In the old days (say, 1979), people tolerated that limitation; they doet have to anymore, and neither should today's Logo user. To be fair, the Color Computer's multiple turtles represent an extremely nice implementation of turtle graphics, but it is only half a language, in my opinion.

TI's Logo offers an exclusive feature - "sprites." These 32 objects can be moved around the screen independently of the background or each other. Sprites can be given headings (direction) and also speeds - they move in a straight line until told to change - without slowing down the program. But they cannot draw lines like turtles. TI's Logo makes it easy to redefine character shapes and, to a limited extent, their colors. However, since the TI relies on character graphics rather than memory-mapped graphics, the TI turtle "runs out of ink" rather quickly. As a further limitation , the TI Logo operates only on whole numbers between -32768 and 32767. Although simple beginning programs may not require more, most people will quickly find it a limiting feature. (PILOT is also "integer only," and I find this an inconvenience all the time.) Finally, TI's program editor, sprite and character editors appear to be substantially less convenient to use than those of either the Atari or Apple Logos. I believe that they would be especially frustrating to new users.

Apple II+ users are offered three versions of Logo. Although this isn't the place to analyze these deeply, an overview seems in order. All three, Terrapin Logo, Krell Logo and Apple Logo, are full-scale implementations of the language with competent graphics, list processing and editing facilities. In fact, the three are very similar, as one would expect, since they are produced by companies with similar heritages from MIT and the inventors of the Logo language.

That's the good news about the Apple Logos. The bad news is that Apple hardware and software for any of them will cost you well over $2,000. Each requires an Apple II+ with language card, disks and an RF modulator. That compares to recent prices of less than $300 for an ATARI 400 with cassette, or less than $1,000 for the 800 with a disk drive. A school, for instance, could buy two or three ATARI systems for the price of one Apple, an attractive deal even if the cheaper systems weren't quite as good. Atari's Logo is at least equal to and, for most people, far better than any of the Apple Logos.

Turtles

The most easily recognized advantage will be Atari's four (countem, four) turtles. That compares to Apple's single turtle. But Atari's turtle advantage is far more than numbers. A normal, "boring" turtle can move, draw lines, erase lines, show or hide itself, and set a particular heading. The Apple systems have one normal, boring turtle.

"Dynamic" turtles can do everything boring turtles can do, plus they can change color, change shape, and can be set in motion at a given speed. In essence, they're a cross between sprites (which can't draw or rotate to show headings) and normal boring turtles. And Atari Logo has four dynamic turtles!

The care with which this was implemented is illustrated by the screen representation; the turtle looks like a cute little turtle, not a triangle. Atari's full picture of a turtle not only makes it easier to tell headings but immediately ca ptivates younger programmers with a "real" turtle.

As a result of the Apple's hardware limitations, the Apple Logos do not appear to support sounds in high-level language - an assembly language routine must be written to produce sounds. Atari Logo features full tone quality on two sound channels. The superior tonal quality was obtained by hardware mixing two of the usual voices for each channel. While BASIC programmers may miss the four voices, they'll love the new "duration' feature. When giving Logo the command TOOT and telling it which voice to use and note to play, you also tell it how long to play that note. Your program can then go off and do its thing while the music continues to play. Nice!

Now one might say that the four turtles and sounds are non-essential. Right, but they open an entire galaxy of new microworlds. A four-player joystick-controlled road race game with acceleration, deceleration, turning, different colored cars shaped like cars, and full sound effects can easily to constructed in 50 lines. It's a project well within the capability and interest span of third graders. Even simple turtle-graphics displays can be easily animated.

High Commands

These displays are made easy by some of Atari Logo's exclusive high-level commands. Paddles and joysticks are fully supported, as you'd expect (not so on Apple). An EACH command gives the same instructions to all active turtles and lets them perform the entire set one at a time. For instance, if the instructions draw a box, the first turtle would draw the complete box. Then the second turtle would draw the box, and so on. Essentially, the first turtle completes all instructions before the second turtle does anything.

The ASK command, on the other hand, allows all the turtles to execute the list of instructions simultaneously! Actually, the first turtle does one instruction in the list, then the second turtle does that instruction, etc., until all named turtles have completed the first instruction. Then the first turtle does the second instruction and the process repeats until all turtles have completed the list. The effect is wonderful - up to four figures drawing at the same time.

As you might expect, Atari's 128-color pallet is much better than Apple's seven, but there's even better flexibility. With Atari Logo, each line is drawn with a specified pen. As in the other systems, you can change pens, and thus the colors, of the lines to be drawn. The Atari advantage shows up in the SETPENCOLOR command which allows you to change the colors of lines already drawn. This is a "color register" change so it does the entire screen instantly. The Atari supports three simultaneous pen colors, the Apple five (not including backgrounds).

I found the Atari turtle-shape editor easy to use. It displays a large-scale image of the old shape and uses simple cursor controls to design a new shape. The shapes can be animated or moved at will. They draw lines just like the usual turtle.

Even better, Atari Logo lets you use Atari's "collision registers." This is done by setting up a WHEN demon to watch your screen, continuously looking for an event such as a turtle touching another, a specific joystick movement, or a turtle touching a line. Some 20 different specific conditions can be monitored, with different specific actions taken whenever the event occurs. You set up demons only once. Thereafter, they look for the conditions and execute the instruction list whenever the event occurs.

All in Family

I also compared the power of Atari Logo's list processing features to Apple Logo. Since Atari Logo was developed by Logo Computer Systems, Inc. (LCSI), the same people who wrote Apple Logo, it bears an extremely close resemblance to that product. For my money Atari Logo's "non-graphic" command repertoire is essentially as useful as the Apple systems' yet considerably easier to use.

Krell/Terrapin includes nice error trapping commands (CATCH and THROW) which could be really useful. Also helpful would be the DEFINE command to define new procedures under program control (Atari supplies a procedure to do this). Only Krell/Terrapin allows you to save and recall screen pictures to and from a disk file. These provide a GO command to jump around within a procedure (okay, I'll admit that it's a poor programming technique - which is probably why Atari didn't include it). The TRACE command found on Krell/Terrapin allows you to step through a program one instruction at a time. Finally, Apple Logo provides a PACKAGE command to manipulate groups of procedures and variables simultaneously, and the ability to redefine the primitives themselves.

How important would these be to you? TRACE is very nice, in my opinion. As for the rest, Apple Logo lists them in the "rarely used" section of the reference manual. Almost all of these affect the process of programming, not the product itself. As for the process of programming, my review indicates that Atari's superior keyboard already makes it far easier to use than any of the Apple Logos. That's true despite LCSI's obvious use of Apple-like control keys in some instance.

Without special hardware, the Apple gives only uppercase letters. Atari, of course, gives both. Most educators consider early introduction of both sets of letters educationally advantageous.

Logos are heavy memory users. Atari Logo, however, seems very efficient. Under Logo, your programs use "free workspace memory" which is measured in "nodes" of five bytes. A 48K ATARI system provides at least 26%, and sometimes up to 100%, more free workspace memory than the Apple Logos. Consequently, you can run more complex programs.

Backup

Support for users is often a problem with any computer product. Not so with Atari Logo. First, the package includes an excellent tutorial in the 160-page "Introduction To Programming Through Turtle Graphics." Next, Atari Logo provides an in-depth review of the language in a 210-page "Reference Manual." Both of these have excellent indexes and useful examples. Probably as useful as either is the 16-page "Quick Reference Guide" which not only gives the form of each command but also explains it. A very important Atari exclusive is a live human Logo specialist at Atari's Customer Support number, 800-538-8543.

The close similarity between Atari Logo and Apple Logo gives us a nice side effect - virtually all of the Apple Logo programs and books written by or for LCSI systems will run on the ATARI with essentially no change. Krell/Terrapin programs need only trivial changes. TI Logo is the oddball here and requires moderate rewriting. I tested the Apple Logo compatibility by typing over a dozen programs from The Young People's Logo Association, magazines, etc; all ran perfectly.

This means that you could use any of the LCSI-oriented books easily and immediately. This not only makes a great many support materials available but also makes it relatively easy to operate a mix of ATARI and Apple machines in the classroom. All could be exploring the same microworlds, sharing materials and exchanging procedures. (Of course, it won't be long before the kids vie for the ATARIs because of their superior turtles and sound!) Parents could buy ATARIs knowing that their children's Apple classroom work could be brought home, and vice versa. (Of course they might ask why the school district bought such expensive machines in the first place!)

We'll cover books in a future article. So far we've heard that Apple Logo by Abelson (Byte Books) and Apple Logo: In Invitation to Art and Patterns in Nature by Thornburg (AddisonWesley) and Learning With Logo by Watt (Byte Books) are some of the best.

Some of you will ask the burning question, "Will Logo run on the new ATARI machines?" We have assurance from the Atari Logo Product Group that Logo will indeed run on the entire XL line, as well as on the older models.

There is also a significant educational question, "Does Logo really enhance learning?" Let me finish by quoting Robert P. Weiss, PhD, a school principal in the Santa Clara School District. "I cannot think of an educational goal which is not enhanced by Logo. There is no limit to what children can do with Logo, and they know it! Kids like it, and develop a sense of power and self-esteem because with Logo they can control their environment."

This kind of endorsement strongly suggests that Logo is and will be the computer language most used in classrooms for many years to come. We recommend Atari Logo to parents and educators as a finely implemented version of the language, completely suitable for use at home and in school.