HN Theater @HNTheaterMonth

I didn't see it linked from the article, Jon Purdy has a great talk about this too: "Concatenative Programming: From Ivory to Metal" (2017) https://www.youtube.com/watch?v=_IgqJr8jG8M

There's also "A Conversation with Manfred von Thun" http://archive.vector.org.uk/art10000350 which is worth reading (IMO) if you're interested in concatenative languages. He's the creator of Joy.

I've been working with Joy over the last few years now and I really think there's something there. It seems to combine the best features of both Forth and Lisp.

⬐ adastra22

It’s still possible to work with Joy today?

⬐ carapace

The C source on the old site compiled and ran when I tried it: https://www.kevinalbrecht.com/code/joy-mirror/joy.html (mirror)

My own project is here: https://joypy.osdn.io/ It includes interpreters in Python, Prolog, and Nim (and a start on Rust) and some explorations of compilers and type inference/checking written in Prolog.

Hear, hear! Wise words from the genius who created Turing Drawings.

It's becoming more and more important to treat complexity as a kind of technical debt that has the potential at any moment to metastasize into eldritch horror.

I've been playing with what you could call a minimalist programming language: Joy created by Manfred von Thun (who was a philosophy professor! See "A Conversation with Manfred von Thun" http://archive.vector.org.uk/art10000350 ) It combines features of Lisp and Forth, and I suspect it may be the simplest useful language. The syntax is enormously simple, and the semantics are likewise simple. It's easy to reason about functions and derive them in a mathematical way using simple algebra, so it's hard to introduce bugs. I recently found a very good 2017 talk by Jon Purdy describing concatinative programming and it's quirks and (potential) advantages: Stanford Seminar - "Concatenative Programming: From Ivory to Metal" https://www.youtube.com/watch?v=_IgqJr8jG8M

Anyway, it's made me "allergic" to complexity. I tried Rust. Wrote the beginning of a Joy interpreter. I paused for a month and came back to it and it had become Greek to me, and I can't read Greek. :( Now part of that is just I 'm getting old, but a lot of it is the complexity of Rust.

I don't want to pick on Rust though, complexity itself is the enemy (Rust is, if anything, an improvement on most of what has come before it, eh? I think only Ada can really be said to be Rust's peer?)

⬐ pgtan

I see LOGO also as a kind of (lispy, interactive, left to right!) concatenative langugage. Here is an example, an ASCII christmass tree we made with the kid recently:

    ?  tanne.print tanne.output tanne.shift tanne.split 19 3 3 
             x
            xxx
           xxxx*
          oOOOx
           OxO
          ~oxoOox
         ~~o*o**O
        *o~*~x*OO
       x~Ox*x~~xOx*
        *~ox*x*O*O
       xO~ox~~*~
      oxoxxox~~xx**
     *O*o~OOo~*o**
    ~xOxOx~x*o*x*O
    

just putting something in between:

    ? tanne.print butlast tanne.output tanne.shift tanne.split 19 3 3 
          
         x*
        xxO*
       x*o*Oo
        oo*x
       o~ox~*x
      xOoOOOx*
     **o*xoo
    o***OO**x~

I don't know if it's Baader-Meinhof or what, but I'm seeing concatenative languages all over the place now. Which is great, because now I'm planning to write my own! My gut says that a concatenative language could be ideal for competitive programming, where you want to quickly apply various transformations to your input and immediately see the result.

Here's a talk I watched recently describing some of the neat mathematical properties of concatenative languages: https://www.youtube.com/watch?v=_IgqJr8jG8M

⬐ tluyben2

I implement small Forth-likes quite a lot, for instance [0].

I really like having something to explore 70-80s machines (other than Basic), hardware and systems that have no/bad Repls (like Xamarin). This kind of thing is ideal for that as it takes a really short time to implement, gives full and flexible access and it is fast enough to prototype things with.

[0] https://gist.github.com/tluyben/16ee2645c4c8aed813005d51488d...

Stanford EE380 talk by Jon Purdy:

  abstract: http://web.stanford.edu/class/ee380/Abstracts/171115.html

  slides: http://web.stanford.edu/class/ee380/Abstracts/171115-slides.pdf

  video: https://www.youtube.com/watch?v=_IgqJr8jG8M