edit: and when you want to understand a larger program the terseness means you might be able to actually see it as a whole, in one page or screen

From terse languages surely there is a lot of training data for Perl. Not nearly as terse as J, K or Klong, although.

[0] https://code.golf/wiki/langs/julia

It looks like every apparently free variable in a Klong brace expression is actually bound as a function parameter.

This is so in basic algebra in that we can think of, say, x^2 + y^2 as a two parameter function, even without writing out the full f(x, y) = x^2 + y^2 notation with the f(x, y) head.

A two parameter function would be called "dyadic" in the jargon which calls one argument functions "monadic".

https://news.ycombinator.com/item?id=44231847

It's [dead] because they were banned, not because of the comment itself. It can still be vouched for.

You just go right to left. 1/2 applied to x^ so x^(0.5), _ is floor so floor of x^0.5. ! creates an array of numbers up until floor of x^0.5. 2+ just adds 2 to every number, and then I lost interest in learning the rest lol.

Yeah I like the python equivalent def is_prime(x): return x > 1 and all(x % i != 0 for i in range(2, x))

>This allows one to think faster and further than they could encumbered but a heavier syntax.

How does the programming language limit your ability or speed of thinking, lest when the fundamental data types and operations are the same? The hard work is always knowing what to implement. Saving some keystrokes for reversing an array or whatever other array manipulation is hardly a game changer.

That's a good way to put it. It's pretty hard to convey this to someone who hasn't actively tried and solved real problems in such languages though. You don't realize how much the "words get in the way" (as Granny Weatherwax would say) until you give an array language a good chance.

Another pop-culture quote that resonated in this regard is from The Matrix:

> Your brain does the translating. I don't even see the code. All I see is blonde, brunette, redhead.

All I see is range, sum-over, divide. The symbols turn into the concepts directly in your head - not as conscious translation, but in the way I imagine Chinese or Japanese kanji characters translate directly in the head of a native speaker.

I think it's important to remember that APL was born of an era where having a keyboard dedicated to a single programming language was reasonable.

I think there's a lot of middle ground between the more line noise syntax of say jsoftware, or a pure lisp style prefix notation.

This is a little snippet from Stevan Apter, a k programmer that has an old school home page with a lot of array language curiosities:

https://nsl.com/papers/kisntlisp.htm

If you look at the pseudo code example at the end using words vs ascii glyphs, I think that's quite readable while also concise. It uses k's bracket notation to easily specify slices of nested arrays.

Interestingly kxsoftware themselves went this route with q (Stevan's essay predates this I believe). There they kept nearly all the power of k but exposed it va a more approachable sql like syntax.

I can understand (though do not personally agree with) the appeal of extreme terseness — there are arguments to be made that maximizing information density minimizes context switching, since it reduces the amount of scrolling. Personally, I find that large displays and split buffers mitigate this issue, whereas the mental overhead of using my short-term memory to map of dozens of single letter variables to semantic definitions is much higher than having to flip between splits/marks in my text editor. (The fact that the aforementioned Iverson Ghost languages are popular whereas APL and its derivatives are not is evidence that I'm aligned with most people in this regard.)

I don't understand why people rarely make the terseness argument for non-array languages, even though it's just as easy to write tersely in them — the Obfuscated C Competition is a prime example [1]. Is it just due to the influence of APL, or is there something special about array languages that gives them a unique proclivity for terseness?

[0] https://dev.to/bakerjd99/numpy-another-iverson-ghost-9mc

[1] https://www.ioccc.org, https://github.com/ioccc-src/winner/blob/master/2020/ferguso...

I wish APL derivatives embraced some of these ideas, and made their magic spells easier to parse visually, and to format for readability. I don't know how to achieve that easily. Mathematical notation took centuries to develop. It took quarter of a century for programming languages to normalize indentation. Maybe APLesque languages will eventually come up with a notation that's less impenetrable than APL / K / Q, but less verbose than Pandas.