An Implementation of J (1992)
jsoftware.com
jsoftware.com
I love being able to see an example and type it my editor in without having to switch back and forth a bunch of times because I forgot some syntax by the time I switched windows. Your data is a ball of dough and you can knead it into whatever shape you want with the primitives.
Even if I don't know what the symbols are, its still easier to remember because its less stuff you have to type in. Its a little bit of work up front to learn some of the verbs (why not use Anki and some mnemonics), but you really do have so much more room to think about the problem in your head. The compression is like a cool breeze on a hot summer day.
When when you have a problem that perfectly fits the bill, they are very good at it.
The problem is they are terrible at everything else. I/O, data validation, manipulation strings, parsing, complex logic trees...
So I feel like just like regexes, there should be an array language parser embedded in most languages, that you opt in locally for just this little nudge.
In Python, it would be nice to be able to "import j" like you "import re" in the sdlib.
The entire J code base, including utility scripts, a console, a stdlib and a regex engine, is 3mb.
April is this for Common Lisp: https://github.com/phantomics/april
Matrix vs Regex
--------------
A+B with A|B
A*B with AB
(1 - A)^{-1} with M*
import numpy as np
from scipy.sparse import csr_matrix, bmat
class NFA:
def __init__(self, T, S, E):
self.T = T; self.S = S; self.E = E
@property
def null(self): # Nullable?
return (self.S.T @ self.E)[0,0]
# --- 1. The Core Algebra ---
def disjoint(fa1, fa2):
""" Places fa1 and fa2 into a shared, non-overlapping state space. """
n1, n2 = fa1.S.shape[0], fa2.S.shape[0]
z = lambda r, c: csr_matrix((r, c), dtype=bool)
# Block Diag Transitions
chars = set(fa1.T) | set(fa2.T)
T_new = {}
for c in chars:
m1 = fa1.T.get(c, z(n1, n1))
m2 = fa2.T.get(c, z(n2, n2))
T_new[c] = bmat([[m1, None], [None, m2]], format='csr')
# Stack Vectors
S1 = bmat([[fa1.S], [z(n2,1)]], format='csr')
S2 = bmat([[z(n1,1)], [fa2.S]], format='csr')
E1 = bmat([[fa1.E], [z(n2,1)]], format='csr')
E2 = bmat([[z(n1,1)], [fa2.E]], format='csr')
return NFA(T_new, S1, E1), NFA(T_new, S2, E2)
def fork(fa):
""" Returns two references to the exact same machine. """
return fa, fa
def connect(fa1, fa2):
"""
The General "Sequence" Op.
Wires fa1.End -> fa2.Start, and updates Start/End vectors.
"""
# 1. Transitions: T_new = T_combined + (Bridge @ T_combined)
# Bridge = Start_2 * End_1^T
Bridge = fa2.S @ fa1.E.T
chars = set(fa1.T) | set(fa2.T)
T_new = {}
for c in chars:
# If fa1==fa2 (fork), this just gets fa1.T[c]
# If fa1!=fa2 (disjoint), this adds the non-overlapping blocks
m_comb = fa1.T.get(c, _z(fa1)) + fa2.T.get(c, _z(fa2))
# Apply the feedback/feedforward
T_new[c] = m_comb + (Bridge @ m_comb)
# 2. States: Standard Concatenation Logic
# S_new = S1 + (S2 if N1)
# E_new = E2 + (E1 if N2)
# Note: If fa1==fa2, this correctly computes S + (S if N) = S
S_new = fa1.S + (fa2.S if fa1.null else _z(fa1, 1))
E_new = fa2.E + (fa1.E if fa2.null else _z(fa1, 1))
return NFA(T_new, S_new, E_new)
# --- 2. The Operations (Now Trivial) ---
def cat(fa1, fa2):
return connect(*disjoint(fa1, fa2))
def leastonce(fa):
return connect(*fork(fa))
def union(fa1, fa2):
d1, d2 = disjoint(fa1, fa2)
chars = set(d1.T) | set(d2.T)
T_sum = {c: d1.T.get(c, _z(d1)) + d2.T.get(c, _z(d2)) for c in chars}
return NFA(T_sum, d1.S + d2.S, d1.E + d2.E)
def star(fa):
return union(one(), leastonce(fa))
# --- Helpers ---
def lit(char):
T = {char: csr_matrix(([True], ([1], [0])), shape=(2,2), dtype=bool)}
return NFA(T, _v(1,0), _v(0,1))
def one(): return NFA({}, _v(1), _v(1)) # Epsilon
def _z(fa, c=None): return csr_matrix((fa.S.shape[0], c if c else fa.S.shape[0]), dtype=bool)
def _v(*args): return csr_matrix(np.array(args, dtype=bool)[:, None])
# --- Execution ---
def run(fa, string):
curr = fa.S
for char in string:
if char not in fa.T: curr = _z(fa, 1)
else: curr = fa.T[char] @ curr
return (curr.T @ fa.E)[0,0]
if __name__ == "__main__":
# Test: (a|b)+ c
# Logic: cat( leastonce( union(a,b) ), c )
a, b, c = lit('a'), lit('b'), lit('c')
regex = cat(leastonce(union(a, b)), c)
print(f"abac: {run(regex, 'abac')}") # True
print(f"c: {run(regex, 'c')}") # False (Needs at least one a/b)I think Iverson had a good idea growing language from math notation. Math operations often use one or few letters - log, sin, square, sign of sum or integral. Math is pretty generic, and I believe APL is generic as well.
Sometimes you just need a little matrix shenanigans, and it's a shame to have to bring in a bazooka to get decent ergonomics and performances.
The tacit syntax is too idiosyncratic (I always forget the different types of verb trains) and I'm not entirely convinced it actually helped me as a "tool of thought" (but it might just be me not sticking with it long enough to be able to decode The Matrix).
I wish multidimensional arrays were a first-class citizen in my main languages though.
I felt compelled to make a comment about that last week[1]; I stopped thinking of it like "APL is a tool for thought [and nothing else is]" and started thinking of it like the Sapir-Whorf idea; all programming languages and mathematical notations are tools for thought and we don't normally talk about them like that. Their designs promote/encourage/ease some ways of thinking about problems and reveal some patterns in the data and the algorithms, and on the flip side by making design choices they necessarily demote/discourage/frustrate other ways of thinking and obscure some patterns.
It's not just that Go has Goroutines in it as a technical feature, it's that having a first class way to express that feature encourages Go developers to think about solving problems in terms of Goroutines. A bit like "if the only tool you have is a hammer, every problem starts to looks like a nail". But we still go down the direction of making a kitchen-sink language which has a bodge of half-implemented mismatched features from different areas wedged awkwardly into its syntax, and then saying "this company only does Java" or "only uses C++" instead of making smaller simpler tools that fit particular problems and working on ways to learn about them and integrate them.
> "I wish multidimensional arrays were a first-class citizen in my main languages though."
It has not helped you but you wish you had access to it because it's changed the way you think? Same; it has changed the way I think about bulk-transforming arrays of data, and using intermediate array structures, and thinking it's good to have an interpreter layer which transforms a whole array using SIMD/vector extensions instead of a loop which does individual non-SIMD tests on items so it can exit part way through the array to "save time".
This is so real. I had the same issue and was only able to break through by collabing with professional APLers. It's very non-ideal for the curious autodidacts.
I'd love to share, hone, and flesh out what the Tool of Thought looks like in practice with interested others. For anyone here to whom that sounds fun, feel free to reach out. Contact info is in my profile.
I usually show it to folks when it comes to code aesthetics. They end up in disbelief.
Less to type in when writing code and less to look at when reading code
"Why "J"? It is easy to type."
Terse languages are the best
Click on the show notes and there are links to previous episodes with him, talking about the J engine implementation, updates in J 9.03, threading and faster bignum calculations in J 9.04, updates in J 9.5, his views on tacit programming, etc.
That is an alarming statement, especially as the first line on the site.
> Words are expressed in the standard ASCII alphabet. Primitive words are spelled with one or two letters; two letter words end with a period or a colon. The entire spelling scheme is shown in the system summary. The verb ;: facilitates exploration of the rhematic rules. Thus:
;: 'sum =:+/_6.95*i.3 4'
┌───┬──┬─┬─┬─────┬─┬──┬───┐
│sum│=:│+│/│_6.95│*│i.│3 4│
└───┴──┴─┴─┴─────┴─┴──┴───┘
I'm already lost, and this is the first example.
And anyone reading this at the time would have been familiar with APL as well.
It's not intended to be beginner friendly. Like J, and like the original J dictionary, the values here are brevity, compactness, and essence. There is plenty of other more beginner friendly material on J out there.
"Ken Iverson - The dictionary of J contains an introductory comment that J is a dialect of APL, so in a sense the whole debate is Ken's fault! He is flattered to think that he has actually created a new language."
> This document describes an implementation of J in C. The reader is assumed to be familiar with J and C.
There have a been at least a couple attempts I've seen posted here of blog posts breaking down the code in a beginner friendly way. One I dug up is: https://blog.wilsonb.com/posts/2025-06-06-readable-code-is-u...
Related: https://needleful.net/blog/2024/01/arthur_whitney.html
I get it and I've heard it before, it's supposed to make it easier to fit more on one screen which is supposed to reduce cognitive burden. You are free to like what you like of course, but it just makes everything look like a jumble.
And even in a math context, I get frustrated if there's no simple glossary or surrounding prose to describe what's going on. Very few people write math this way, as a dense jumble of symbols. Even in the context of written mathematics, this is a very unusual style. I feel like J fans talk about it as if it's a totally normal thing to do if only you knew a little more math.
Yes, it's very unusual. I think the argument is more that there is a tradeoff, that "inflation" (whitespace, long names, multiple classes/files/etc) has a cognitive cost too even it it's more approachable, and that this other alien-seeming style can work very well for some people. There's a lot to love in the APLs even you ultimately don't buy the fanboy arguments, if only for the lessons of just how different the world can be.
(I say this as someone who got filtered by pure math!)