sbcl VS BQN

Based on the commit message [0], and the references to "user code" in this document, my guess is that user programs have or will have access, but it's not finalized enough to be documented.

That being said, I suppose if you're developing an internal API for a compiler/interpreter, your "users" could be other parts of the project rather than language users.

https://github.com/sbcl/sbcl/commit/7f65522a16d857e41aa61cd0...

related: the Immix inspired parallel-mark-region GC developed by Hayley Patton (https://github.com/no-defun-allowed/swcl) got merged recently into SBCL.

https://github.com/sbcl/sbcl/blob/master/doc/internals-notes...

https://applied-langua.ge/~hayley/swcl-gc.pdf

build with

    ./make.sh --without-gencgc --with-mark-region-gc (on x86-64/Linux and x86-64/macOS only at the moment).

The Immix inspired mark-region GC developed by Hayley Patton (https://github.com/no-defun-allowed/swcl) got merged recently, which is pretty cool news for SBCL users.

>Just like your usual hardware CPU cannot run Common Lisp directly, neither can WASM.

My usual hardware CPU runs Common Lisp code beautifully, thanks to this native x86-64 compiler: https://www.sbcl.org/

You can get SBCL for free which actually beats Lispworks on performance AFAIK: https://www.sbcl.org/

sbcl w/ linedit for repl/shell

I recommend checking BQN at https://mlochbaum.github.io/BQN/ and the YouTube channel code_report by Conor Hoekstra (and also "Composition Intuition by Conor Hoekstra | Lambda Days 2023"). It is well documented.

I don't put a lot of stock in the "write-only" accusation. I think it's mostly used by those who don't know APL because, first, it's clever, and second, they can't read the code. However, if I remember I implemented something in J 10 years ago, I will definitely dig out the code because that's the fastest way by far for me to remember how it works.

This project specifically looks to be done in a flat array style similar to Co-dfns[0]. It's not a very common way to use APL. However, I've maintained an array-based compiler [1] for several years, and don't find that reading is a particular difficulty. Debugging is significantly easier than a scalar compiler, because the computation works on arrays drawn from the entire source code, and it's easy to inspect these and figure out what doesn't match expectations. I wrote most of [2] using a more traditional compiler architecture and it's easier to write and extend but feels about the same for reading and small tweaks. See also my review [3] of the denser compiler and precursor Co-dfns.

As for being read by others, short snippets are definitely fine. Taking some from the last week or so in the APL Farm, {⍵÷⍨+/|-/¯9 ¯11+.○?2⍵2⍴0} and {(⍸⍣¯1+\⎕IO,⍺)⊂[⎕IO]⍵} seemed to be easily understood. Forum links at [4]; the APL Orchard is viewable without signup and tends to have a lot of code discussion. There are APL codebases with many programmers, but they tend to be very verbose with long names. Something like the YAML parser here with no comments and single-letter names would be hard to get into. I can recognize, say, that c⌿¨⍨←(∨⍀∧∨⍀U⊖)∘(~⊢∊LF⍪WS⍨)¨c trims leading and trailing whitespace from each string in a few seconds, but in other places there are a lot of magic numbers so I get the "what" but not the "why". Eh, as I look over it things are starting to make sense, could probably get through this in an hour or so. But a lot of APLers don't have experience with the patterns used here.

[0] https://github.com/Co-dfns/Co-dfns

[1] https://github.com/mlochbaum/BQN/blob/master/src/c.bqn

[2] https://github.com/mlochbaum/Singeli/blob/master/singeli.bqn

[3] https://mlochbaum.github.io/BQN/implementation/codfns.html

[4] https://aplwiki.com/wiki/Chat_rooms_and_forums

> Are there any other languages that use glyphs so heavily?

APL (the first, invented in the 1960s): https://en.wikipedia.org/wiki/APL_(programming_language)

BQN (a modern APL, looks like an inspiration for Uiua though I don't know): https://mlochbaum.github.io/BQN/

Too many smaller esoteric languages to count.

Vouch for array programming, but also BQN. Modern, very good documentation, a bit less confusing than APL imo.

There’s also at least BQN, which I suspect is the language used in those comments:

https://mlochbaum.github.io/BQN/

Well, a former Dyalog APL developer did go on to create his own language based on ideas from APL called BQN, which is touted as "an APL for your flying saucer"

The latest APL-INSPIRED and in my opinion, best array language, is BQN: https://github.com/mlochbaum/BQN