LOGO Still Lives -- New Java-Based Version Released

farrellj writes "Many people were introduced to computer programming using a virtual turtle, or if you were lucky a robotic turtle. Created in the '60s by a bunch of people at MIT, including one of the formost experts on computer aided learning Seymour Papert, it gave a good grounding in programming in a day when BASIC and PASCAL were the only other easily available languages...I use to teach LOGO at a computer lab in Ottawa, but have lost touch with LOGO for many years. Today, a email appeared in my mailbox announcing a new release of LOGO called StarLOGO from MIT...wow...it is done in JAVA, and looks pretty snazzy. It runs on just about any platform, and I think that it again may be a great way to get young kids interested in programming. It took me about 2 minutes to get it running...just untar it, and run a shell script, and I had the enivronment up and running. In a couple more minutes, I was writing programs that created graphical displays that would look great at raves. So I guess it's for kids of all ages!"

Comments

It's can be about a lot more than graphics.

[jmacgill]

The thing we all remember about LOGO as kids was the fun graphics. But it's also a full language and it's an exclenet way to learn programming.

StarLogo has been around for a while now (though not in Java) and I've seen it used for some advanced things. For example, I remember being shown an agent based pedestrian model built using the thing if I remember rightly some years ago.

Re:It's can be about a lot more than graphics.

[Ian Bicking]

I remember Logo as being less useful than Basic - what really sticks in my mind is the brain-dead syntax for string literals, where the first space character ends the string. Hello? Strings with spaces in them?

Traditionally you use a list in place of a string, like PRINT [How are you doing today?] -- all items of the list are implicitly quoted, so that's a list of five words. Many modern Logos have alternate syntaxes for expressing strings with spaces.

There might be ways around that; there might be decent control structures (not just REPEAT 50), ways of creating data structures like arrays, and some means of calling external procedures or operating system routines. But they didn't get much emphasis in Logo programming textbooks, perhaps because they'd differ from one pl atform to another.

Like most Lisps, you can define your own control structures -- all the traditional ones are usually included. For instance, you can implement WHILE like:

TO WHILE :cond :body
IF RUN :cond [RUN :body WHILE :cond :body]
END

Of course, you will run out of stack if your logo is not tail-recursive (UCBLogo is, many others are not). But with WHILE and some other primitives, you can implement most other control structures without needing tail recursion.

The only data structure is usually the list. This serves as an array, and can do other things as well. Definitely old school Lisp. It's entirely sufficient, though associative arrays are convenient as well (can be implemented with lists, but annoying).

External routines are, as always, entirely up to the implementation. Many have plugins, usually there is no way to call arbitrary external code.

Ah, looking at the old Logo book on my bookshelf I see that the language had list handling similar to Lisp, its parent. But much clunkier and less elegant. Logo may be a functional language but I wouldn't call it a decent one.

It's not meant to be a great language -- it's an expedient language for young children. One example of this is the extensive use of abreviations (e.g., FD for FORWARD). Real programmers don't like these in their languages -- but real programmers type much, much faster than young children :)

I think Logo is very similar to Tcl, except where Tcl uses strings, Logo uses lists. Both have extremely simple syntaxes and semantics, and Logo is one of the purer dialects of Lisp -- but it's sometimes a bit awkward, and it's performance is fairly limited.

It's not just Logo

[Anonymous Coward]

Starlogo is not just another Logo version. It's a tool for experimenting with descentralized models. See the homepage, for more information.

Taken from there:
StarLogo is a programmable modeling environment for exploring the workings of decentralized systems -- systems that are organized without an organizer, coordinated without a coordinator. With StarLogo, you can model (and gain insights into) many real-life phenomena, such as bird flocks, traffic jams, ant colonies, and market economies.

There's a book by Starlogo creator, Mitchel Resnick called Turtles, Termites, and Traffic Jams : Explorations in Massively Parallel Microworlds where he shows the use of Starlogo in education.

Don't Forget MonoLogo, the .NET/Mono version

[Ur@eus]

For people interested in Logo there is also a Logo project called MonoLogo
that creates a .net version of Logo on top of Mono.

StarLogo...

[Squidgee]

Actually, StarLogo has beenout for quite a while; you could have downloaded it in 2000, or farther back :)

As you may already know

[Anonymous Coward]

LOGO is a dressed up dynamically scoped LISP. A very powerfull language actually.

Self-Organizing Systems

[homerus]

Last year I have cooperated in restyling the course Self-Organizing Systems. The teacher introduced me to this great massively distributed language, and it was an eye-opener. Together we have designed some fun exercises around some of the basic self-organizing properties which can be shown with StarLogo.

The students (freshmen) gave better ratings for the course after our restyling. Also, some more enthusiastic students have helped us with designing some new StarLogo apps. A real great tool for this course!

More information about our course at the Vrije Universiteit, Amsterdam.

Re:Name for this?

[ctrimble]

It's actually called StarLogo because the original version was written in *Lisp (star-lisp) on massively parallel computer system. At some point Resnick ported it over to Java.

Incidentally, StarLogo has a resemblance to Logo, but it's primarily superficial. StarLogo is all about exploring emergent behaviours in decentralised systems. While you can do regular turtle graphics in StarLogo, if you do it, you're kind of missing the point.

StarLogo uses thousands of turtles, instead of just a couple. StarLogo also allows the turtles to interact with their environment by doing things like creating pheromone trails. This makes it easy to do things like build an ant colony and watch it explore for food and create trails to the food for other ants to follow.

Incidentally, the ant colony code only uses thirteen procedures, each one no more than five or six lines of code. Here's a sample:

to find-food-demon
if (not carrying-food?)
and ask patch-here [food > 0]
[set-carrying-food? true
ask patch-here [set-food food - 1]
set-drop-size 35
right 180 forward 1]
end

This defines the way an ant finds food. Essentially, if it's not carrying food it checks the ground to see if there's any food there (ask patch-here). If there is, it sets itself to carry it and reduces the amount of food on the ground by one unit. The line set-drop-size sets the initial magnitude of the pheremone drop. There's another demon (return-to-nest-demon) that takes over once the ant gets food. It's responsible for following the pheremone gradient back to the nest and to mark the trail to the food by decreasing the food pheremone with each step back to the nest. That way the food pheremone will be strongest near the food, causing the hungry ants to go in that direction.

One of the other interesting parts of the book, Turtles, Termites, and Traffic Jams is the author's descriptions of the kids that he works with. He takes StarLogo into grade schools and gives the kids problems (like the ant problem, or a traffic jam modeling problem) and watches them solve it. All in all, it's an excellent book and I highly recommend it.

logo applet around for some time

[monk]

I taught my daughter rudimetary programming with logo about 2 years ago. I used a web-based implementation. It's a logo applet by Robert Duncan.

Squeak

[maggard]

For those interested in oo-language derivitives for teaching another popular one is Squeak. Just as Logo is Lisp-derived Squeak is Smalltalk-derived.

Small, portable, virtual-machine based, simple enough for kids to get started (and excited on) it's powerful enough for 'real stuff'. Check out the FAQ based on a Squeak Swiki.

Oh, and as Logo had Seymor Papert as 'the guy' behind it Squeak had Alan Kay who did lots of early work on 3D graphics, ARPAnet, windowing interfaces, modern oo programming, and inventor of the Dynabook.

Re:Although I used LOGO

[Ian Bicking]

I've seen sophisticated computer usering children still get excited about programming, even when their creations pale next to the games they play. Creating things can be tremendously fun.

Some of the commercial Logos (like Microworlds and Terrapin Logo) have considerably more multimedia capabilities. In some ways the language as implemented in those products is dumbed-down, though compared to any "game construction kit" or similar product, they offer tremendous flexibility. They are still real programming environments.

StarLogo is more of a computer science kind of Logo -- all about massive parrallelism. Which can be very fun and motivating as well, but probably requires a different personality to enjoy. The Free logos are still pretty much old-school, triangles on the screen kind of deals.

Of course, get her Lego Logo kits, and no one can resist that.

Logo I have known / written

[leighklotz]

Friends and I worked at the MIT Logo lab in 1980, where we did the first mass-market Logo, for the TI 99/4 (though I didn't contribute to it), and Logo for the Apple II (where I did). I then went on to Terrapin, which had originally been started by Danny Hillis and others to sell turtles, and we got Terrapin to sell Logo. I enhanced the Apple II version, and did the Commodore 64 version and we did a Mac version (plus some other ones like C128, C264, and C16 where the boxes never shipped, and some that only shipped a little, like Music Logo). I did Logo translations (with others), in Japanese, German, Italian, and French.

When Mitch Resnick was at MIT LCS and started the *Logo project as a grad student, I was a bit jealous as I'd been working on the same thing in my spare time, but I didn't have the resolve he did (thesis). It's funny, because the idea for *Logo came from StarLisp, of course, which was came from Thinking Machines, which was also started by Danny. The *Lisp stuff was fun, and I've often wished that Mitch would bring out StarLogo so I could play with it again.

I think my favorite Logo that I didn't write was the "1986" version mentioned by another poster -- it ran on a dual-processor PDP-11 / bit-slice machine with a vector graphics display. The drawing was done by adding to a "display list" which the vector processor displayed. This feature allowed Hal Abelson and Andy diSessa to develop some interesting observations about group theory (see their book "Turtle Geometry" ("Turtle Geometry: The computer as a medium for exploring mathematics" by Abelson & DiSessa, 1981, MIT Press, Cambridge MA).

The interesting thing about that version of Logo was that in addition to forward and right, it had grow and spin, which introduced time-varying elements into the display list. grow :n made a line that grew at a speed on n, and spin :n made an angle that turned at a speed of n. With fd and rt, the following draws a star that grows asymetrically. With grow and spin it explodes! Lots of fun taking any random old chestnut Logo program and taking it up a level.

to wow :n
if :n > 200 then stop ; yes, no brackets in those days
grow :n
spin 144
wow :n+5
end

My favorite non-Logo that I did write was at MIT AI and LCS and later at UC Berkeley, called Boxer, which presently runs on the Mac, but might be out on PCs sometime. It takes direct manipulation interfaces to the extreme -- the entire workspace is shown as the screen, and every data item and every procedure is represented as a box, a square container on the screen, and all are inside other boxes. To make a menu, you make a box with a keystroke, and put the names of the commands you want in the box. To execute the menu, you point and click. Pretty simple. There's all sorts of other features, like hyperlinked boxes, boxes that are portals to other resources (web sites, other people's computers, etc.). Look for it someday.