From Eric Iverson:

Roger Hui passed away peacefully on Saturday afternoon, October 16, 2021.

He had a several year struggle with cancer and was in a hospice with his
hands held by his wife Stella and their children Rachel and Nicholas.

Roger created J with Ken and made major contributions to APL. But all that
has been farthest from my mind the last 24 hours. What I think about is the
joy I saw when watching Ken and Roger together. I remember Ken telling me
how Roger asked if it would be OK to bring his girlfriend to dinner with
Ken and Jean. And how they were surprised by the coincidence that her name
was Ken's mother's name. No one was surprised by the integrity and
soundness of the family that he and Stella made.

Yes, Roger was a coder extraordinaire. But what was important is that he
was a rock solid good person. His calm and measured way in life and in his
last years should be a model to all.

Version 1.1 https://trygnuapl.github.io

User interface and other enhancements are described

on the project page https://github.com/trygnuapl/trygnuapl.github.io

Sad news from Eric Iverson on the J forums:

The forum is about J, not people. But sometimes someone is so exceptional that they break this mold.
Elijah Stone is one. His contributions to the J community started in 2021 when he was 19. He gave the best answers to forum questions ever. He went on to make serious contributions to the J Engine. And J was just a tiny part of his full life. Watching him walk down a street, you realized his real interest was dance, not math.

Elijah was magical, smart, witty, graceful, gentle, and very private.

Elijah passed away on September 9th.

Our condolences to his family, partner, and all who will miss him.

We have just completed the first episode of the Array Cast, a podcast all about the Array Programming languages. Hosted by Conor Hoekstra, with co-hosts Adám Brudzewsky (APL), Stephen Taylor (APL, q), and Bob Therriault (J), this bi-weekly podcast will cover developments in the array programming paradigm. For the first episode, the topic is 'Why We Like the Array Programming Languages'. It is currently available to download from the arraycast.com website and within the next day or two should be available on iTunes and other podcatchers of your choice. Give it a listen and let us know what you think at [email protected] or @arraycast on Twitter.

Without going into too much detail to spare those who want to do it themselves, I'll just say that the first day's problems were crying out for an array language solution.

What's more, as is so often the case with problem-solving in APL and its descendants, a conceptually similar problem had a natural, similar solution. In this case, the second half of the problem was a natural progression from the first, but would been a non-trivial twist in most other languages I know. Not J, though. Hats off once again to this wonderful language.

The team at Monument has created something remarkable: composable multi-threaded concurrency, 100% compatible with the J language jsoftware.com. We've called it Jx, or the "Monument engine."

It's perfect for the rapid algorithmic development that we've performed at Monument, and we're interested in hearing feedback. Developers get to use all CPU cores, simply and elegantly, with functions they compose. You can try it right now at Monument https://www.monument.ai/m/parallel.

We'd love to hear your feedback and experience. Please email us with questions and comments at [email protected].

In our third episode, we look at the challenges that are delaying the popularity of the array programming languages. Host: Conor Hoekstra Panel: Nick Psaris, Adám Brudzewsky, and Bob Therriault. Audio, Transcripts and Show Notes at Arraycast.com

On this episode of Array Cast we spoke with Marshall Lochbaum about his new array language BQN, a language he calls 'an APL for your flying saucer'. This episode gets pretty deep so don't forget that there are show notes that give background on many of the concepts. https://www.arraycast.com/episodes/episode-07-marshall-lochbaum-and-the-bqn-array-language

Hey everyone, our next episode of Array Cast is out and it is an interview with J's own Henry Rich. You can access it at the website https://www.arraycast.com/episodes/episode-06-henry-richs-deep-dive-into-j Unfortunately, I messed up the publishing so that if you already have a repeat of episode 5 with episode 6 then you will need to delete it and download again and the new version should be the interview with Henry. I think it is our best episode yet!

Today's xkcd contains a (goofy) algorithm that struck me as having a particularly natural expression in J's syntax.

NB. https://xkcd.com/2435
mean =: +/%# NB. Arithmetic mean
geom =: mean&.:^. NB. Geometric mean
median=: <.@-:@# { /:~ NB. Median

f =: mean , geom , median
gmdn =: [: {. f (^:_)

gmdn 1 1 2 3 5 NB. 2.08906

e: Fixed &.: on line 3

New version of Juno - online IDE for J language - is now available at https://jsoftware.github.io/juno/app/ featuring:

• no installation - Juno runs locally in any modern browser

• view of current workspace showing user-defined entities with visualization

• visual debugger of J sentences - Dissect

• code sharing (besides script uploading and saving) by generating a link to Juno which encapsulates your code.

Check out all the features in the lab in the right panel entitled Do you know Juno?

Happy coding!

Message from Eric Iverson http://jsoftware.com/pipermail/programming/2021-June/058312.html

I am pleased to announce that the RayforceDB columnar database, developed in Lynx Trading Technologies, is now an open source project.

RayforceDB is an implementation of the array programming language Rayfall (in the same way that kdb+ is an implementation of k/q), which inherits the ideas embodied in k and q. However, RayforceDB uses Lisp-like syntax, which, as our experience has shown, significantly lowers the entry threshold for beginners and also makes the code much more readable and easier to maintain. However, the implementation of k syntax remains an option for enthusiasts of this type of notation.

RayforceDB is written in pure C with a minimum of external dependencies, the executable file size does not exceed 1 megabyte on all platforms (tested and actively used on Linux, macOS, and Windows), and the executable file is the only thing you need to deploy to get a working instance. Additionally, it is possible to compile to Webassembly and run in a browser. However, in this case, automatic vectorization is not available.

RayforceDB was developed by a company that provides infrastructure for the most liquid financial markets. As you might expect, the company has extremely high requirements for data processing speed. The effectiveness of the tool can be determined by visiting the following link: https://rayforcedb.com/content/benchmarks/bench.html

The connection with the Python ecosystem is facilitated by an external library, which is available here: https://raypy.rayforcedb.com

RayforceDB offers all the features that users of columnar databases would expect from modern software of this kind. Please find the necessary documentation and a link to the project's GitHub page at the following address: http://rayforcedb.com

I am interested in books on mathematics, specifically those using or based on APL. I’ve come up with the below list (only including APL books, not J). Are there any that I am missing that should be on the list that I don’t know about? – or any that shouldn’t be on the list?

[EDIT: (Thank you, all, for all the additions!) Add them, in case anyone searches for this; AMA style for the heck of it; add links to PDFs where they look legitimate; otherwise Google Books page; remove pointless footnotes]

• Alvord, L. Probability in APL. APL Press; 1984. Google Books.

• Anscobm, FJ. Computing in Statistical Science through APL. Press; 1981. Google Books.

• Helzer, G. Applied Linear Algebra with APL. Springer New York; 1983. Google Books.

• Iverson, KE. Algebra: An Algorithmic Treatment. APL Press; 1977. PDF.

• Iverson, KE. Applied Mathematics for Programmers. Unknown; 1984.

• Iverson, KE. Elementary Algebra. IBM Corporation; 1971. PDF.

• Iverson, KE. Elementary Analysis. APL Press; 1976. Google Books.

• Iverson, KE. Elementary Functions: An Algorithmic Treatment. Science Research Associates, Inc; 1966. PDF.

• Iverson, KE. Mathematics and Programming. Unknown; 1986.

• LeCuyer, EJ. Introduction to College Mathematics with A Programming Language. Springer-Verlag; 1961. PDF.

• Musgrave, GL, Ramsey, JB. APL-STAT: A Do-It-Yourself Guide to Computational Statistics Using APL. Lifetime Learning Publications; 1981. PDF.

• Orth, DL. Calculus in a new key. APL Press; 1976. Google Books.

• Reiter, CA, Jones, WR. APL With a Mathematical Accent. Routledge; 1990. Google Books.

• Sims, CC. Abstract Algebra: A Computational Approach. John Wiley & Sons; 1984. Google Books.

• Thompson, ND. APL Programs for the Mathematics Classroom. John Wiley & Sons; 1989. Google Books.

I'm trying something new here. Programming a little text editor in J. It's live on twitch right now if anyone wants to drop by, and I'll record the stream for later as well.

https://www.twitch.tv/tangentstorm

Update: wound up recording for 5 hours straight. The full recording is up on YouTube now:

https://youtu.be/4RAv8K4w66c

Covers my terminal mode UI framework and then dives into actually working on the editor component.

J, APL and q all have slightly different approaches to the way that they deal with arrays. In this episode we explore those differences.

Host: Conor Hoekstra Panel: Nick Psaris, Adám Brudzewsky, and Bob Therriault.

Episode download, Show notes and transcript available at https://www.arraycast.com/episodes

In our second episode, we pay tribute to the life of Larry Breed, find out that we really don’t need loops to write computer programs, and get some tips on the best ways to go about learning the array programming languages. Host: Conor Hoekstra Panel: Stephen Taylor, Rich Park, Bob Therriault.

For more information go to https://arraycast.com/episodes

I’m hosting a Reddit AMA (Ask Me Anything) on November 13th, 2025, where I will be answering all your questions about KDB/Q, the world’s most powerful time-series database and array programming language.

Over the years, I’ve received countless messages about:

• 💡 How to start learning KDB/Q

• 🚀 Career paths and progression in the KDB/Q ecosystem

• 📚 Best learning resources and study plans

• ⚙️ Real-world applications and architecture insights

So instead of replying to everyone one by one, let’s bring it all together. The AMA will run for 24 hours, and you will be able to ask your questions completely anonymously.

Looking forward to hearing from you all!

Alex - DefconQ

P.S. I forgot to mention, that all answers shared during this AMA reflect solely my own personal thoughts and opinions, and are not representative of any past, current, or future employers or affiliations.

Hello, Iversonians (and the rest)!

I started documenting my work on Fluent, an array-oriented language I've been building for the New Kind of Paper project. Few salient features:

1. Every operator is user-(re)definable. Don't like writing assignment with `←`, change it to whatever you like. Create new and whacky operators – experiment to the death with it.

2. Differentiability. Language is suitable for machine learning tasks using gradient descent.

3. Strict left-to-right order of operations. Evaluation and reading should be the same thing.

4. Words and glyphs are interchangeable. All are just names for something. Right?

5. (Pre,In,Post)-fix. You can choose style that suits you.

Some whacky examples:

; pre-, in-, post-
(
  1 + 2,
  1 add 2,
  add(1,2),
  +(1,2),
  (1,2) . +,
  (1,2) apply add,
  1 . +(2),
  +(1)(2)
),

; commute
(
  ↔︎ : {⊙ | {x,y| y ⊙ x}},
  1 - 2,
  1 ↔︎(-) 2,
  1 (- · ↔︎) 2
),

; gradient
(
  f ← { x | x ^ 2 },
  g ← ∇(f),
  x ← (1 :: 10),
  ( f(x), g(x) )
)

Most of this work was done 2 years ago, but recently I started to look into it more. Mainly to document it, but I forgot how fun it was hacking on it. I'll definitely add some visualizations and more editor goodies like automatic word-to-symbol translation.