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.
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.
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...
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).
Snap! 5 is here!
https://news.ycombinator.com/item?id=20309162
Here's the elegant Snap! visual Y Combinator:
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.
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.
[1] https://www.amazon.com/Turtle-Geometry-Mathematics-Artificia...
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.
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/
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/
...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/
[1] https://paleotronic.com/software/microm8/help/micrologo/
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:
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?
Random Q: Why was that light on Apple's keyboard invariably uncomfortably hot?