
History of Logo - lelf
https://escholarship.org/uc/item/1623m1p3
======
chrisdone
There's a StrangeLoop talk about teaching programming by Felienne Hermans
([https://www.youtube.com/watch?v=g1ib43q3uXQ](https://www.youtube.com/watch?v=g1ib43q3uXQ))
that claims that all fields have an "exploration vs instruction" debate on how
to teach their field, but this debate is apparently absent from the field of
programming for the most part, wherein the "mess around and figure it out"
exploration style of LOGO and Papert ("every time you teach something, you
deprive a [student] of the pleasure and benefit of discovery") is the
predominant unquestioned wisdom. Felienne wants more pedagogy fights. It's a
worthwhile talk. I love LOGO and I think our generation of programmers are
very sympathetic Papert's philosophy due to most of us being self-taught to
some degree (you can see the fond nostalgia already on display in the comments
here), but Felienne made me think about it more critically.

~~~
rzzzt
OT, but Felienne has a great talk on functional programming in Excel (thanks
for reminding me of her name):
[https://www.youtube.com/watch?v=0yKf8TrLUOw](https://www.youtube.com/watch?v=0yKf8TrLUOw)

~~~
kjs3
This is worth watching even if you hate Excel and FP. It's a view of a
different way of thinking. Good stuff.

------
DonHopkins
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](https://donhopkins.com/home/archive/lisp/llogo.lisp)

Lars Brinkhoff got some of this code to run in MacLisp on an emulator! (I
don't know how much of the historical hardware the emulator supports yet, but
he's probably worked on some of that too. ;) )

[https://github.com/PDP-10/its/issues/620](https://github.com/PDP-10/its/issues/620)

Thanks to Lars, here are two revisions of an AI Lab memo about LLOGO:

[http://bitsavers.org/pdf/mit/ai/aim/AIM-307.pdf](http://bitsavers.org/pdf/mit/ai/aim/AIM-307.pdf)

[http://bitsavers.org/pdf/mit/ai/aim/AIM-307a.pdf](http://bitsavers.org/pdf/mit/ai/aim/AIM-307a.pdf)

And a Logo manual and glossary of PDP-11 Logo:

[http://bitsavers.org/pdf/mit/ai/aim/AIM-313.pdf](http://bitsavers.org/pdf/mit/ai/aim/AIM-313.pdf)

[http://bitsavers.org/pdf/mit/ai/aim/AIM-315.pdf](http://bitsavers.org/pdf/mit/ai/aim/AIM-315.pdf)

[http://bitsavers.org/pdf/mit/ai/aim/AIM-315a.pdf](http://bitsavers.org/pdf/mit/ai/aim/AIM-315a.pdf)

~~~
larsbrinkhoff
Also running on the emulator: PDP-10 Logo, PDP-11 Logo, Applle II Logo.

The emulator doesn't support the robot arm yet.

~~~
klotz
Thank you for doing this, Lars, and thank you for all the amazing historical
research and preservation you are doing on the PDP-10 and the origins of
operating systems, Lisp, Logo, symbolic math Macsyma, and all of the software
and system zeitgeist that produced Logo. We always felt like we were packaging
up what our AI lab hacker culture was like, in "mind-sized bites" as Seymour
said.

~~~
larsbrinkhoff
Thanks for the kind words! I'm grateful for the quirky, fun, and interesting
work and research that was done, and glad it much of it has been preserved.
(Also sad some of it has been lost.)

------
kilbuz
When I was in elementary school in the 80s, someone in our district retrofit a
school bus with two rows of computers running along the sides. The bus would
travel to each school in the district once a month or so. We would all walk
out to the parking lot, board the bus, and use Logo. It was probably the first
exposure to a computer most of the kids in my class had, and I have never
forgotten it.

~~~
DonHopkins
A Logomobile!

[https://www.amazon.com/Turtle-Bus-Window-Sticker-
Decal/dp/B0...](https://www.amazon.com/Turtle-Bus-Window-Sticker-
Decal/dp/B013F0JQYM)

Could they program the computers inside the bus to drive it around, like Robot
Odyssey? ;)

[https://en.wikipedia.org/wiki/Robot_Odyssey](https://en.wikipedia.org/wiki/Robot_Odyssey)

[https://slate.com/technology/2014/01/robot-odyssey-the-
harde...](https://slate.com/technology/2014/01/robot-odyssey-the-hardest-
computer-game-of-all-time.html)

[https://www.robotodyssey.online/](https://www.robotodyssey.online/)

I suppose there could be a downside to that:

[https://www.vaildaily.com/news/photos-turtle-bus-rescued-
by-...](https://www.vaildaily.com/news/photos-turtle-bus-rescued-by-crane/)

------
mimixco
LOGO changed my life! When I learned it as a kid, it made me realize that
software was "castles in the sky" and you could do anything you want. 41 years
later and a career programmer, I'm now using Lisp in our most modern product.
:-) I'll always be grateful to Papert for his work in creating and teaching
LOGO.

~~~
klotz
Which version of Logo and which Lisp? Have you read SICP? Hal Abelson is
responsible for getting Logo out of MIT and into the world of the Apple II,
and with GJS for SICP. Logo and Lisp connections go way back though, to it's
inception with BBN and MIT people.

~~~
mimixco
As a kid, the library had a TI-99/4A with its LOGO and a book by Papert
included. I remember it had the most documentation of any piece of software
for the machine, which intrigued me. They also had a Coleco ADAM that had
LOGO, too, so I used both.

Today, we use SBCL to power a Lisp backend for our product that communicates
with an Electron HTML/JS frontend via WebSockets. (See Nebula[0])

[0]
[https://news.ycombinator.com/item?id=23043417](https://news.ycombinator.com/item?id=23043417)

------
ken
Logo was a hard pill to swallow in the 1980's. It had some neat features 'on
paper' but it was hard to appreciate them because it was agonizingly slow on
the computers of the day.

It was the first programming experience I ever had where I'd type in my
function, and then had to wait a while for the computer to do something to it
(it never used the word "compiler"), and then it could run. I remember
thinking: this makes programming not-fun. I could write it in assembler faster
than I'm waiting for the "...." to dance across the screen.

~~~
kjs3
I honestly can't think of anything more "missing the entire point" of a
language like Logo than "I could write in assembler faster...".

~~~
ken
I was maybe 8 or 9 at the time. I guarantee I missed 'the point' of a lot of
things at that age! Shoot me.

Even today, though, if you told me there was a great new programming language,
but I had to wait _a minute_ every time I made a change before running my
program, I don't imagine I'd be terribly excited to learn it.

Right next to this on HN is a 2014 article by WalterBright that reports
"compiler speed matters a lot". What's the last compiler you used that spent
60 seconds compiling a single file?

~~~
DonHopkins
>What's the last compiler you used that spent 60 seconds compiling a single
file?

Unity3D C# => CIL => il2cpp => emscripten => WebAssembly. ;(

Nowadays, we compile a single file with many compilers. And you change one
line, then you have to recompile and repackage the whole chain.

------
DonHopkins
Seymour Papert, introducing "The Turtle":

[https://www.youtube.com/watch?v=-V_OPfmbbCk](https://www.youtube.com/watch?v=-V_OPfmbbCk)

[https://www.youtube.com/watch?v=fTO-Ruby-
Uo](https://www.youtube.com/watch?v=fTO-Ruby-Uo)

[https://www.youtube.com/watch?v=CJlRGe5QGhs](https://www.youtube.com/watch?v=CJlRGe5QGhs)

~~~
mimixco
Just that first video alone introduces and explains several key programming
concepts: imperative programming with its hidden state and implicit
instruction order, procedure calls with parameters, and operator-operand
syntax -- all without ever having brought up any of that.

------
nicetryguy
Aaaand once again Gary Kildall gets left out of history. While CEO of Digital
Research, the largest software company in the world at the time (besides IBM),
he did an entire implementation himself! DR Logo had some innovative graphical
features.

[https://www.youtube.com/watch?v=l4P6MDuk3Zk](https://www.youtube.com/watch?v=l4P6MDuk3Zk)

~~~
klotz
Gary Killdall tried to buy Terrapin. It was unfavorable terms and I didn't
agree. He went away mad and wrote something in C an implementation of what
looked like Logo but I don't know how he choose to implement it. I remember
him talking about structs of various sorts at one point, instead of using
lists so I assume he was concerned about efficiency. I never had a discussion
with them about their interest in pedagogy so I can't comment.

------
jecel
In 1983 I and Fabio Cunha designed a Logo computer with the 6809 processor:
[http://www.merlintec.com/lsi/pegasus.html](http://www.merlintec.com/lsi/pegasus.html)

The project evolved into a more advanced 68000 based Smalltalk computer, but I
regretted not finishing and releasing the original machine as years later I
saw what schools in Brazil were doing with MSX Logo and such. The big mistake
in the design was using the same chipset as the TRS-80 Color Computer which
had a bunch of needless text and low resolution modes but no nice high
resolutions ones.

------
manaskarekar
My first exposure to computers was through Logo in 1992!

Thinking back, it was really effective in grabbing your attention and making
you want to experiment with different commands!

This is a good reminder that Logo is still a great teaching tool, especially
for kids.

I suppose python + turtle can replicate the effect to some degree as well.

[https://docs.python.org/3/library/turtle.html](https://docs.python.org/3/library/turtle.html)

------
DonHopkins
Also thanks to Lars Brinkhoff's research:

Here's a video uploaded by Cynthia Solomon. Seems legit.

[https://www.youtube.com/watch?v=c4kMzrDr4jQ](https://www.youtube.com/watch?v=c4kMzrDr4jQ)

Definitely check out the rest of Cynthia Solomon's youtube video treasure
trove, with lots of great stuff by Marvin and Margaret Minsky, Seymour Papert,
and others from MIT and Atari Cambridge Research:

[https://www.youtube.com/user/cynthiaso/videos](https://www.youtube.com/user/cynthiaso/videos)

Seymour Papert on Logo, Turtles and Giraffes:

[https://www.youtube.com/watch?v=maDzjHIiXZc](https://www.youtube.com/watch?v=maDzjHIiXZc)

[https://www.youtube.com/watch?v=lDyym_9-E-g](https://www.youtube.com/watch?v=lDyym_9-E-g)

[https://www.youtube.com/watch?v=ha8sTgtUejM](https://www.youtube.com/watch?v=ha8sTgtUejM)

A gestural programming system developed by Margaret Minsky, Danny Hillis,
Daniel Huttenlocher, David Wallace (Gumby), and Radia Perlman at the MIT-AI
Lab:

[https://www.youtube.com/watch?v=-Wq6SQTVM9M](https://www.youtube.com/watch?v=-Wq6SQTVM9M)

Marvin Minsky demonstrating a Logo Machine with an acoustic modem and cassette
tape, talking about education theory, and showing a part of his first
"thinking" machine: a simulated nerve synapse (1 of 40) with an adjustable
knob that he built in 1951 out of WW-II surplus hardware, and discussing
playing with Tinker Toys as a child:

[https://www.youtube.com/watch?v=c4kMzrDr4jQ](https://www.youtube.com/watch?v=c4kMzrDr4jQ)

[https://www.youtube.com/watch?v=S72xF3gd-
mI](https://www.youtube.com/watch?v=S72xF3gd-mI)

[https://www.youtube.com/watch?v=yZRQQl8mA0c](https://www.youtube.com/watch?v=yZRQQl8mA0c)

[https://www.youtube.com/watch?v=dfKRNHRyD64](https://www.youtube.com/watch?v=dfKRNHRyD64)

David Levitt demonstrating his musical improvisation software:

[https://www.youtube.com/watch?v=ocwsVkqEKys](https://www.youtube.com/watch?v=ocwsVkqEKys)

------
lou1306
One of Logo's derivatives, NetLogo [1], seems to be pretty popular among
academics as an agent-based modeling tool. It also has a neat browser
interpreter. Worth a look, IMO.

[1]:
[http://ccl.northwestern.edu/netlogo/](http://ccl.northwestern.edu/netlogo/)

~~~
_reza
Santafe institute's 'Introduction to Complexity' online course uses NetLogo to
run simulations.

------
catketch
This was an interesting read. I grew up with early personal computers of the
eighties and in the geographic area described in the history, so a lot of it
is nostalgic. At that time, programming on early home computers generally
meant using BASIC (and maybe poke’ing some assembly code) before getting into
“real” languages like pascal, Fortran and c in college. I remember thinking
logo was a ‘baby’ language and only for kids—-it wasn’t until later on I
appreciated some of its features and it’s ties to lisp.

Programming languages like REBOL (or the modern variant Red [http://www.red-
Lang.org](http://www.red-Lang.org)) seem to build on many of the same ideas.

~~~
timbit42
Yes, REBOL was created by Carl Sassenrath, a fan of Lisp, who after writing
much of the Amiga operating system, wrote Amiga Logo and then REBOL.

------
LargoLasskhyfv
Off topic: This site has a very nice UI. No frills. Almost soothing. Now i
have to read that, and the rest of the site has moved to the top of my
Tsundoku stack because of that. Does anybody else feel like that, too?

~~~
tingletech
Thanks! My group at work produces that site [0], and our design group [1]
worked on the UI too.

[0] [https://cdlib.org/services/pad/](https://cdlib.org/services/pad/) [1]
[https://cdlib.org/services/uxdesign/](https://cdlib.org/services/uxdesign/)

~~~
LargoLasskhyfv
I really like it. It is so unobtrusive. At first i've been surprised because i
disabled in-browser Pdf-reading, but it almost looked like a pdf-reader. All
proportioned and positioned just right, no fiddling necessary. And not laggy
either. This is how it should be! (For me.)

~~~
tingletech
it is a pdf reader, our own fork of PDF.js
[https://github.com/eScholarship/pdfjs-
embed2](https://github.com/eScholarship/pdfjs-embed2)

~~~
LargoLasskhyfv
I wondered about that, since the original document obviously was a pdf.
Anyways, doesn't matter because _your_ fork did the right thing for me on 24"
@1920x1200, while i've been up for about 7 hours, reading and beginning to
feel a little tired. When i came across your's it _eased_ me into focus.
Again: This is how it _should_ be!

~~~
LargoLasskhyfv
edit: i should add i know both the internal ones of Firefox, and Chromium.
They usually don't work for me, that is why i disabled them, apart from the
usual cargo-culting paranoia to only open documents with native applications
;)

------
soperj
Logo was definitely my introduction to programming. Never thought of it as
programming. Lots of fun. We tried to make an animation with it as a kid.

------
AstroJetson
I love Logo. On of the best program was TLC Logo ( The Lisp Company 1983).
They had added some extensions that made it even more powerful. The Book,
Thininking about TLC logo with the Turtle cartoons (by Allen, Burke, Johnson)
was super easy to learn. It's a shame it never made it to the PC stage.

------
__david__
I couldn't stand Logo as a child--my entire childhood goal was to make a video
game and Logo was just so slow. Turtle graphics made certain things easy
(drawing circles) but there was no way to get some animated sprites on the
screen. I pretty much instantly recognized this and stubbornly decided it was
toy language for babies.

It wasn't until years later that I realized that Logo had a bunch of neat
fundamentals (like functions, which were totally foreign to BASIC-fluent me).
It's a shame it wasn't more attractive to a kid like me.

------
pgtan
Logo rules big times!

~~~
crznthndr
Even in 2020, I was pleasantly surprised that my kids school teaches Logo at
the elementary school level! However, I had a hard time convincing parents who
were suggesting it to be replaced with Python or a more modern programming
language :(

~~~
new2628
There's some merit to both sides. As a kid in the eighties, I remember being
annoyed by Logo -- it seemed a toy, and even as I child I wanted to learn the
tools with which "real programs" (mostly games) could be written.

~~~
DonHopkins
Snap! has the full power of Scheme (first class functions, user defined
blocks, recursion, closures, continuations, JavaScript integration, etc), with
a visual block syntax and playful graphical environment with turtle graphics
like Scratch.

The following post is a couple years old, but maybe somebody can provide some
updates and recent info!

Edit: I should have RTFA first, which is totally up to date, just published in
2020, from the turtle's mouth:

[https://escholarship.org/uc/item/1623m1p3](https://escholarship.org/uc/item/1623m1p3)

>Brian Harvey’s Personal Narrative on Snap!: Scheme Disguised as Scratch

>In 2009, the University of California, Berkeley, was one of several
universities developing a new kind of introductory computer science course,
meant for non-CS majors, to include aspects of the social implications of
computing along with the programming content. Scratch wasn’t quite expressive
enough to support such a course (it lacked the ability to write recursive
functions), soProf. Daniel Garcia and I thought “What’s the smallest change we
could make to Scratch to make it usable in our course?” After 20 years
teachingStructure and Interpretation of Computer Programs[Abelson et al.1984],
the best computer science text ever written, I knew that the answer to “what’s
the smallest change” is generally “add lambda.” I joined forces with German
programmer Jens Mönig, who had developed BYOB (Build Your Own Blocks), an
extension to Scratch with custom (user-defined) blocks, including reporters
and predicates. [...]

[https://news.ycombinator.com/item?id=17594403](https://news.ycombinator.com/item?id=17594403)

DonHopkins on July 23, 2018 | parent | favorite | on: Ask HN: Best Lego
Mindstorms alternative for fun p...

One of the coolest ways to learn programming I've ever seen is the Snap!
visual programming language, which is written in JavaScript and runs in the
browser. [https://snap.berkeley.edu](https://snap.berkeley.edu)

It's the culmination of years of work by Brian Harvey and Jens Mönig and other
Smalltalk and education experts. It benefits from their experience and expert
understanding about constructionist education, Smalltalk, Scratch, E-Toys,
Lisp, Logo, Star Logo, and many other excellent systems.

Snap! takes the best ideas, then freshly and coherently synthesizes them into
a visual programming language that kids can use, but is also satisfying to
professional programmers, with all the power of Scheme (lexical closures,
special forms, macros, continuations, user defined functions and control
structures), but deeply integrating and leveraging the web browser and the
internet (JavaScript primitives, everything is a first class object,
dynamically loaded extensions, etc).

Y Combinator demo:

[https://i.imgur.com/cOq8tvR.png](https://i.imgur.com/cOq8tvR.png)

[https://snap.berkeley.edu/snapsource/snap.html#present:Usern...](https://snap.berkeley.edu/snapsource/snap.html#present:Username=jens&ProjectName=y%20combinator)

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/](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](https://github.com/ecraft2learn/ai)

[http://lntrg.education.ox.ac.uk/presentation-of-ai-cloud-
ser...](http://lntrg.education.ox.ac.uk/presentation-of-ai-cloud-services-
integrated-with-snap-at-the-connective-ubiquitous-technology-for-embodiments-
center-of-the-national-university-of-singapore-and-keio-university-
on-16-march-2017-by-k/)

Use devices with Snap!:

Orbotix Sphero guide by Connor Hudson and Dan Garcia:

[https://docs.google.com/document/d/11wR53OTnofRtTtxZCmxnCUjI...](https://docs.google.com/document/d/11wR53OTnofRtTtxZCmxnCUjIlFQjnGewM21A0vmjtFw/edit?usp=sharing)

Lego NXT package by Connor Hudson:

[https://github.com/technoboy10/snap-nxt](https://github.com/technoboy10/snap-
nxt)

Nintendo Wiimote package by Connor Hudson:

[https://github.com/technoboy10/wiisnap](https://github.com/technoboy10/wiisnap)

Finch and Hummingbird robots package by Tom Lauwers:

[https://www.hummingbirdkit.com/learning/snap-
programming/](https://www.hummingbirdkit.com/learning/snap-programming/)

Parallax S2 robot package by Connor Hudson:

[https://github.com/blockext/s2](https://github.com/blockext/s2)

LEAP Motion by Connor Hudson:

[https://github.com/technoboy10/snapmotion](https://github.com/technoboy10/snapmotion)

Speech synthesis by Connor Hudson:

[https://github.com/technoboy10/snap2speech](https://github.com/technoboy10/snap2speech)

Arduino package by Alan Yorinks:

[https://github.com/MrYsLab/s2a_fm](https://github.com/MrYsLab/s2a_fm)

Arduino package by Bernat Romagosa/Citilab:

[http://snap4arduino.rocks/](http://snap4arduino.rocks/)

Fischertechnik ROBOTICS TXT Controller by Richard Kunze:

[https://github.com/rkunze/ft-robo-snap](https://github.com/rkunze/ft-robo-
snap)

Snap! for Raspberry Pi by rasplay.org:

[http://downloads.rasplay.org/pisnap/](http://downloads.rasplay.org/pisnap/)

More Snap! extensions for CS education:

snap-apps.org provides Edgy for graphs, Cellular for multi-agent simulation,
and more.

[http://snap-apps.org/](http://snap-apps.org/)

[http://www.snap-apps.org/edgy.html](http://www.snap-apps.org/edgy.html)

[http://www.flipt.org/#cellular](http://www.flipt.org/#cellular)

Netsblox for multiplayer networking.

[https://netsblox.org/](https://netsblox.org/)

~~~
bharvey
Thanks for the kind words both about Logo and about Snap!. That article is in
fact not yet officially published, but if I'm reading the ACM legalbol
correctly, authors are allowed to put an "author's last draft" version on
their institutions' web archives, so that's what you found.

The article has eight authors, and of course the time required to write
something is \Theta(n^2) in the number of authors, so it was a long slog,
although worth it because in between yelling at each other we had some great
conversations about education and computers and Logo technology.

I am inordinately proud of Snap!, which is almost entirely the work of Jens
Mönig. My big contribution was to talk him into lambda. (Coming in the next
version: APL-style vector and matrix operations. After that we just have to
find a way to shoehorn in Prolog and we'll be the unification (pun not
intended) of all the good programming languages.)

~~~
DonHopkins
Hey, how about throwing in a perverted, fetishistic, masochistic programming
language like FORTH, too? ;)

Where do you think Logo and Snap fit into the three basic mental structures of
psychosis, perversion, and neurosis, as W Watson describes in "The Pervert's
Guide to Programming Languages"?

[https://news.ycombinator.com/item?id=22910702](https://news.ycombinator.com/item?id=22910702)

[https://www.youtube.com/watch?v=mZyvIHYn2zk](https://www.youtube.com/watch?v=mZyvIHYn2zk)

[https://s3-us-west-2.amazonaws.com/vulk-
blog/ThePervertsGuid...](https://s3-us-west-2.amazonaws.com/vulk-
blog/ThePervertsGuidetoComputerProgramming-ThePaper.pdf)

I have hope that Snap! has transcended the self-indulgent Turing Tarpit of
Melancholy Languages like Scheme, Lisp (which spawned Scheme during a
hysterical event), Smalltalk, and languages that never were, as described on
the penultimate page. ;)

Snap! strikes me more as a Hysterical language, frantically pursuing the
object of desire, in pursuit of the perfect syntax.

>Hysterical Languages: Hysterical development lends itself to languages that
facilitate endless refinements in the code base. The delivered code is never
good enough, not merely because of pragmatic reasons but often because of
ascetic reasons. The final goal of capturing the elusive domain jargon [59]
seems just around the corner, where just one refinement may perfectly
represent the domain. Within the hysterical languages there can be two
extremes. One extreme is to work towards the capability to easily represent
any aesthetic. In this extreme the work and enjoyment are in the development
of the language itself [60]. The other extreme is to consciously implement the
aesthetic using the language as is [61]. This extreme bends the language to
look more aesthetically pleasing. Somewhere in between are refinements to
extremely large code bases that must stay available.

>[59] “The overhead cost of all the translation, plus the risk of
misunderstanding, is just too high. A project needs a common language that is
more robust than the lowest common denominator. With a conscious effort by the
team, the domain model can provide the backbone for that common language,
while connecting team communication to the software implementation. That
language can be ubiquitous in the team’s work.”, Evans, Eric (2003-08-22).
Domain-Driven Design: Tackling Complexity in the Heart of Software (Kindle
Locations 829-832). Pearson Education. Kindle Edition.

>[60] “Also, I’m a great fan of evolving as opposed to just starting out new.
You might fall in love with one particular idea, and then in order to
implement it, you go create a brand-new language that’s great at this new
thing. Then, by the way, the 90% that every language must have, it kind of
sucks at. There’s just so much of that, whereas if you can evolve an existing
language — for example, with C# most recently we’ve really evolved it a lot
toward functional programming — it’s all gravy at that point, I feel.”,
Biancuzzi, Federico; Chromatic (2009-03-21). Masterminds of Programming:
Conversations with the Creators of Major Programming Languages (Theory in
Practice (O'Reilly)) (Kindle Locations 7017-7021). O'Reilly Media. Kindle
Edition.

>[61] “A big part of the modus operandi of the Ruby community is a more fluent
approach— trying to make interacting with a library feel like programming in a
specialized language. This is a strand of thinking that goes back to one of
oldest programming languages, Lisp.”, Fowler, Martin (2010-09-23). Domain-
Specific Languages (Addison-Wesley Signature Series (Fowler)) (Kindle
Locations 473-475). Pearson Education (USA). Kindle Edition.

~~~
toontalk
Regarding hysterical languages and aesthetics there is the school of thought
that small yet very expressive kernels are the most aesthetic. I recall a
discussion in the early 1980s with Alan Perlis who claimed APL was a diamond
and Lisp was a ball of mud. But it is easier to make things out of mud than
diamonds. I also recall a discussion with Seymour Papert (circa 2005) about
the next generation Logo. He claimed that one first needs to decide if the
design should be driven by engineering or mathematical aesthetics. Sadly,
there never was much progress designing the next Logo.

People's taste in programming languages is coloured by their first
language(s). But Logo was designed to be a first language, so it shouldn't
suffer from people's expectations that it do things like other languages.

------
DonHopkins
Lars Brinkhoff suggests that this thread comp.lang.logo with Brian Harvey and
Leigh Klotz is required reading:

[https://groups.google.com/forum/#!topic/comp.lang.logo/UqOvE...](https://groups.google.com/forum/#!topic/comp.lang.logo/UqOvEkZsJEQ)

Just a couple highlights from a detailed history of Logo that Brian and Leigh
and others posted:

>From Brian Harvey:

>Many, many people have been involved in the development of Logo.

>Wally Feurzeig started the whole thing by organizing a group at Bolt,
Beranek, and Newman, Inc., to study the educational effects of teaching kids a
programming language. The first language they used, like most programming
languages, was focused on numeric computation, and it was Wally's idea that
kids would find it more natural to work in an area they knew better, namely
natural language; therefore, he set up a team to design a language featuring
words and sentences. Wally made up the name "Logo."

>The team Wally put together at BBN included Seymour Papert and Dan Bobrow.
The three of them are credited as the designers of the first version of the
language; Dan wrote the first implementation. In a BBN report dated August,
1967, credit for additional work is given to Richard Grant, Cynthia Solomon,
and Frank Frazier.

>Seymour later started a Logo group at MIT, where Logo development continued.
The MIT versions of Logo were substantially different from the BBN ones, both
in the notations used and in the things the language could do. Most notably,
turtle graphics was added at MIT.

>Among the many people who contributed to the development of Logo at MIT, at
the risk of leaving someone out, are Hal Abelson, Paul Goldenberg, Dan Watt,
Gary Drescher, Steve Hain, Leigh Klotz, Andy diSessa, Brian Silverman... oh,
lots of people.

>I think that most of the early documents are out of print now, but whatever
documentation there is of the early efforts will be in the form of technical
reports from BBN and from MIT. You may have to visit Cambridge to find them!

>From Leight Klotz:

>In the mid 1970's, when the AI Lab Lisp Machine project was just getting
underway, Marvin Minsky and Danny Hillis (later to found Terrapin, and still
later, Thinking Machines) put together a project to build a Logo machine. It
had two components: a PDP-11 processor (the 3500) and a separate vector-
graphics display (the 2500). Guy Montpetit, a Canadian entrepeneur, funded
development eventually, and a company called General Turtle was formed.
General Turtle built and sold the 2500/3500 system. Henry Minsky, then about
12, worked on the design of the 2500, using the Stanford Draw program, one of
the early electronics CAD systems. (The 2500 had this really great barrell
shifter stolen from the Lisp machine design, but it was later found not to
work, so it was never used.) [...]

>[...] Like Brian, I've left out many people who worked on Logo over the
years: Brian Fox and Flavio Rose worked for me at Terrapin on a contract basis
briefly, as did vagabond programmer Devon McCullough (who used to dial in with
a 300 baud modem he'd written in entirely software using the parallel game
port, with an 80-column mixed-case display done with 3x5 pixel characters;
when the modem detected the call waiting click on the line, it would make the
Apple II speaker make the telephone ringing sound -- a feature which I just
saw a US patent filed on, not by Devon.), and the frustrated Sinclar QX
programmer, who I suspect doesn't want his name used. Of course, there were
tons more people at the AI Lab in the pre-commercial days...

>From Lars Brinkhoff

>Hello,

>I'm mostly researching PDP-10 software, especially MIT's Incompatible
Timesharing System.

>I have recently stumbled across some of the LOGO group work. I have a copy of
the Dazzle Dart game that ran on their PDP-11/45\. It uses the Tom Knight
vector display controller, so it's not easy to run it.

>Maybe it would be possible to get the original MIT PDP-11 LOGO running.

>[...] It's running now.

>[...] Now also BBN PDP-10 Logo, MIT CLOGO, MIT Lisp Logo, and hopefully soon
MIT Apple II Logo (direct ancestor of Terrapin Apple II Logo).

------
DonHopkins
Terrapin Logo for the Apple ][ and C64 came with a 6502 assembler written in
Logo by Leigh Klotz, that they used to write Logo primitives (for controlling
the turtle, etc).

It would be ambitious to make a self hosting 6502 Logo meta assembler, by
porting the entire 6502 assembly language Logo source code to the 6502 Logo
Assembler!

Leigh, wasn't the assembler that you used for the original Apple ][ version of
Logo written in MacLisp running on a PDP-10?

The Apple II Source Code for the LOGO Language Found (adafruit.com) 379 points
by mmastrac on Oct 4, 2018 | hide | past | web | favorite | 89 comments

[https://news.ycombinator.com/item?id=18142287](https://news.ycombinator.com/item?id=18142287)

[https://blog.adafruit.com/2018/10/04/the-apple-ii-source-
cod...](https://blog.adafruit.com/2018/10/04/the-apple-ii-source-code-for-the-
logo-language-found/)

Lars: The link in the article to the code from
[https://github.com/PDP-10/its](https://github.com/PDP-10/its) is broken. I
found a few references to it in the repo. Did you have to take it down, or did
you move it somewhere else?

[https://github.com/PDP-10/its/blob/a5694acbf9b6185a36d18d226...](https://github.com/PDP-10/its/blob/a5694acbf9b6185a36d18d22631914ac40605d6b/doc/logo.md)

>Logo

>"I too see the computer presence as a potent influence on the human mind. I
am very much aware of the holding power of an interactive computer and of how
taking the computer as a model can influence the way we think about ourselves.
In fact the work on LOGO to which I have devoted much of the past years
consists precisely of developing such forces in positive directions."

>Seymour Papert

>"Logo is the name for a philosophy of education and for a continually
evolving family of computer languages that aid its realization."

>Harold Abelson

>"Historically, this idea that Logo is mainly turtle graphics is a mistake.
Logo’s name comes from the Greek word for word, because Logo was first
designed as a language in which to manipulate language: words and sentences."

>Brian Harvey

>Logo was initially created by Wally Feurzeig, Seymour Papert, Daniel
G.Bobrow, Cynthia Solomon and Richard Grant in 1967 as part of a National
Science Foundation sponsored research project conducted at Bolt, Beranek &
Newman, Inc., in Cambridge, Massachusetts. In 1969 Dr. Seymour Papert started
the Logo Group at the MIT Artificial Intelligence Lab. Throughout the 1970s
the majority of Logo development was conducted at MIT in the Artificial
Intelligence Lab and the Division for Study and Research in Education, using
large research computer systems, such as ITS powered PDP-10.

>Our goal is to make that early Logo systems available to a wider audience of
enthusiasts for exploration, experimenting and, of course, hacking.

[...]

>MIT APLOGO

>In accordance with Leigh L Klotz Jr., Hal Abelson directed the Logo for the
Apple II project at MIT.

>MIT APLOGO was developed by Stephen Hain, Patrick G. Sobalvarro and Leigh L
Klotz Jr. It was developed and cross-compilled for the Apple-II-Plus Personal
Microcomputer on PDP-10 at the MIT LOGO Group. It is direct predecessor for
Terrapin Logo. We have a source code for assembling an improved version from
7/9/81 at its/src/aplogo

~~~
klotz
Quite the resource list, Don! You should put in links to the Adventure game
you wrote for the C64 Logo, and we listed you by name and age.

The assembler was already chosen, probably by Steve Hain or Gary Drescher. I
believe it was CROSS. It annoyed me that I would get phase errors if I edited
during the first pass which was like 10 or 15 minutes at night so I wrote a
one-pass assembler in MacLisp, but it was slower to finish than the first pass
of CROSS so I translated it to Logo and Hal said to put it on the utilities
disk. I can't remember who added .output and .input but Logo had had them
before the Apple II, I think 11Logo had it.

~~~
DonHopkins
So CROSS made you so cross that you crossed the line by rewriting it in
MacLisp, then double crossed it by rewriting it in Logo itself!

Logo Adventure for C64 Terrapin Logo

When I was 17, Terrapin published my first commercial code on their C64 Logo
utilities disk: a Logo Adventure program, 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...](https://medium.com/@donhopkins/logo-adventure-
for-c64-terrapin-logo-4c684a240b53)

