I like that the article mentions Manfred von Thun, his iteration over FORTH was a joy to use, spent many hours writing code with it. It's a breeze. It was the true mirror reflection of Lisp in FORTH, and helps one reap the benefits of concatenation without getting bogged down in the nitty gritty details as one often ends up dealing with in FORTH, at least in the beginning until a mature vocabulary is built for the problem.

As I'm still so far behind in the LLM tech in terms of how it works, so I don't know what to think of this article, but my experience with using them as a user to generate FORTH code was often a failure. They just can't get it right, most likely due to lack of training data. OTOH, I also found writing FORTH as a human way more difficult than any other language I used, even more so than hand written assembly. But it amortizes itself fairly quickly, and things get a lot easier after a point (what I called earlier as vocabulary maturity). But more importantly writing FORTH code is way more fun and satisfying to me somehow.

From the title alone I tought it will be another FORTH interpreter implementation article, but I was happy to see someone actually using it for anything besides proving their interpreter with a Fibonacci calculation.

My own baby started out as a Forth dialect, but now sits somewhere between Logo and Common Lisp on the complexity scale. Forth is a good starting point imo, you don't waste any time on non essentials.

https://gitlab.com/codr7/shik

The observation that concatenative programming languages have nearly ideal properties for efficient universal learning on silicon is very old. You can show that the resource footprint required for these algorithms to effectively learn a programming language is much lower than other common types of programming models. There is a natural mechanical sympathy with the theory around universal learning. It was my main motivation to learn concatenative languages in the 1990s.

This doesn't mean you should write AI in these languages, just that it is unusually cheap and easy for AI to reason about code written in these languages on silicon.

Muxleq and Subleq:

https://github.com/howerj/subleq

https://github.com/howerj/muxleq

Muxleq because of performance:

      cd muxleq
      cc -O2 -ffast-math -o muxleq muxleq.c
    

Edit muxleq.fth, set these values like this:

    1 constant opt.multi      ( Add in large "pause" primitive )
    1 constant opt.editor     ( Add in Text Editor )
    1 constant opt.info       ( Add info printing function      )
    0 constant opt.generate-c ( Generate C code )
    1 constant opt.better-see ( Replace 'see' with better version )
    1 constant opt.control    ( Add in more control structures ) 
    0 constant opt.allocate   ( Add in "allocate"/"free" )
    1 constant opt.float      ( Add in floating point code )
    0 constant opt.glossary   ( Add in "glossary" word )
    1 constant opt.optimize   ( Enable extra optimization )
    1 constant opt.divmod     ( Use "opDivMod" primitive )
    0 constant opt.self       ( self-interpreter [NOT WORKING] )

Then run:

./muxleq ./muxleq.dec < muxleq.fth > new.dec

new.dec it's the enhanced SUBLEQ EForth image.

To run it:

      ./muxleq new.dec

For the available words, run

      words

inside the interpreter.

Enter

      bye

to exit.

Get Starting Forth but the ANS version (there's some PDF in search engines) and Thinking Forth.

Diffusion text models to the rescue! :)

Looking to discuss with people about whether LLMs would do better if the language had properties similar to postfix-notation.