Logo was the best!

I still remember my father 'explaining' me Pythagoras theorem when I was around 5 to show me how to draw the roof of a house on our hand-soldered Philips Apple II clone.

I've been hooked ever since.

The best thing was that 25 years later I opened a Logo emulator again and when faced with having to clean the screen somewhere deep, deep from my muscle memory the right command sprang forward: `CLEARSCREEN`.

Oh man, PC Logo takes me back down the memory lane. We were introduced to PC Logo in 4th grade. That's about 9 years ago. I instantly fell in love with it. The amount of power I had over the computer - ordering it to draw what I want, how I want, was really exciting.

My father had installed Kubuntu on our home computer which had an amazing suite of educational applications, including KTurtle which was (almost) the same as PC Logo. I got so addicted to it, my father suggested me to create a blog and regularly update it with the drawings and the code for it. And so I did! Good times :).

In the same vein:

    CALL -151

That was the entry point to Apple 2's "monitor", i.e., bare bones assembler. Not the most beautiful but very evocative. Gave me a sense of power. :-)

The true beauty of Logo comes in the realization that you can add your own words to it, and that all these specialist words you devise are themselves first-class citizens of the language, of syntax and status equal to its generic builtins. For example:

    TO CIRCLE
    REPEAT 360 [FD 1 RT 1]
    END

    TO FLOWER
    REPEAT 20 [CIRCLE RT 18]
    END

And so on ad infinitum, until you arrive at a complete custom vocabulary that concisely and precisely expresses the particular concepts and behaviors of interest and importance to you. In doing so, you move from thinking algorithmically (which is glorified spaghetti) to thinking compositionally, which is the key to scalability – managing complexity as your needs and ambitions grow.

Whereas Algol-y languages treat user-defined vocabulary as second-class citizens, beneath their own privileged built-ins. Which is a ridiculous status when you consider which is actually important to the user: precise, powerful, tailored words that describe their particular problem, or the crude primitive undifferentiated building blocks that the language dumps out of the box?

The beauty of bottom-up programming, as any Lisp fule know :), is that it endlessly tests your own understanding of the problem domain: to define effective, productive words you must have some idea of what you're talking about; you can't help but learn the foundations of the problem space as you go. There's a basic humility to this approach; there's nowhere to hide laziness or ignorance.

Whereas in top-down programming it's much too easy for highly-educated highly-paid absolute know-nothings to bullshit eternally, constructing great theatrical class architectures; grand mechanical castles in the sky that look all very difficult and impressive to observers while never saying anything relevant or useful.

That key switch from algorithmic to compositional thinking is not a natural conceptual leap for self-learners – it takes a carefully directed prod at a particular point in the learning curve to jump those rails – but it opens up worlds. #PlatosCave

For all you Logo fans out there, you should really play Duskers. It's "Logo meets Aliens".

How my, so many souvenirs. Especially the one when our teacher took us to the courtyard and had us do the turtle in real life, him giving the instructions.

Thanks for sharing. What a cool story! That must have been a unique time to grow up. Going through adolescence a decade later, computers and the software they ran had advanced significantly enough that the thought of trying to code anything at that age was never even considered.

Your story helped me live through that era vicariously and I can imagine it would have been fascinating to my younger self as well.

>     REPEAT 20 [REPEAT 180 [FD 1 RT 2] RT 18]

It's a great image because it reminds me exactly of what we used to do, especially the `REPEAT 180` with `RT 2` instead of `REPEAT 360` to avoid repeating the circle twice since the circle looks the same anyway on those monitors. Once you move up to `RT 3` or more it begins to look a bit more like a polygon.

I started with Logo at school and it was a great teaching language and gave me a good basis (e.g. we did a ton of recursive stuff) and a passion for creating things with code.

Logo wasn't the first language I started with (that would be BASIC), but it is one I have many fond memories of from childhood. I used Logo later on to program microcontrollers used with Lego to build simple robots and machines. One of my proudest moments was building a functional prototype of a washing machine with selectable wash cycles. It allowed me to begin understanding many of the things which we find in the world that rely on small embedded electronics to function.

I wish there were programs like this for children these days in school. I know Scratch derived from Lego Logo and there's still things like Lego Mindstorm, but I don't think there are many common programs at least in the US to teach children programming and prototyping using these simple mechanisms.

I remember reading about Seymour Papert's Logo back in the 80's and getting blown away by how elegant and luxurious the language felt. But, the need to start Logo environment first in order to run a program kept me away from it so I kept working with BASIC and Assembly. That kind of friction matters a lot.

"FD 100" was my introduction to programming too! This short post just brought it all back!

I've remembered for years that there was some for-loop syntax that I'd used as a kid. I knew it wasn't `for` so seeing `REPEAT 360 [FD 1 RT 1]` was quite a revelation for me just now! That's exactly what I was writing back then. I think my first instinct at the time was `REPEAT 4 [FD 100 RT 90]` and from there went on to draw pentagons, hexagons, and then at some point had a eureka moment and tried `REPEAT 360` … mind blown!

I was using an Amstrad PCW 8512 and would love to hear from anyone else who had a similar experience.

That's exactly how I started programming too in 1994. :)

Baliex, I had an 8256. I read some code in a magazine showing how to draw fractals recursively (they were Koch snowflakes actually) and I had a lot of fun making more complex fractals using that basic recipe. The PCWs had a monochrome screen that was quite hi-res, certainly compared to what I was used to, which worked well for turtle graphics.

As someone who hasn't done graphics programming (or anything like this), it's amazing to me how simple directives can yield such things. Is this type of logic still used in games/graphic programming today?

Sili, It can, and it does, sort of! There's a bit more boilerplate in most environments designed for shipping things, but one of the more high power/terseness activities is writing a shader that can render signed distance fields. The article at https://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm compose a few of these together and you can manifest some pretty nuts infinity fractals. Here's a video I made playing with the functions provided: https://twitter.com/LeapJosh/status/1439876813258256385.

Sili, Sort of related to games/graphics programming - There's an open source CAD program called OpenSCAD that allows you to create 3D models with code that can be simple, but gets complex fast. I personally tried using it to create models for 3D printing, but got overwhelmed and decided to go to other tools.

Lovely post, though it's weird to end in saying that this "gave me a brief taste of functional programming". Turtle drawing is arguably the most non-functional, stateful programming paradigm ever invented.

This was a great blast from the past. A few friends of mine and I would write down instructions to draw crude pictures in Logo; the usual sorts of things you'd expect from kids.

I'm sure lots of other kids did the same thing; kind of a fun way to sneak into writing programs —a low barrier to entry, and immediate results you could tinker with.

Is there something popular like this today?

DrCode, Well, they say that Logo gave them a taste of functional programming, which is a broader statement than turtle drawing (which, to be fair, is the bulk of the prior discussion). Logo was strongly influenced by Lisp and, consequently, is a multi-paradigm language including functional as one of its paradigms.

Paul, A lot of kids (middle and high schoolers) these days have pet projects like making HTML-based website and writing a discord bot in JavaScript. The fact that our district hands out Chromebooks probably contributes to the trend.

DrCode, Logo is more than the turtle. Brian Harvey wrote a whole series of textbooks for Logo that really stressed the functional aspect of the language: http://people.eecs.berkeley.edu/~bh/v1-toc2.html.

DrCode, You can think of it that way, but you can also think of a Logo program as a purely functional computation that follows the monad laws. Here's a Haskell package that implements it: https://github.com/aneilmac/worldturtle-haskell.

This takes me back to https://mitpress.mit.edu/books/turtle-geometry, a great book by Harold Abelson and Andrea DiSessa. It uses turtle geometry to explore college-level maths concepts and biological phenomena such as predator-prey relationships.

Last night I was chatting with my girlfriend (who works as a CAD designer in textile industry) about Logo! Like the author of this post, Logo was my first language, and I was really excited to draw squares, cubes, and rocket ships, between the ages of 7 and 9. I had a lot of fun experimenting with the audio frequency generation as well, composing some basic songs (Ode to Joy, Au Clair De La Lune, Frère Jacques).

Years later, when I was 26, I got to use Logo again! I wanted to draw a time-proportional train map of Taiwan. The distance between each point on the map corresponds to the time it takes a local train to travel that far. It made more sense to do that in Logo than in any other language. So I rewrote a basic Logo implementation in JavaScript and called it TurtleSheet: http://peterburk.github.io/tra/.

I hope that some teachers will see the potential of empowering kids, by giving them real-world data like public transport times, and getting some real designs out.

Me too. I learned Logo in the 90's during 3rd grade. Now thinking back, it was probably an important defining moment in my life because it let me experience creativity through coding and visual feedback (and also the constant discovery of new ways of using the various commands).

Similar sort of experience, although we had no turtle, so it was BASIC on the BBC Micro for us.

    10 MODE 7
    20 PRINT CHR$141"A text adventure"
    30 PRINT CHR$141"A text adventure"

May as well have been the opening bars of Beethoven's 5th, for the infinite and incredible possibilities which followed. Anything. I could make anything. It was the most incredible sensation and realisation - and still is.

For me, it was QBasic under MS-DOS.

    SCREEN 13

is the start of endless possibilities!

I think this kind of experience is missing for kids now – but I'd guess it's more about how ubiquitous computers are, and how there's a lot more between the kid and the computer. When a CLI is your interface, making even rudimentary graphics feels like achieving magic. When your interface is a cell phone or GUI, there's a much larger leap from zero to "feels like magic" – OK, so I made a circle bounce around the screen... there's already an app that does that.

This is so amazing. Using absolute minimal primitives to achieve interesting results!

I agree 100% with the author -- logo as a child is what started me on programming. My first programming experience was in ~1981 or so when my elementary school teacher brought an Apple II into our classroom. She was getting her MS in education, and it was on-loan from her college. It was loaded with Apple Logo, and you had to pry me away from it with a crowbar. That was one of the first times I stayed after school willingly. I hounded my parents mercilessly until they finally bought an Apple II clone.

I eventually learned BASIC, and learned debugging and "hacking" by fixing the games that I typed in (incorrectly) from magazines and modifying them to do different things.

Such great memories! Logo, then moving on to Basic on the VTech PreComputer 1000, then GW-BASIC on PC (which to this day I never figured out how to exit! I used to turn the computer off and on again).

Llimos,

`SYSTEM`

We had a Logo turtle at school in the late 80s I guess. I can't remember if it was hooked up to the BBC Micros or the RM Nimbus pseudo-PC that were popular in UK schools at the time. But either way, it seemed amazingly cool.

> Logo gave me a brief taste of functional programming even though back then I did not know the term "functional programming".

This is what Unix pipes did for me. By the time I started programming, constructing programs as series of side effect-free transformations felt perfectly natural. To be precise I did have some previous imperative programming experience and I didn't like it or grok it.

It seems a pretty common thing to have a pleasant nostalgic memory of Logo as a fun introduction to programming. My experience with it was pretty different. I found it pretty pointless and boring at the time. It didn't have any pull on me the way C later did.

Ironically, a big part of what made C fun for me were the Borland conio (console I/O) and graphics libraries. Those were fun only because I could respond to user interactions and make simple games and other playful things. Looking back on it, that was probably the missing ingredient with Logo for me. We were never taught any ways of user input. They were just static programs that did one thing and that feels fundamentally different.

Great article! :) I spend my days developing turtleSpaces, a modern 3D environment for coding in Logo, based on the Apple Logo II implementation (and greatly expanded upon). Like the original Logos it has a REPL and you can just type `FD 100` and the turtle will happily move as expected.

It's written in Go, and as such has builds for macOS, Linux and Windows, as well as a WebAssembly build which runs inside of a Javascript-based IDE. We still have a ways to go to reach our goal of a Logo-based multi-player 3D game engine (like Roblox) but you can do a great deal with it as it stands now, including creating STL files for 3D printing and making simple games and animations.

I did the "heathkit" version of programming: Typing in BASIC code for a version of lunar lander on a TRS-80 on the sale floor of my local Radio Shack.

Later I learned to write my own kits. And sometime after that, I got others to pay me for the pleasure - Winning!

My first programming language (aside from HP-12C routines) was COMAL on the C64. COMAL was advertised as being halfway between BASIC and PASCAL, and it also had Logo turtle graphics and featured a corresponding split screen text/graphics view. Great times.

Thank you for your article! It brought back memories for me. I also used Logo as a child, when I was at school. I was able to draw shapes, and even simple fractals (like Koch snowflake).

Sadly, I wasn't one of those child prodigies. Logo didn't start my career as a programmer back then; that didn't happen until a decade later.

But then I re-discovered turtle graphics, as a Python library: turtle. No installation needed. It's a built-in! And I started using it with the same childish joy! Now, armed with proper programming background, I am able to draw more complex shapes (such as Lindenmayer system), and even use turtle envorinment (with OOP) as a canvas for projects like boids or solar system simulator. I'm glad I'm able to enjoy turtle again!