Yeah, somehow I owe my entire software engineering career to that flower and garden program example. There was something about being able to add new words based on primitives, and new words based on custom words, that captured me for good.

I'm currently writing a history of this. What year in the 70s? I've struggled to find widespread logo use before the end of the 1970s.

  Lisp hacker, Atari Cambridge Research Lab
  1984 - 1984 · Less than a year
  Symbolics Lisp Machine code to use a Star Wars arcade game as a graphics output device,
  6805 code loader, 3D turtles, maze game (jsMaze.com was my second try at this).

SVG paths only update a position internal state as you add drawing primitives, logo also has heading. I think this is a significant difference.

Not exactly, but true insofar as SVG and PDF files are basically PostScript programs with the code and logic stripped out, and effective drawing commands left in (or "distilled out"), which is that they merely represent the graphical output, without the Turing complete programming language underneath. With all the loops unrolled and mathematical expressions, logic, and conditions evaluated.

Capturing the graphical output of a program (just drawing commands, or calls to any api surface like turtle graphics, or stencil/paint porter/duff renderinging API, i.e. PostScript => PDF, SVG, or HTML canvas 2d rendering context) is called "partial evaluation".

https://en.wikipedia.org/wiki/Partial_evaluation

>In computing, partial evaluation is a technique for several different types of program optimization by specialization. The most straightforward application is to produce new programs that run faster than the originals while being guaranteed to behave in the same way.

Meta-circular evaluators are useful for partially evaluating programs, and fortunately they are easy to write in homoiconic languages like PostScript and Logo:

https://en.wikipedia.org/wiki/Meta-circular_evaluator

>In computing, a meta-circular evaluator (MCE) or meta-circular interpreter (MCI) is an interpreter which defines each feature of the interpreted language using a similar facility of the interpreter's host language. For example, interpreting a lambda application may be implemented using function application.[1] Meta-circular evaluation is most prominent in the context of Lisp.[1][2] A self-interpreter is a meta-circular interpreter where the interpreted language is nearly identical to the host language; the two terms are often used synonymously.[3]

https://en.wikipedia.org/wiki/Homoiconicity

>In computer programming, homoiconicity (from the Greek words homo- meaning "the same" and icon meaning "representation") is an informal property of some programming languages. A language is homoiconic if a program written in it can be manipulated as data using the language.[1] The program's internal representation can thus be inferred just by reading the program itself. This property is often summarized by saying that the language treats code as data. The informality of the property arises from the fact that, strictly, this applies to almost all programming languages. No consensus exists on a precise definition of the property.[2][3]

The Shape of PSIBER Space: PostScript Interactive Bug Eradication Routines — October 1989:

Printing Distilled PostScript:

https://donhopkins.medium.com/the-shape-of-psiber-space-octo...

The Metacircular Postscript Interpreter:

https://donhopkins.medium.com/the-shape-of-psiber-space-octo...

For example, partially evaluating ("distilling") this compact high level recursive data driven fractal PostScript pot leaf drawing program would expand it from one page of concise PS to many pages of repetivive low level PDF drawing commands.

https://donhopkins.com/home/archive/news-tape/pictures/leaf....

https://news.ycombinator.com/item?id=22461545

DonHopkins on March 2, 2020 | parent | context | favorite | on: Sun's NeWS was a mistake, as are all toolkit-in-se...

I wrote a metacircular evaluator, ps.ps, but I only used it in PSIBER for debugging (single stepping through code, which the normal PostScript interpreter didn't support directly, and also drawing visualizations of code execution). So the fact that it was slow wasn't really an issue, since it wasn't used in any speed critical situation.

https://www.donhopkins.com/home/code/ps.ps.txt

Nether GoodNeWS aka HyperNeWS aka HyperLook nor TNT (The NeWS Toolkit) used a metacircular evaluator themselves.

HyperLook could copy the image of windows to the clipboard as a PostScript drawing, but didn't need to use "PostScript capture" for that [below], because it represented drawings in its own format as a display list of PostScript data, that PostScript code interpreted to draw, and when you printed an image, it would just send a header with the drawing interpreter to the printer, followed by the drawing data and a call to the interpreter.

Maybe it was the speed of the structured drawing interpreter that people were complaining about. There is some overhead of course, but it's washed out by the fact that actually performing the drawing itself takes much more time than interpreting the data.

Or maybe you're thinking of "PostScript capture", which is effectively "partial evaluation" of arbitrary PostScript code, with respect to the imaging model (making paths, filling and stroking them, and rendering text)? You can efficiently implement PostScript capture without resorting to a metacircular evaluator, simply be redefining a few key operators like "fill", "stroke", "show", etc.

https://en.wikipedia.org/wiki/Partial_evaluation

PostScript capture is the technique of executing some arbitrary PostScript code that produces a drawing (which could be a traditional document in a PostScript file meant for the printer, or even a window system object like a menu), and capturing the drawing commands as another PostScript program, without any computation, conditionals, and loops. It would capture the effects of the drawing commands as another simple, flat PostScript program with all the conditionals and loops unwound (so a small recursive drawing procedure would produce an enormous flat drawing file, but most normal documents would be optimized to be smaller and even print faster), in the same global coordinate system, with unnecessary graphics state changes removed.

That's the essence of Adobe Acrobat's "Distiller", or Glenn Reid's "PostScript Distillery". I wrote distill.ps "in the spirit of Glenn Reid's Distillery" for PSIBER, and the NeWS Toolkit had its own /capture method built in, but they weren't actually used for much besides making a few illustrations.

https://medium.com/@donhopkins/the-shape-of-psiber-space-oct...

>Printing Distilled PostScript

>The data structure displays (including those of the Pseudo Scientific Visualizer, described below) can be printed on a PostScript printer by capturing the drawing commands in a file.

>Glenn Reid’s “Distillery” program is a PostScript optimizer, that executes a page description, and (in most cases) produces another smaller, more efficient PostScript program, that prints the same image. [Reid, The Distillery] The trick is to redefine the path consuming operators, like fill, stroke, and show, so they write out the path in device space, and incremental changes to the graphics state. Even though the program that computes the display may be quite complicated, the distilled graphical output is very simple and low level, with all the loops unrolled.

>The NeWS distillery uses the same basic technique as Glenn Reid’s Distillery, but it is much simpler, does not optimize as much, and is not as complete.

Here's more about the metacircular interpreter and distilled PostScript:

https://news.ycombinator.com/item?id=13705664

>What you've described sounds exactly like a PostScript interpreter! You can easily write a metacircular PostScript interpreter in PostScript!

http://www.donhopkins.com/home/psiber/cyber/ps.ps.txt

>And here is a PostScript quine:

    {{[ exch /dup load /exec load ] cvx} dup exec}

>If you wanted to produce "safe" PostScript file for printing, that used a standard header file and didn't require a Turing complete printer with loops, conditionals, functions, etc, you could write a partial evaluator for PostScript that projects it against the stencil-paint imaging model, optimizes the graphics, and prints out another "safe" PostScript program using a standard header, with all the loops unrolled and conditionals evaluated and functions called and graphics in the same coordinate system. That would enable you to capture anything you draw on the screen, independent of the PostScript algorithmic procedures and classes and libraries and application required to draw it.

http://www.donhopkins.com/home/psiber/cyber/distill.ps.txt

>Glenn Reid, who also wrote books on PostScript like Thinking in PostScript, pioneered that idea in his "PostScript Language Distillery", which is the idea that grew into PDF.

http://donhopkins.com/home/archive/postscript/newerstill.ps....

Glenn tells me that the PostScript distillery was actually John Warnock's idea!

I myself learned programming with logo, at my school when I was 8 or 10. And it was a delight, I am so grateful it existed.

But quite surprisingly, when later during my Ph.D. part of my time was dedicated to give exercises to students. And we used logo instead of the more usual programming languages. And I think it really helped them to really internalise programming a lot better. Typically, the latest exercices introduced recursion which is immediately visible as fractals.

    HIDETURTLE
    
    PENUP
    SETXY -200 0
    RIGHT 90
    PENDOWN
    
    to dragon :degree :size
        setpensize 1
        if :size>5  [setpensize 2]
        if :size>10 [setpensize 3]
        if :size>20 [setpensize 4]
        if :size>40 [setpensize 5]
        ifelse :degree=0 [
            fd :size
        ][
            left  45 dragon (:degree-1) (size/4)
            right 90 dragon (:degree-1) (size/2)
            left  90 dragon (:degree-1) (size/4)
            right 45
        ]
    end
    
    dragon 6 3000

if you want to give a try :)

I created logocode.dev for kids, but find myself playing with it occasionally - https://logocode.dev/

For many years, our students[0] have used Logo as an integral part of their math circle-style[1] classes. When we started Wally Feurzeig, one of the creators of Logo, was instrumental in helping us incorporate ideas from Logo into the kind of non-standard problem solving that we were striving for. Turtle geometry is a particularly helpful "instrument of the mind" for exploring dynamic geometry. Our co-founder, Victor Gutenmacher, wrote an incredible book[2] on "geometry in motion," which gave a completely different perspective on geometry from the one seen in school and which our students could explore with the help of Logo. For many of our students, especially those with math anxiety, Logo was what enabled them to overcome that anxiety and discover the joy of thinking and tinkering. Many programmers today have fond memories of getting into programming via Logo, but I would argue that despite the current blistering pace of progress, it remains one of the best and gentlest introductions to problem solving and computational thinking.

[0] https://www.gentleknowledge.com/

[1] https://en.wikipedia.org/wiki/Math_circle

[2] https://www.amazon.com/dp/0817641610

I still remember when we learned logo in elementary school. I had to get my mom to go out and buy a 3.5" disk so I could save my programs.

When I realized that all of logo was actually saved on that disk and I could continue playing with the turtle at home, I was amazed.

Drawing little things, realizing that I was repeating stuff and breaking it into little functions so I could draw them again more easily. I was learning the essentials of programming and didn't even realize it.

I'm forever grateful for having the access to Logo programming in early 90s, as a kid from a 3rd world country, for how it leads to where I am today.

My first ever english word that I can spell out is REPEAT.

I thought Logo was interesting because it translated the syntax (and errors) to the language of the programmer. Thereby it removed "learning English" as a prerequisite for learning programming.

https://apps.kde.org/nl/kturtle/ (in pretty much every linux distro) also brings that benefit (though the language is not exactly a LOGO clone).

This is on top of HN right now, and there is still nobody who has mentioned the fact that the tier-1 book Turtle Geometry <https://direct.mit.edu/books/oa-monograph/4663/Turtle-Geomet...> , is in open access.

Do yourself a favor, and read it today : it is that good. Even though it is quite depressing to see that the revolution in education that the book was predicting in its preface, simply never happened.

I didn't win logo programming competition in polish equivalent of 7th grade and I am still salty about it

One of my most vivid memories from my childhood (around 10 years old) is trying to make a ticking analog clock using Logo, with the turtle drawing all the hands.

We had "no screen in the morning" house rule - we had to eat, play outside first while it was not too hot. I woke up and realised what was wrong with my code. And my mum made an exception to the rule and the fix worked! I am so grateful to her for understanding the importance of the moment and allowing me to do the fix. I guess I'll give her a call and tell her the story now :) Thanks HackerNews!

Logo was created by by Seymour Papert. I highly recommend his book Mindstorms: https://en.wikipedia.org/wiki/Mindstorms_(book) It was written in 1980 but could have mostly been written today. All the same issues with teachers misunderstandings and fear of math and technology and refusal to change to meet the challenges of the age.

I couldn't be more grateful to my public school and my teacher for teaching us Logo in computer class on 486s.

For many of us, it was our first encounter with programming.

Kicked off so many memories...

Early 80's I learned Logo and Basic at a local store that sold Apple computers. It was called "The Logical Choice" and had a classroom tucked away behind a false wall and an English Sheep dog "Sir Isaac Newton" that would hang around the store!

Nice, I just found a story on the store, page 5 of [1].

[1] https://mirrors.apple2.org.za/ftp.apple.asimov.net/documenta...

Back in 1983, my elementary school was a part of a Logo pilot program. We had a lab of Commodore 64's that I had free run of (my mom was a teacher there), and it's why I do what I do all these years later.

What I find interesting it that it's not just programming, specifically. Logo is a highly interactive and dynamic language (a relative of Lisp), and that influenced the way I think about writing code. Seymour Papert did a lot for me, albeit highly indirectly.

https://mschaef.com/c64

LCSI LogoWriter for 68k Macs[0] was my shit. It was my first[1] introduction to programming in elementary school and I spent hours trying to make games with it. There were 4 turtles and you could treat them like sprites; you give them custom shapes and colours, and there were basic collision detection primitives. You could also check for collisions with the background by querying the colour under a turtle. You could play and record your own sounds... spent so much time with that little round Apple microphone[2] recording goofy sound effects.

[0] https://www.macintoshrepository.org/6717-logo-writer-2-0

[1] technically I had used the Apple II version a couple times first

[2] https://applerescueofdenver.com/products-page/macintosh-to-p...

My favorite logo on macOS is https://www.alancsmith.co.uk/logo/ First dabbled with logo on my apple ][, attracted by turtle graphics like many others.

Logo was my introduction to programming. Working on a 1 MHz Commodore64, my masterpiece was a fireworks show that was animated by the fact that the individual drawing commands were so slow you could watch them play out.

So, draw a curve from the ground to the sky. Draw some explosion shape. Change pen color to the sky color. Draw the curve and the explosion again to erase them. Change pen color and start the next firework.

Anyone here remember a 1980's Logo-programmable robot that I once used in a TAG program? It had a pen, we would lay it on top of a giant sheet of paper.

It was like a little futuristic tank. I searched for a minute, and I cannot find the exact model. Did I imagine this?

There is a wonderful offshoot of Logo for Agent Based Modeling https://www.netlogo.org/ where one can conduct all sorts of simulations involving many thousands of agents.

Logo is a real surprise if you revisit it as a grown professional. Remarkably elegant language.

During my PhD I used a agent based simulator called https://www.netlogo.org

Logo was just perfect for thinking in Agents

Few years ago I became interested in modelling complex societal and economic processes. That led me to discovering NetLogo, a multiagent-based programming and modelling environment derived from Logo. Can recommend! https://en.wikipedia.org/wiki/NetLogo

This on-line version of Logo is pretty great: https://www.calormen.com/jslogo/

I learned a little bit of logo, when I joined our school's computer club in 4th grade. A few years later, when I got my first own computer I was sad that it didn't have logo on it and no one I knew knew what logo was, let alone where to get it. So instead I turned to QBasic and other Basic dialects. I only got hold of a working logo much later again. I sometimes wonder what impact an earlier prolonged exposure to a lisp-like language would have had on my later programming career.

When I was seven I wrote my first program. It was in Terrapin Logo and evenly tiled the monitor of my elementary school's Apple IIe with hexagons.

It's been all downhill since.

As a child, I really enjoyed Logo. It appeared as a sidebar on a math textbook about angles and line segments. I studied it like I studied everything else in the textbook, but I didn’t immediately realize it was a programming language, a means to control a computer. Fast forward a few years in elementary school, when the teacher actually began to teach Logo with all students in front of a computer, it was such a profound revelation for me.

During the second Logo class, the teacher set up a competition. A prize was to be given to the student who could first plot an equilateral triangle, a square, a regular pentagon, a regular hexagon, etc, up to a regular icosagon. I won the prize because I wrote formulas to make the computer do the angle computation. I was so so proud of myself compared to my classmates who were computing angles with pen and paper. It felt like the first inkling of the power of automation.