I was very involved with Logo back in the 1970s and 80s. I spent a fair bit of time at BBN working with Wally Feurzeig and crew, and ran a number of Logo workshops for teachers here in British Columbia.
I finally gave up when I realized that most of the teachers I worked with saw the pretty pictures produced by the screen turtle as the goal, rather than the deep insights produced by the programming process. For them, Logo was never going to be anything more than an Etch-a-Sketch.
I hear you, but I think it still worked. I was in elementery school in the 80s and learned logo (and had it at home on an Apple ][+). My teachers fit your description - they were most excited by the pictures we were able to make. None of them knew how to code. But that didn't keep the students from having the Aha! moments that logo provided, or from developing an understanding of key programming concepts. It was the interaction with logo that taught us, not what our teachers did or didn't explain to us.
Thank you! I was one of the kids in school in BC whose life was likely changed by that.
In spite of the feelings of the teachers, it worked. One day one of us (may be, maybe it was my friend Ronny, I dunno) figured out that we could open up a magic screen that let us type more than one command, and have them all executed when we were done. We were programming and didn't really know it!
I realized years later that I'd learned programming from Logo, and look back on those days in the computer room with great fondness.
I worked on a Logo computer in 1983 but never launched it. Even so I tried to keep up with the Logo community over the years. I was very disappointed to see what schools did with Logo through the 1980s. To me it seemed that the worst problem was that the teachers were gatekeepers - if there was a book they were the ones who had it and they only passed a small fraction of that to the students. Every time I would see a school showing of their student's Logo projects I would see how many pages of the "Apple II Logo" book you would have to read to do that. It normally would be around the first 8 to 12 pages of the 280 page book.
The solution would be to put the book in the system. That is what Smalltalk-80 came close to offering. But 8 bit floppy-based computers were not up to that. Eventually the Internet would become a way around the gatekeepers, but by then the idea that Logo had failed had become widespread and we had to wait for Scratch to occupy (not very well) that space.
By "current situation" I mean that with larger disks and the Internet in the mid 1990s it was possible to package a system like Logo with a whole book and a nice library of examples. In the case of Scratch there was a shared website where students could post their projects and look at projects from all over the world. As Alan Kay would put it, being literate is not only being able to read and write but having access to literature.
For some reason many people don't take Scratch seriously because of its visual nature. So they do a similar system where you can press a button and see your block as JavaScript text so you can know that you are doing "real programming". The real reason Scratch is limited is because it was created that way on purpose to make it easy to make simple games and animations. It could easily be expanded into a full programming language and the Snap! project at Berkeley did exactly that.
Logo was a full programming language from the start. Early versions didn't even have the famous turtle and focused on text applications. By the time of the 8 bit microcomputers it had become associated with the graphics (and so was used as the world's most awkward drawing program) and limited implementations. 64KB was a huge amount of memory for Basic or Forth, but only allowed the simplest Logo programs to fit and ran them very slowly. This made people think that Logo was just a toy (which was not true) like today they think Scratch is a toy (which is true, though not for the reasons they think).
It's definitely a tough one when thinking about marketing Logo, because the educators do need to be Logo-savvy for it to work in a classroom setting and it's hard to convince them to take the time to learn it properly themselves. That's why I think it's better to try to get contemporary Logo into code camps, because the facilitators are more motivated and have some enthusiasm for it. But we'll see :)
Could you please e-mail me at melody at retrocoders.org ? I'd love to chat with you about BBN. We're in Victoria
That's the problem with just about every well-meaning "computers in education" program, even more recent efforts like OLPC. The teachers have to understand the power of the machine and the insights and abstract critical thinking that can be taught through it. Most teachers are like the sort I grew up with: they would hold floppy disks by sticking their fingers through the hole in the middle. And they mishandled kids even more destructively, treating them like vessels into which it was their job to pour the curriculum.
I was introduced to LOGO sometime around 1981/82 while I was in elementary school. I loved it. My teacher was just as much of a nerd as I was, so we all learned it together. Had it not been for LOGO, I certainly wouldn't be the nerd I am today.
As a kid who grew up using logo in the 80s at school (Alberta though, not BC), it was the pictures that i could make that actually got me to do more than just the basics that the teacher had us go through. I ended up getting a CSC degree, in large part because of fun programming like that. So thank you for your effort regardless.
I just checked again, and thank God, it seems the book "Turtle Geometry: The Computer as a Medium for Exploring Mathematics" is in Open Access.
No book has ever can come close to the magnificent exposition of geometry and programming you'll find in it :
https://direct.mit.edu/books/book/4663/Turtle-GeometryThe-Co...
This is a marvelous book coauthored by one of the SICP coauthors. In contrast to SICP its focus is on math more than programming, and it aims at exploring math more than covering a curriculum for a course.
In Logo's heyday there were several other fine Logo books -- like Brian Harvey's Computer Science Logo Style, and one whose title I'm forgetting, by several authors, billing itself as for a particular Logo implementation but with lots of rather interesting projects like a basic proof assistant.
Logo is truly a delightful little functional language. I've written a few implementations over the years- this one is built in Forth, drawing from Apple ][ logo: http://johnearnest.github.io/Mako.js/?rom=Loko
And another written in Java, as part of a more elaborate edutainment adventure game I still have in an unfinished state: https://github.com/JohnEarnest/MLogo
Could you please elaborate on your game idea? I'm wanting to do something similar, but I haven't quite found anything that I'm happy with, and I'd love to hear what you had in mind, if you were willing to share...
If it really piques your curiosity, I might be able to dig up the demo build I distributed to a few colleagues.
Oh, and another feature that isn't really shown off there is the manual- all of the examples can copied into an editor buffer and then tinkered with directly at the REPL: https://i.imgur.com/CwCaLY5.gif
Having access to a language with a turtle is nice, but Python really is not the same thing as Logo.
Logo is a small, simple, and powerful language. It has simple syntax and a small number of concepts, making it easy to learn.
Python is a large, hairy scripting language that is currently an in-vogue way to glue together performant C libraries and get work done. Python can be useful, but I do not think it is nearly as well suited to education as Logo is.
Agree, but just wanted to point out that Python started life as ABC, a language that, like Logo (and BASIC), was designed for teaching and prototyping.
For some time I have found it amusing that ABC's pilot studies were largely used as a justification for Python's significant whitespace, despite the fact that the ABC editor provided syntax-aware editing whereas Python was always composed with an ordinary text editor.
Indeed. Logo offers a great "my first programming steps" experience. Often translating the programming language (and syntax errors, etc) to the native language of the programmer.
This is unmatched, and can never be matched, by Python.
Not really, no. You might not be able or willing (pedagogically) to get kids to the interesting bits, but traditional LOGOs (being ~ pre-Scheme LISPs) are dynamically scoped and have tail call optimization, neither of which would work in Python. The implications are that control structures are defined as simple procedures, there aren’t really closures, …
You can probably reimplement much in Python, but at some point you will have to admit you’ve written a LOGO interpreter.
I'm not saying Python is a LISP, but it does have closures. I'm not sure why tail call optimization matters for teaching. This is beginning to sound like a Python bashing instead of a Logo praising.
Anyway, I've taught with Python a fair amount and have been pleased with the results, especially when using the `turtle` module.
One of the advantages of TCE in Logo (in combination with turtle graphics) is that you can teach the concept of recursion in a gradual and intuitive manner. You can start with drawing a circle, using recursion to make an infinite loop, stopping it manually after a while:
to circle
fd 3
rt 7
circle
end
Add a parameter, and get a spiral. The turtle winds its way off the screen, and again the student can stop the program manually:
to spiral :x
fd :x
rt 30
spiral (:x + 1)
end
Introduce a base-case, and now the program stops itself at a desired size:
to spiral :x
if (:x = 30) [ stop ]
fd :x
rt 30
spiral (:x + 1)
end
Small, unsurprising steps building up an intuitive grasp of a useful concept.
TCE can also improve the economy of the language, reducing the number of "primitive" control flow concepts that need to be provided out of the box. Since Logo has no "special forms" and is not eagerly evaluated like a Lisp, it's easy to make new control constructs without needing to teach any magic:
to while :cond :proc
unless run :cond [ stop ]
run :proc
while :cond :proc
end
Turtle in Python would have the same flow of ideas up to the invention of new control flow, which I agree is cool. But that's why Python isn't a LISP.
Yet, the creation of a "while" here isn't so different than making a new function which performs that logic. Was your example intended to demonstrate creating new syntax?
It takes two arguments ("cond" and "proc") which would both be bracketed lists.
"unless" is common sugar for a negated if statement.
"run" evaluates a list as an expression. You'll notice that if/unless also take their bodies as lists, rather than any sort of special-purpose block syntax.
"stop" short-circuits the current procedure and immediately returns.
Since Logo has dynamic scope, any variable references in "cond" and "proc" will resolve the same within "while" as they did in its caller; no nasty visibility surprises. Since Logo does not eagerly evaluate lists, there is no need to "quote" or otherwise escape the lists in the caller's context. It is precisely that one can define such a construct without defining new syntax per se that is useful.
One extra note: LOGO does not have closures (closures require lexical scope). Dynamic scope gives the possibility to, e.g., define new control flow without quoting, but lexical closures are not possible.
Somewhat similar but in the browser - which is useful if you are trying to teach a bunch of kids on a smorgasbord of Macs, Chromebooks, Windows machines.
That's not Logo. That's only the turtle graphics from Logo. Logo is a complete functional language like Lisp but without parentheses, although parentheses can also be used.
Logo was my second programming language after basic when I was around 9 years old. I did not have access to much lego in my country but agree that it is a very good way to stimulate young minds. My son’s just 3yo and since he was about 2 we started playing with lego blocks, at the beginning large ones then moved onto regular legos. I am very reluctant to introduce him to the digital world and will delay that for as long as possible. Instead I will be buying phisical kits, puzzles and games for him and let him explore this way. Luckily he’s not into action figures and weapon toys.
Logo was one of the 3 I first picked up on Assembler, BASIC and Logo. My first computers weren't capable of running LOGO (no real display). I didn't have a LOGO interpreter so I coded one in BASIC. By god it was slow. But I did pick up structured programming and it led me on to LISP (and SASL/CLU,Pascal,Modula 2). Somehow I still ended up using C/C++ daily. I guess that's just how it goes. But LOGO was and is nice. It (almost) has what my dad calls IKR (Immediate Knowledge of Results) and if LOGO were to develop further it is exactly the area of realtime interactivity I think it should move. Great language with a lot of thought put into it but still very much a product of its era.
Thanks to everyone who tried out turtleSpaces! While we're aware we're just one Logo in a vast lineage of Logos, we're passionate about helping to make Logo relevant again, if even just a little bit. So thank you.
Even in this day and age, I was pleasantly surprised to find logo being taught in my kids school as one of the main subjects in elementary!
Principal's eyes glistened with moisture when I complemented her on this!
Apparently they receive a ton of flak each year from parents for not being in the know and teaching the latest/hottest/.. languages.
As a kid I learned to program using a book introducing a Logo-inspired programming language with the Russian syntax - Robic [1,2].
It had a concept of an Agents living in an Environment.
It had several builtin agents, i.e. an "Ant" and a "Painter", etc.
The syntax was more Pascal-like than Logo itself.
Just like Logo it was designed to teach programming to very young kids.
It was rather limited, so the second half of the book was introducing Rapira [3,4] - a SETL-based programming language with Russian keywords. It was rather advanced dynamic language and had lots of data types: tuples, sets, etc.
Recently at work I did some simulations using NetLogo - so it was fun.
That was also my progression! The end of the road was the C++ AP test my junior year of high school. I believe we were the last year of the C++ test with Java being used after that.
Same here but only in elementary school. At least back in 2004. We moved from Logo -> QBasic -> Visual Basic -> HTML -> Java -> C before graduating high school.
edit: there's also a very good three-book series for beginners called Computer Science Logo Style, by a UC Berkeley prof whose name I can't recall... Brian Harvey maybe?
I got my start with computers in 2nd or 3rd grade, in our elementary school computer lab filled with Commodore 64s running LOGO. I and one or two other kids would get to leave the class before 'computers' early to boot up each of the glowing boxes of power, feed them their floppy discs, and load LOGO on all of them before everyone else got there.
As a reward, we'd sometimes get to spend our lunch hour with them unsupervised. This led to us learning basic, finding early demoscene-like animations (that someone got from a high schooler! wow!), and typing in programs from the backs of computer magazines.
I'll never forget that feeling of discovery and control - it was so empowering to be able to make this box do something that I created.
Now I spend my days trying to thwart ransomware and cybercrime... sigh...
Most impressive to me is that the turtle was originally an actual (robot) turtle. Even nowadays with all the fancy graphics, surely students would be much more excited about programming an actual robot than a little triangle on the screen!
And since we're still paying >$100 for 1990s tier graphing calculators (OK, I think they finally got color screens) it doesn't seem infeasible to give each student their own little robot to play around with?
Also, can anyone confirm that the Turtle robot is from the 1940s? What's the story behind that?
I finally gave up when I realized that most of the teachers I worked with saw the pretty pictures produced by the screen turtle as the goal, rather than the deep insights produced by the programming process. For them, Logo was never going to be anything more than an Etch-a-Sketch.
Sigh