Slashdot Mirror
Forty Years of LOGO
SoyChemist writes "Forty years ago, LOGO, a derivative of LISP, was born. Several years later, it became the cornerstone of educational software that simultaneously taught geometry and how to think like a coder. With a plethora of high-end educational software packages to choose from, each with flashy multimedia and trademarked characters, parents and teachers may find the humble turtle a bit outdated. Thankfully, several LOGO programs are available for free through a variety of websites, but perhaps 3D programming environments like Alice will be the wave of the future."
I, for one, welcome our 40-year-old turtle overlords.
My introduction to programming was BASIC, back in 1980. By the time I encountered LOGO in a high school computer science class, it was a fun toy for about an hour, but then got old. Thinking back to that, I could conclude that LOGO is sort of lame, but for little kids who don't have the typing and language skills of middle school or high school students, I guess it's a better entry into programming than BASIC.
They're supposed to have LOGO on the OLPC XO laptop, and if I do that "buy one, donate one" thing, it will be interesting to see at which age my kid (who is now 2.5 years old) starts taking an interest in LOGO.
Start a happiness pandemic
My son tried logo, because his school had it and thought it would be instructive for the more able students. He was utterly bored, and is now learning python in his own time.
Logo was good, but the language landscape is so vast now there are better languages for almost every task to which logo can be put.
I learned to program using LOGO on a Commodore Vic-20 in 1980 or 81. It was an astounding program because it enabled a very high level of functionality without needed knowledge of a lot of technical details of the machine. My school district (Portland, OR) had a Talented and Gifted program that included a computer course, and LOGO was it. We were able to draw polygons and devise simple games (somewhat more rudimentary than an Atari 2600). Based on this experience, my brother and I got a Commodore 64 a year or so later, and I was disappointed in BASIC. Sure, it was structured more like a "real" computer language, but it wasn't possible to do anything even remotely sophisticated in Commodore Basic graphics-wise without resorting to quasi-assembly PEEKs and POKEs. To get around this, my brother tried to learn 6502 assembly, and burned out on computers (he's now a lawyer.. poor man). I was lucky and discovered Pascal...
I don't think I would have a career in the technology industry if it were not for LOGO (I'm an analog IC designer). A previous comment said Python is better for his child. I would agree. In fact, I would have done pretty much anything for Python and Pygame when I was a small child. However, for the late 70s and early 80s, LOGO was the educational language to beat, and the only way for a child to really feel the machine the way a programmer does, and not as a passive game player.
My concern with teaching and using LOGO in education is that LOGO fails to provide people with a fully capable language that they can use life long. How many teens or adults program in LOGO? What type of "real" programs can be written in LOGO. Is it efficient enough for practical programs.
My first programming language was BASIC, (then 6502/Z80 assembly) then Pascal, C and APL (APL is my favorite teaching langauge - see Kxdb+ from KX Systems to see where APL is now). While LOGO is cute, in my mind it fails the long term relevance test, and also is not close to CPU's in operational methodology.
Just my 2 cents
Simbuddha
Apple II had a facility called shape tables that could do sorta what logo could do at the time. You typed in a bunch of vertices in hex, and then you could draw the shape transformed in several interesting ways.
Shapetables, I thought, were the bomb, but also, proved to be my first introduction to the lesson: there is always a better program than you.
I was in high school at the time, Firestone in Akron, and we had a teacher that fought for and got a really nice computer lab. He was great. He had a lot of prestige because a future shuttle astronaut was one of his students, and in general, the math department there was one of the best in the state.
Anyway, I spent hours hand coding my shape table for a little lunar lander video game I was writing, and I thought I was the cat's meow, and I was all about to show it to everyone, trumpeting my genius, and this other guy walks in with a pinball game written in assembly language.
All I could do was compliment the guy, because it was great. He had decent sound, fast graphics, smooth play. It was just great. Amazingly, I don't know where he went with it, because it was right up there with the commercial pinballs of the day. But still, talk about humiliation! I about died!
This is my sig.
It's interesting that most comments here are along the lines of "I saw LOGO when I was 7" through "I played with LOGO for an hour in middle school." I tinkered with a couple of LOGO variants as a kid, but my real LOGO experience ended up being... in college.
In my school's Computer Science department, the class that weeded out (or at least delayed) the majority of students was our Discrete Structures course. The theoretical part of the course focused on typical discrete logic, discrete math, sets, predicate calculus, etc topics. But the unusual part was that the professor was determined to break us out of the C++ mold that the introductory programming courses began. Therefore, he picked LOGO as the language for the course. Sure, interpreted LOGO wasn't the most blindingly-fast choice, but the list-based nature of the class made it very much a "LISP Light" that we could quickly work with for solving problems. Surprisingly, it was extremely flexible for the kinds of logic problems we were working with. By the end of the year, I really had to rethink my initial concept of "oh no, turtle graphics." Plus, we got exposed to a bunch of quite interesting offshoots, such as StarLogo, a massively-parallel-turtle variation of LOGO.
If you've never had to write a parser for an arbitrary boolean arithmetic expression in LOGO, then you've never really lived... (Er...)
seven two six five
seven four six one seven
two six four two e
Personally, I never learned LOGO in school, I used it at my first programming job!
I was 17 years old and already know how to program in Z80 assembler and MBasic (Ah, the heady CP/M days!).
Imagine my surprise when I got an apprenticeship at a place where they did accounting - in LOGO!
Not just any LOGO either it was M.I.T. Experimental LOGO #43 if I remember correctly, running on a microcomputer with 12 terminals connected to it! And there was NO TURTLE in this LOGO, only the list operators, logic and math primitives!
This company was doing the monthly accounting of about 40 or so client firms and the whole system was written in LOGO.
I remember thinking "Why the heck are they using a kid language to do all this" at first, but under the teaching of my mentor, I learned recursion and abstraction to a level I had never considered before.
I mean instead of tripping all over the mundane aspects of implementation that you would bump up against in assembler or BASIC, here was a language that was so high-level that you really could concentrate totally on the abstraction and algorithm of solving the problem without getting tangled in a lot of what seemed to be more real-world problems (memory allocation, variable types, string/array manipulation, etc...), this language forced you to think in really high-level ways about the problems you were trying to solve.
It was a year of epiphany-after-epiphany for me and it did more to form me than any of the other languages I've ever touched. It caused me to rethink my approach to all other languages and tools and I feel tremendously fortunate that I was in the right place, at the right time to experience it all.
Sadly, that company's history ended badly; one of the partners was billing the clients directly and ran off with the money, so the company went under and I never did find another company using LOGO again.
Too bad reality and theory almost never line up...
I've recently been playing with Logo, I'm a veteran of the dev trenches and have gone through SICP.
I picked up all the 80s books I could find that used Logo to teach geometry, algebra, music, language etc. I'm currently working my way through them. There is of course the Compu Sci series from Berkeley http://www.cs.berkeley.edu/~bh/v1-toc2.html That I'm planning to go through next.
So for those of you who turned your nose up at logo because it's too simple for you may need to turn that statement around. Think Lisp without the parens.
so turtles all the way down?
It's hard to believe that's how Micronians are made. Why don't we see it right now by having you both kiss one another?
The turtle was the worst thing to ever happen to Logo. Logo is a full featured language capable of doing anything other languages can. But because we were all introduced to the turtle at relatively young ages and nobody ever showed us how to do anything more than draw simple pictures we all concluded that it was only a toy and not for serious use. Only now, years later, do I realize how wrong that was.
For those who want to rediscover Logo and learn what it was *really* all about you can go to the website of Brian Harvey, a logo guru:
http://www.cs.berkeley.edu/~bh/
On this website you can download a nice series of textbooks about Logo and also download the Berkeley Logo implementation of the language. I was surprised to find that Logo is a functional programming language. I am also studying Lisp, Scheme, Haskell, and Erlang and find the whole concept of functional programming to be very interesting. It is getting hot again and will become a critical part of programming if we are to take advantage of multi-core cpu's.
I am constantly amazed by just how vast this industry really is. I wish it hadn't taken me so long to realize this and I am saddened that so many people coming out of school these days have no clue that there is anything other than Java and Dot Not out there.
I, too, started with Basic (albeit in the mid-90's). Never saw LOGO... but I used a Lisp derivative (scheme) in our intro CS course at Georgia Tech. Even us non-CS guys (engineers, science majors, even liberal arts people) had to take the class.
Scheme was probably one of the worst things they could have had us using for such a class. The majority of engineers and the others didn't need to get too far into advanced programming concepts; most of us will never use anything more complicated than matlab.
Obviously, the course changed the semester after I took it; engineers/science people took a matlab-based class, liberal arts people used java and python, and CS moved on to something else.
I think most young children could probably use Basic once they can read and understand basic algebra.
The meek may inherit the earth, but the strong shall take the stars.
As a high school CS teacher, I am considering creating a class that uses Alice.
I think it may be easy for people in this community to make assumptions about programming languages and their utility. However, relevant questions, to me, include, "How do we get students who may not have sufficient math skills feel success as programmers at a young age? How do we get them hooked on the idea that computing and programming are accessible in their lives?"
Alice, with its drag-and-drop interface, can be frustrating for some professionals. It is a tool for learning programming concepts with an interface that is friendly to young people by producing a product that is of interest to young people.
It's just another piece in an ever-growing educational toolkit.
I recently introduced my kids to programming with Scratch http://scratch.mit.edu/ rather than LOGO. It does include everything that LOGO does, but it has a lot of benefits that make the feedback from programming more immediate and accessible, and the web site is great for sharing ideas, sprites, etc.
I've been trying to get my elder daughters (12 and 9 years old) interested in programming. I tried Squeek (a LOGO-like subset of Scheme), which they enjoyed... for a little while. The eldest actually started writing up routines for the entire alphabet, but eventually lost interest. Coincidentally, I found Alice about three weeks ago.
For kids, Alice has the staying power that Squeek and LOGO don't. It allows them to set up an entire 3D world and tell a story without ever making a single syntax error. They can even make their own interactive games, which is what they really want to do. No hunting for misspellings, no looking up methods or operators in website documentation, no Googling. Just programming, fast and simple. They don't even realize they're programming; they think they're having fun, and they are!
Sure, Alice has a few shortcomings. There's NO DEBUGGER. Polymorphism isn't implemented. Custom methods aren't displayed in the world view. It's hard to produce new models. But on the other hand, it's got my kids thinking like object-oriented programmers, having fun, and producing stuff they love.
I think the submitter nailed it with "Alice will be the wave of the future".
For geek dads: Contraction Timer
My first exposure to a computer was in junior highschool.
It seems that Logo was introduced to children a few years younger than that--think grades IV to VI. Computers were introduced into my elementary school around the time frame that computers were introduced into your high school (about 1982). In middle or high school students generally "graduated" to BASIC and perhaps Pascal programming. Older students were also the first to get computers (A small classroom with a number of Commodore PETs and a single "Bell+Howell" branded Apple II+). So, in my school those in Jr High in 1979 to 1982 would've been introduced to computers via BASIC on the PETs and would do a bit of "fun" stuff on the Apple in BASIC as well.
A couple more apples were brought in, then in 1982 Commodore released the 64 and our school bought a large number of them. The Apple II+ and C64s were primarily put into use in elementary grades...and they were each ordered with a copy of LOGO! I was lucky enough to have been in the right grades when they were brought in. LOGO was also ordered for the Apples around that time.
LOGO made for a superior introduction to programming than BASIC for several reasons:
* LOGO took advantage of the graphics and sound capabilities of the machines on which it ran. Without exception ALL dialects of BASIC supplied with personal computers at the time lacked some degree of built-in support for these capabilities and required PEEK, POKE and CALL/SYS/USR commands and machine language skills to fully exploit. Atari BASIC was the best (only lacked support for sprites and a couple of GTIA graphics modes), followed by Apple (no sound support at all, even for the internal beeper, but good graphics), TRS80, and last and very least lousy Commodore BASIC (vanilla MS BASIC without any extensions at all). LOGO could beep, draw pictures and the turtle was always a sprite on machines that supported sprites.
* LOGO syntax was consistent/standard at a high level. I made some fancy programs at home on my Coleco ADAM's SmartLOGO and could type the printout character-for-character into a Commodore 64 and it would run fine! There were visual differences due to differing resolutions and colour palletes (both had 16 colour selections but didn't use the same 16 so it looked tacky on one of the machines). There was absolutely no way to accomplish this level of compatibility with BASIC (beyond the rudimentary MSBASIC standards, so no graphics or sound) with one exception--the Coleco computers' SmartBASIC was syntax-compatible with Applesoft BASIC.
* LOGO was extensible and structured. BASIC was a mess in comparison, with its line numbers and how it enticed beginners into using GOTO. LOGO encouraged structure in its syntax--it had formal, named procedures (TO MYSQUARE/REPEAT 4 [FD 100 RT 90].../END, and you called the procedure as if it were just another built-in "word") and didn't have an enticingly easy-to-use GOTO construct. As a result the code was very readable and students learned good programming practices.
When we "outgrew" LOGO our schools didn't even throw us into old-school BASIC even then; we were put onto IBM XT clones (built by Commodore--like many Canadian schools we had an infatuation with Commodores, probably due to Commodore's Canadian roots) but learned "True Basic" instead of GWBASIC which was more strucutred and "modern" (and interestingly enough, multi-platform as it worked with Macs, etc). In high school QuickBASIC was used on 286 machines.
If it wasn't for me doing BASIC programming on computers at home (and trying my coleco code on the Apples at school) I might never have known basic had line numbers.
Scratch from the MIT Media Lab is everything I got out of Logo when I was kid except more fun. Kids can still learn recursion, sprite manipulation, even some coler stuff I don't remember from Mr. Keating's 6th grade symposia on the wonders of "mt". I have sent this link on to anyone that haskids and a computer. Awesome fun, and what the hell--some learning to boot.
blarg.
Guns don't kill people; Physics kills people! - John Lithgow as Dick Solomon on Third Rock From The Sun
I can't claim to match the 40 years LOGO has, but I can claim that my first computing experiencing was making the turtle do what I wanted on the good ol' Commodore 64. I was 7 years old. By about the time I was 9, my computing curriculum included replacing the turtle with custom single-color bitmaps. If you did it right, you could feign animation-- one image with a guy who is taking a step, one image with the guy's legs together; "pick up the pen", move a few pixels in the positive direction, replace the cursor bitmap, move a few more pixels replace with the original bitmap; repeat.
It was great fun while it lasted. A digital (but so low tech to today's standards) picture flip book. And it taught me procedural coding techniques. I'm glad the "turtle" was part of my past.
libertarian: (n) socially liberal, financially conservative; neither left, nor right.
First, smalltalk is very much alive. Second, learning different programming languages helps you THINK in different ways. Smalltalk is incredibly nifty and has things that C++ doesn't (for example, EVERYTHING is an object, which means you can add a method to the equivalent of the int class), it also has the idea of an image. Basically, you save a *running* program, with all its data etc), which is incredibly nifty.
I'm not a Smalltalk programmer and have just dabbled in it, but can tell you how other languages have helped my thinking. Learning Scheme made me really understand first-order functions, which made me able to efficiently use C pointers to function, and later many 'patterns' for event handling. Learning Haskell helped me really understand templates.
So, learn the languages to help you learn to think, and who knows, maybe you'll even get a job using them (I've seen postings for Haskell, Smalltalk and Scheme)