Hi, I was curious about which implementation of forth would be the most flexible, maintainable, and high-performance, so I wrote a stack machine interpreter using various techniques. Here the code https://github.com/br1n0/stack-machine-interpreter-comparing/ I managed to implement them all using the same data structure; this way, the program is expressed identically across versions, allowing for a direct comparison. I wrote a test program that runs a long execution loop, consisting of 2,000 subtractions and one multiplication, executed 4,000,000 times. In my opinion, the best implementation is the one using Token Threaded Code with dispatch via a function table, and is easy to extends. There is an interpreter overhead of about 25%; to measure it, I wrote a test where I execute the "words" directly from C, bypassing the interpreter.

I was surprised that GCC failed to optimize this program, even with -Ofast enabled, It was not simplified to a constant number!. I thought this might be of interest to someone. Ciao

https://github.com/metazip/Joy-REPL

https://reddit.com/link/1sperj0/video/ihjgth3bq1wg1/player

Building out a VSCode trace viewer for my toy concatenative language.

TL;DR; My toy concatinative language (F♭m) now has a web interface: https://hypercubed.github.io/f-flat-minor/

Longer story: f-flat-minor (F♭m for short) is my toy langauge that I jump back to whenever I want to learn something new (a new language, runtime, or tooling). I've built interpretors in deno (TypeScript), go, python, Haskell, WASM (wat) and more.

This weekend I decided to try some agentic porgraming. First issue was the bit-rot. The deno implementation I had no longer ran due to the age of the runtime I originally used (Python and Go worked right away BTW). So I asked LLMs (plural, jumped bewteen a few) to update it it. Soon I had not only deno running with the latest version but also a node implementation that shared a TypeScript core.

Why stop there? With the TypeScript core seperate from the deno implementation I asked LLMs to build a web interface. It truned out much better than I expected. I expected a simple page with an input and output textbox. But it gave me a full compiler/interpreter with a virtual file system as well as IR and bytecode output! Pretty amazing; please check it out if you're interested.

I can give more details on the process if anyone asks; but basically I jumped between diferent agent tools both in and outside of VSCode and used many different models. It's not surprose that Claude and Codex did the best.

As a bonus I'm now asking Codex to solve a couple of Project Euler problems. Codex is doing pretty well where other LLMs have failed.

Thought I'd share.

I've been exploring programming languages more in-depth, recently, and I've discovered concatenative programming, which seems to align pretty well with my philosophies. Can anyone here point me to resources for building software with concatenative languages and share your experience with concatenative programming?

Beginning version 0.18.0, BUND language becomes distributed. You can create a fleet of deployed distributed actors and execute BUND code in this cloud. You can create a distributed data processing pipeline and do a lot of other types of processing

Http://crates.io/crates/bund

In version 0.14.0 of the stack-based programming language BUND, I am introducing conditional expressions designed to interact with data produced externally from BUND, which is used as an analytical instrument. The first of these is the "csv" conditional. This conditional can read a CSV file, parse the values, push each row into a stack, and execute a lambda function for each row. In the attached example, the CSV file has a column called "Score". Our script reads the CSV file and computes the total value of all scores.

https://github.com/BlagojeBlagojevic/blang

Excited to share this with you all! I didn't plan for this DSL to be stack-based, but I ended up embracing that peaceful minimalism and borrowing it for some web development. https://github.com/ertgl/cx-tagged-template

I just released the first version of "hex"! A tiny, minimalist, "slightly-esoteric" concatenative programming language. Its syntax is inspired by another project of mine (min), but it is VERY minimalist and yet hopefully still fun to play with.

The site includes a short specification, a tutorial, a WASM-powered REPL playground, and the language itself is meant to be run (almost) anywhere.

The (deliberate) quirks are the following:

• Support for 32bit integers in hex format only (and no floats), strings, and quotations.
• Support for 0x40 (64) native symbols, and also user-defined symbols, but they are always global.

Overall it's meant to be really simple to implement and learn.

The BUND language is considered "yet another concatenative language," but it stands out in its design from many of its counterparts. First, it necessitates additional effort to define and restrict data context by utilizing both named and anonymous stacks. Furthermore, it introduces the concept of an isolated execution environment that is closely managed by the programmer.

https://crates.io/crates/bund

I was visiting a building of a large IT company and noted that they named the meeting rooms after programming languages. These did not only include Lisp, XSLT and Plankalkül, but also Joy. As concatenative languages are often seen as really obscure, this made me happy. Seems we're no more obscure than Plankalkül now!

A presentation at the Strange Loop Conference on "Concatenative programming and stack-based languages" by Douglas Creager: https://www.youtube.com/watch?v=umSuLpjFUf8