What Is a Logo-Like Language? | Hacker News Reader

What Is a Logo-Like Language?

maxhallinan.com

72 pointsmaxhallinan37 comments

>Does this mean that the use of the language is more important than the language itself?

The answer is a resounding yes. C became popular because it is the native language of Unix. It was Rails that made Ruby popular. JavaScript is popular because it is implemented by all the browsers. Objective-C became popular because of iOS, and similarly with Swift. Visual Basic was one of the most popular languages for a time because it made Windows GUI programming easier. The ecosystem and use of a language is far more important than the language itself.

Objective-C became popular because it was the Mac language.

In the pedantic sense, Objective-C became popular because it was the NeXT language. But by the numbers, its massive popularity was due to the iOS app store gold rush, not NeXT STEP or MacOS or OS/X.

You quote a question about “importance,” then make a number of statements about popularity, then conclude something about importance.

It appears that you equate the two. And yet, others may have other definitions of “importance.” For example, Arguments can be made that Lisp, Smalltalk, and Haskell all have importance far greater than their popularity would indicate.

Does anybody still have a copy of the file from the MIT-AI Lab PDP-10 called "AI: HUMOR; LOGO TURTLE" or something like that? I haven't been able to find a copy myself, but I remember reading it and have confirmed that it existed, and that it was published in SIGART around 1982.

It was Leigh Klotz's sarcastic response to a Defense Department questionnaire to Terrapin about how their technology could be used to kill people.

He proposed deploying a swarm of thousands of LOGO turtles to crawl around the battlefield in mesmerizing geometric patterns, and stab the enemy with a quick succession of PENUP and PENDOWN commands (proving once again that the pen is mightier than the sword).

Cybernetic Zoo: A history of cybernetic animals and early robots: 1969 – The Logo Turtle – Seymour Papert et al (Sth African/American):

http://cyberneticzoo.com/cyberneticanimals/1969-the-logo-tur...

Logo's Yellow Turtle: First programmed in 1970. Built at MIT AI Lab:

https://www.youtube.com/watch?v=KeFhFPNO8hc

Logo Update, Volume 4, Number 3 - Spring 1996:

http://web.archive.org/web/20120904211432/http://el.media.mi...

The person I would ask is Brian Harvey, but that's just a guess. It sounds pretty funny regardless.

Good guess: I was just discussing it with Brian Harvey, Ken Kahn, Andrea diSessa, and Leigh Klotz, who said he has a copy, which I've asked him to please share! Then I saw this LOGO discussion. Plate of shrimp!

I love the great work Brian Harvey and Jens Mönig have done with Snap! It's like a non-watered-down version of Scratch, with the full power of Scheme (first class functions, lexical closures, special forms, continuations, build your own blocks, user definable control structures, extensible in JavaScript).

https://snap.berkeley.edu

Snap! 5 is here!

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

Here's the elegant Snap! visual Y Combinator:

https://imgur.com/cOq8tvR

Visual Lambda: Note how the gray block after the "report", shrink-wrapped around the "call (fn) with inputs (fn) []", is a visual "lambda". It looks like a "gasket" or "baggie" that insulates the code inside from being immediately evaluated, returning a closure instead.

Here's an excellent mind-blowing example by Ken Kahn of what's possible: teaching kids AI programming by integrating Snap! with existing JavaScript libraries and cloud services like AI, machine learning, speech synthesis and recognition, Arduino programming, etc:

AI extensions of Snap! for the eCraft2Learn project

https://ecraft2learn.github.io/ai/

>The eCraft2Learn project is developing a set of extensions to the Snap! programming language to enable children (and non-expert programmers) to build AI programs. You can use all the AI blocks after importing this file into Snap! or Snap4Arduino. Or you can see examples of using these blocks inside this Snap! project.

https://github.com/ecraft2learn/ai

http://lntrg.education.ox.ac.uk/presentation-of-ai-cloud-ser...

What's the difference between Snap! and Scratch?

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

LLOGO MACLISP sources with robotic turtle drivers:

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

>Here is the source code to LLogo in MACLISP, which I stashed from the MIT-AI ITS system. It's a fascinating historical document, 12,480 lines of beautiful practical lisp code, defining where the rubber meets the road, with drivers for hardware like pots, plotters, robotic turtles, TV turtles, graphical displays, XGP laser printers, music devices, and lots of other interesting code and comments.

https://donhopkins.com/home/archive/lisp/llogo.lisp

Oh wow. Thanks for sharing this stuff.

I have to confess, that function, even though I always call it Y when I write it so people will get what it's about, isn't a combinator at all. Writing a real Y combinator in an applicative-order language is possible but complicated, so I never do it. :-) (The difference is that this function takes a _two input_ function as input and supplies itself as its first input. Really it should take a one-input function and magick that into a two-input one first.)

So technically, that's a "Y Not-Combinator"?

LLOGO runs on a PDP-10 emulator, including the Knight TV display.

Video of LLOGO demo by Henry Lieberman: https://www.media.mit.edu/videos/144-lisp-logo-demonstration...

Python offers a nice Logo-like environment using "import turtle".

https://docs.python.org/3/library/turtle.html

That module is great fun to mess around with. I've made a program that uses it to plot the Python logo[1]. I had intended to also have it plot the correct gradient but I had trouble getting the trapezoid filling algorithm working correctly at the time.

[1] https://gist.github.com/SuperDoxin/d7bb473dcec7e1c55f48

Logo is actually more than just a toy language for turtle graphics. It's a serious language with a lot of inspiration from Lisp (although not using sexps).

I seem to recall at least one Logo I used as a kid had an "advanced mode" that in hindsight boiled down to S-Expressions and several more Lisp functions added to its standard library. Wish I could recall which Logo that was. Maybe one of the later LCSI builds (Apple Logo or IBM Logo), but possibly some version of Lego's TC Logo?

Doesn't look like IBM Logo, from a glance at the manual on my shelf. IBM Logo did have a `startup` feature, which Rebol and Red (pending security design issues) use, so you can pre-load things into your environment.

Have a look at Berkeley Logo, https://cs.berkeley.edu/~bh/logo.html

About S-expressions, you can fully parenthesize everything if you want. But Logo uses square brackets, not parens, as list delimiters, so you still have to do a little bit of tokenization.

Thanks for making your Logo books available!

As an example: NetLogo is most definitely not a toy language. Especially NetLogo3D. You'll see both of them in a lot of alife and ai demos.

The book Turtle Geometry [1] by Harold Abelson of SICP fame is a pretty cool exploration of mathematics all the way up to non-euclidean geometry using turtle graphics.

[1] https://www.amazon.com/Turtle-Geometry-Mathematics-Artificia...

I rewrote a Logo implementation in JavaScript in order to make a map of the train network in Taiwan.

http://peterburk.github.io/tra/

Existing maps were not bilingual, which caused me to take the wrong train and miss a concert. When I decided to redraw it, I wanted the map to not only have subway-style graphics, but also make the distance between the points be proportional to the time it takes a local train to travel between those stations.

If anyone else would like to use Logo to teach kids programming, and make time-proportional subway maps for other cities, please get in touch! I think it'd be a fun learning exercise.

Rebol and Red [1] are the only languages that I know which acknowledge having Logo heritage in their design and philosophy. Speaking from my experience, I can tell that working in them is indeed a deeply embodied microworld-like experience, they way author describes.

Manipulating homoiconic structures feels highly spatial, as if you're molding a clay with your own hands, or rather palpating the Urschleim. High polymorphism and rich standard library remove the mental burden and quite literally let you think in the language (hi mr. Iversion! [2]) and feel embodied in its runtime. Symbolic programming directly parallels the magic of natural language, its eerie occult power of controlling the world by non-physical means - remember how Sussman spoke about linguistic abstraction and magic incantations in SICP introduction?

In fact, in Red and Rebol everything is a little language (an embedded DSL), from metal to meta, and programs in them are this beautiful symbiogenetic ooze of micro-formats, slangs and linguistic DNA strands, from which your program slowly emerges [3]. Ultimately, you and your code become of one mind and body, stitched together by problem-solving intent. "I'm not moving the turtle, I am the turtle that moves!".

Even thinking about it gives me heebie-jeebies and brings to mind Tsutomu Nihei's Blame! [4] ever-growing City structure and Frictional Games' SOMA craziness [5]. Never experienced anything like that with any other programming language (except maybe for Forth and Lisp, but they are Red and Rebol ancestors too!).

On a slightly different note: there's a "Computer science Logo style" book series [6].

[1]: https://www.red-lang.org/

[2]: https://www.jsoftware.com/papers/tot.htm

[3]: https://meltingasphalt.com/a-codebase-is-an-organism/

[4]: https://myanimelist.net/manga/149/Blame

[5]: https://somagame.com/

[6]: https://mitpress.mit.edu/books/series/exploring-logo

Link 4 is broken. Thanks for insight!

HN ignored last exclamation mark for some reason, changed the link to MAL.

Anyone interested in checking out the MIT Press Exploring Logo books should check out bharvey's link, he's shared the first three books of the series (along with other good stuff) on his web page.

While Processing isn't logo-like in syntax it is logo-like in intention as in it tries to make it very easy for users to get graphics on to screen.

Processing is java-based, but it has spawned both a js verison 'p5.js' and a python version 'processing.py'.

https://processing.org/ https://p5js.org/ https://py.processing.org/

Logo's intention was not to make it easy to get graphics on the screen. Turtle Geometry is a mathematics made for learning. And it is only one part of the bigger picture of problem solving, using a computer both to solve problems, and to learn about how to solve them.

99% of logo users only drew imperative pictures, and that it why logo is famous.

Terrapin published my LOGO Adventure on the C64 LOGO Utilities disk as an example of a simple non-graphical game that showed off Logo’s list processing and functional programming capabilities.

https://medium.com/@donhopkins/logo-adventure-for-c64-terrap...

Paleotronic has ported it to their Apple Logo, which runs in their amazing 3D Apple ][ emulator!

https://paleotronic.com/2018/11/10/logo-adventure-for-apple-...

https://paleotronic.com/software/microm8/

Regarding

...the elements of a language are features of a world I inhabit:

Environments are values floating above my head. I have an urge to glance up when I’m thinking about what’s in scope. A closure is a one-way tunnel or pipe or wormhole back into the function environment. But the program itself can’t flow through the pipe. Asynchronous control flow is a stream that I imagine myself floating down. I think about where the stream will take me. Functors are giant structures, like a sculpture by Richard Serra. Functor operations act like cranes, helping me to move around those structures.

27 years ago I began working on a programming language in which computational abstractions had concrete animated analogs [1]. ToonTalk was my attempt to make a Logo for the 90s. You programmed in a virtual world where you trained robots to put things in boxes, give birds messages to deliver, etc. The mappings are: computation: city, actor or process or object: house, methods: robots, method preconditions: contents of thought bubble, method actions: actions taught to robot, tuples or messages or vectors: boxes, comparison tests: scales, actor spawning: loaded trucks, actor termination: bombs, constants: numbers, text, and pictures, channel transmit capabilities: birds, channel receive capabilities: nests, program storage: notebooks.

ToonTalk became free and open source 12 years ago. 5 years ago I had time to re-implement much of it as a web app [2]. But as Don Hopkins wrote - I'm focussed now on adding AI to Snap!

[1] http://www.toontalk.com [2] https://toontalk.github.io/ToonTalk/

We wrote a 3D version of Apple Logo [1] and we're going to be rolling out a tutorial for it for kids + running classes...

[1] https://paleotronic.com/software/microm8/help/micrologo/

I love your 3D Apple ][ emulator too!

https://paleotronic.com/software/microm8/

Logo appeared in a puzzle in this year's MIT Mystery Hunt: https://www.mit.edu/~puzzle/2019/puzzle/turtle_power.html

Fun puzzle. Took me back...

  I do not think of myself as a closure or a functor, unlike the Logo programmer and the turtle, but the elements of a language are features of a world I inhabit:

Here is the main difference between Logo and other languages. It’s called “Embodied Cognition” in academia.

It's a difference in programmers, at least. I do absolutely think of myself as a functor or closure, when I'm working at that level. (Dijkstra must be rolling in his grave.) Or a structure, moving through a queue, guarded by a serial dispatch queue ... I've realized a lot about data flow by being stuck in traffic.

My programs are apparently anthropomorphic, too: I start every new feature by adding "// TODO: i need ..." comments everywhere, and then go back and do what they say. Someone watching me once remarked that my program wrote itself.

Full disclosure: I learned Logo when I was young, and then Lisp as a teenager -- two of my first languages -- so perhaps I was infected from the start.

Now I'm kind of curious how else people think of programs. Do functions and objects not have a shape and position and rhythm? How do you model them? They're not literally just symbols, are they?

I remember code as places I've been (like a memory palace), that are connected to each other by the control and data flow. So my memories of old code are quite concrete, tangible, and first-person, and I can reconstruct the details and context by remembering the other places it was connected to, and my (the program counter's) journey from place to place that I took when I first encountered those locations (loci).

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

Ahhh... I remember LOGO on Apple ][e's Apple donated to the elementary school I attended.

Random Q: Why was that light on Apple's keyboard invariably uncomfortably hot?

Reply on news.ycombinator.com