You know that feeling where you feel like you have a good handle on things- maybe it's foundational mathematics, or the fundamentals of computer software.
And you start reading something so incomprehensible that you start to wonder if there's just this universe hiding in plain sight directly under the universe you've always known.
That is the precise feeling I get when I trying to understand this post.
Don't get me wrong, I appreciate the exposure, but damn if I'm not sweating trying to understand why this all matters.
I know exactly how you feel. Looks like it was 10 (?!) years ago [0]
> Ah, APL/J/K. Time for my annual crisis of thinking everything I've ever learned about programming is wrong...
Still, though, I'm always happy when it comes up on HN for a little discussion. As I recall there were a couple people working on a new OS or something based on K, I think. I wonder whatever happened to that.
As for this particular post, I get how `x^x*/:x:2_!100` works now (it's cute!), but it seems pretty wasteful. It's generating 10,000 products to filter out of the list of 100 integers. But 99 x 99 isn't anywhere near a number in the original 2..100 list! You only need to go up to 2 x 49, 3 x 33, etc. I wonder if there's more of a "triangular" shape you could generate instead of the full table.
the first few paragraphs lay out the precise extent to which this matters. there's a snippet of code (`x^x*/:x:2_!100`) in a language (k7) using a feature ("rank-sensitive" set difference) not present in previous langs (before 2019); the prev langs' workaround (razing `,/` the table into a list) is bothersome (to chrispsn) so his article examines some alternatives.
chrispsn is sharing the map he drew of the rabbit hole he explored. it involves a lot of haggling with "depth", which is when you nest a list in another list: good for organizing your data, but bad for producing long vectors over which your programs could vectorize. so if you want this to matter more broadly, you can consider it a meditation on some of the mechanics of that, i.e. how to flatten some deep constructions in algorithms, and how to generalize shallow operations to apply at depth
Yeah, array language syntax just breaks my brain. I'm sure given enough time I could get the hang of it, but I'm also pretty sure I'll never put in the time
As far as I can tell, it seems to be something halfway between TempleOS and MUMPS but its a programming language instead of an OS. I don't think you are missing some deep meaning. Its more that this is written in an esoteric language which seems to be more overloaded than Perl by someone who maybe isn't so great at clear communications. He's just looking at ways to make more efficient code in K (the language). But it does look sort of like he is talking about math theorems (he isn't).
> more overloaded than Perl by someone who maybe isn't so great at clear communications.
I have the same feeling. The root of K is APL, but to avoid special characters (I assume), the same symbol has multiple meanings (overloaded), depending on eg. the position, the data type, and the context. The idea is that "programs should be short enough to fit in your head." The challenge is, similar to Perl and Regex syntax, it's very hard and often cryptic to read.
I do think a concise syntax is useful, for a programming language. But at the same time, the syntax should be readable, and that probably means that each symbol or operator must only have one meaning, and that meaning should be (more or less) obvious.
K is an array language. Even an integer is actually an array of one element. I think that makes sense for a tiny language: This is the simplest possible type system. You can even support strings, when using eg. metadata or using a heuristic like "a string is always zero terminated" (which is what I used for my tiny language).
It's clear that the symbols want to have one meaning each, for monadic and dyadic use, but that might mean quite different execution and types.
For example, & is monadic 'where' and dyadic 'min' (a logical extension of it being AND on bit-booleans), but this means you get different semantics, even if they all capture the 'where'-ness:
1 3 ~ &0 1 0 1 / when applied to a list, gives the indices of true elements
`b`d ~ &`a`b`c`d!0 1 0 1 / when applied to a dict, gives their keys
In both cases, you get that `x@&x` works, as `&x` will yield appropriate indices for `x`, but what that actually does has changed. In other languages, these would be spelled very differently, and so do seem like an overload, but sometimes it is just a point of view.
As for why it's obvious- it's not, really, but it's no less obvious than the word `where`, and you have already learnt it, as it is (as it seems to me at least) to be punned on the C syntax (same as `*`, which gives `first`).
> by someone who maybe isn't so great at clear communications
I don't think that's fair. If you're familiar with the programming language, his writing is fairly clear. If you're not, maybe you're just not in his target audience.
IOW, optimizing his text for people familiar with the language is probably a better choice than teaching the language, which would distract him from his goal.
Sad that the Wikipedia page links to some specific commercial service rather than the actual programming language runtime (which appears to be AGPL-licensed).
I think of K like a super-geeky version of Excel, for people who do quant stuff. People do very useful, cryptic stuff in convoluted, bespoke Excel sheets, updated and grown over decades with 37 variants of almost-but-not-quite the same VB function, etc. I imagine the K world is very similar, except K users can meet in London pubs and trade little snippets of K handwritten on scraps of paper between them like Pokemon cards.
You know that feeling where you feel like you have a good handle on things- maybe it's foundational mathematics, or the fundamentals of computer software.
And you start reading something so incomprehensible that you start to wonder if there's just this universe hiding in plain sight directly under the universe you've always known.
That is the precise feeling I get when I trying to understand this post.
Don't get me wrong, I appreciate the exposure, but damn if I'm not sweating trying to understand why this all matters.
> Range is just shallow odometer: ![3]~*!,3.
Ah of course, of course. Trivially, even. Who are we to question the shallow odometers, really?
I know exactly how you feel. Looks like it was 10 (?!) years ago [0]
> Ah, APL/J/K. Time for my annual crisis of thinking everything I've ever learned about programming is wrong...
Still, though, I'm always happy when it comes up on HN for a little discussion. As I recall there were a couple people working on a new OS or something based on K, I think. I wonder whatever happened to that.
As for this particular post, I get how `x^x*/:x:2_!100` works now (it's cute!), but it seems pretty wasteful. It's generating 10,000 products to filter out of the list of 100 integers. But 99 x 99 isn't anywhere near a number in the original 2..100 list! You only need to go up to 2 x 49, 3 x 33, etc. I wonder if there's more of a "triangular" shape you could generate instead of the full table.
[0] https://x.com/losvedir/status/636034419359289344?s=20
Also, how could any sane person ever go into the ngn/k source and find the mentioned implementation? https://codeberg.org/ngn/k/src/commit/ddcc17511ff05e1915f59b...
I don't even want to learn k, I want to learn how to handle such C.
For a smaller example, try the J Incunabulum[0] various explanations are available [1][2]
It's been discussed here before too.
[0] https://code.jsoftware.com/wiki/Essays/Incunabulum [1] https://blog.wilsonb.com/posts/2025-06-06-readable-code-is-u... [2] https://tony-zorman.com/posts/j-incunabulum.html
I like the quote about how different programming languages give you tools to think in different ways.
I get the impression languages like k are a good example of this. (That C code looks as dense/concise as k).
the first few paragraphs lay out the precise extent to which this matters. there's a snippet of code (`x^x*/:x:2_!100`) in a language (k7) using a feature ("rank-sensitive" set difference) not present in previous langs (before 2019); the prev langs' workaround (razing `,/` the table into a list) is bothersome (to chrispsn) so his article examines some alternatives.
chrispsn is sharing the map he drew of the rabbit hole he explored. it involves a lot of haggling with "depth", which is when you nest a list in another list: good for organizing your data, but bad for producing long vectors over which your programs could vectorize. so if you want this to matter more broadly, you can consider it a meditation on some of the mechanics of that, i.e. how to flatten some deep constructions in algorithms, and how to generalize shallow operations to apply at depth
Yeah, array language syntax just breaks my brain. I'm sure given enough time I could get the hang of it, but I'm also pretty sure I'll never put in the time
https://en.wikipedia.org/wiki/K_(programming_language)
As far as I can tell, it seems to be something halfway between TempleOS and MUMPS but its a programming language instead of an OS. I don't think you are missing some deep meaning. Its more that this is written in an esoteric language which seems to be more overloaded than Perl by someone who maybe isn't so great at clear communications. He's just looking at ways to make more efficient code in K (the language). But it does look sort of like he is talking about math theorems (he isn't).
> more overloaded than Perl by someone who maybe isn't so great at clear communications.
I have the same feeling. The root of K is APL, but to avoid special characters (I assume), the same symbol has multiple meanings (overloaded), depending on eg. the position, the data type, and the context. The idea is that "programs should be short enough to fit in your head." The challenge is, similar to Perl and Regex syntax, it's very hard and often cryptic to read.
I do think a concise syntax is useful, for a programming language. But at the same time, the syntax should be readable, and that probably means that each symbol or operator must only have one meaning, and that meaning should be (more or less) obvious.
K is an array language. Even an integer is actually an array of one element. I think that makes sense for a tiny language: This is the simplest possible type system. You can even support strings, when using eg. metadata or using a heuristic like "a string is always zero terminated" (which is what I used for my tiny language).
It's clear that the symbols want to have one meaning each, for monadic and dyadic use, but that might mean quite different execution and types.
For example, & is monadic 'where' and dyadic 'min' (a logical extension of it being AND on bit-booleans), but this means you get different semantics, even if they all capture the 'where'-ness:
In both cases, you get that `x@&x` works, as `&x` will yield appropriate indices for `x`, but what that actually does has changed. In other languages, these would be spelled very differently, and so do seem like an overload, but sometimes it is just a point of view.As for why it's obvious- it's not, really, but it's no less obvious than the word `where`, and you have already learnt it, as it is (as it seems to me at least) to be punned on the C syntax (same as `*`, which gives `first`).
wasnt there another post about using these eso lang as intelligence tests for AI?
Reading that certainly requires more than symbol shunting.
> by someone who maybe isn't so great at clear communications
I don't think that's fair. If you're familiar with the programming language, his writing is fairly clear. If you're not, maybe you're just not in his target audience.
IOW, optimizing his text for people familiar with the language is probably a better choice than teaching the language, which would distract him from his goal.
Sad that the Wikipedia page links to some specific commercial service rather than the actual programming language runtime (which appears to be AGPL-licensed).
you can still try it out here https://kparc.io/kc/
other versions (not k7) include eg. https://ktye.github.io/k.html
the original implementations of k were all proprietary
there are a few open source implementations as well by now
https://wiki.k-language.dev/wiki/Running_K
I think of K like a super-geeky version of Excel, for people who do quant stuff. People do very useful, cryptic stuff in convoluted, bespoke Excel sheets, updated and grown over decades with 37 variants of almost-but-not-quite the same VB function, etc. I imagine the K world is very similar, except K users can meet in London pubs and trade little snippets of K handwritten on scraps of paper between them like Pokemon cards.
> Next up - the War on Lambdas
I don't know array based languages well but I want to read the next one.