I assume that in most array languages, you also create "words" or however you want to call functions, to reuse code. I wonder about a purely aesthetic issue: how does it look to interleave those symbols with user-defined words that by nature will be much, much longer, i.e. "create-log-entry" or "calculate-estimated-revenue".
I never did any real programming in APL, but I studied it over about 2 months. When you get used to the symbols, reading spelled-out words feels like reading in slow motion, or being stuck in molasses.
Most (not all) APL code I've seen uses very short names, often one letter names, for function names. And APL programmers are famous for cataloging "idiom" which are short phrases for common subroutines. In other words, it's best practice to repeat 3- or 4- symbol phrases instead of defining a subroutine.
Of course, there's nothing about an array language that requires using symbols; but for some reason most do.
>Of course, there's nothing about an array language that requires using symbols; but for some reason most do.
The idioms become words and you read them like words, you don't step through each letter of a word when you read it, you recognize the shape. The same thing happens in APL and its ilk, any commonly used sequence is instantly understood as its function without having to parse each individual symbol and what it does.
At one time I briefly spent a bunch of time learning kdb/q. I remember one particular day when I wrote a non-trivial program and it worked first time. I was so shocked I thought I must have suffered some kind of brain aneurism or something.
Based on the one thing I remember in APL I'm guessing the first two characters are "sum over some data structure" and the data structure is what the next two mean. What does it mean entirely?
APL and K are still pretty daunting, but I've recently been dabbling in Lil[1], which is something like a cross between K and Lua. I can fall back on regular procedural code when I need to, but I appreciate being able to do things like:
127 * sin (range sample_rate)*2*pi*freq_hz/sample_rate
This produces one second audio-clip of a "freq_hz" sine-wave, at the given sample-rate. The "range sample_rate" produces a list of integers from 0 to sample_rate, and all the other multiplications and divisions vectorise to apply to every item in the list. Even the "sin" operator transparently works on a list.
It also took me a little while to get used to the operator precedence (always right-to-left, no matter what), but it does indeed make expressions (and the compiler) simpler. The other thing that impresses me is being able to say:
maximum:if x > y x else y end
...without grouping symbols around the condition or the statements. Well, I guess "end" is kind of a grouping symbol, but the language feels very clean and concise and fluent.
Pretty much, yeah! The difference is that in Python the function that calculates a single value looks like:
foo(x)
...while the function that calculates a batch of values looks like:
[foo(x) for x in somelist]
Meanwhile in Lil (and I'd guess APL and K), the one function works in both situations.
You can get some nice speed-ups in Python by pushing iteration into a list comprehension, because it's more specialised in the byte-code than a for loop. It's a lot easier in Lil, since it often Just Works.
Programming in an array lang "should" generally feel like using a calculator.
You are working in a REPL, starting with small expressions to verify they are roughly doing what you want and then composing them to build up until you can plug it all together and now have a formula you can plug into the calculator to plug and chug all the rest of your data.
So in that sense yeah it does kind of replicate the magic of the first time you got a complex equation or BASIC program to run on your TI back in your school days.
Yeah - IDK why it never makes it to these lists. R too. Matlab being 2D matrix first/default gets it right for me there. IK matrices trivially translate to arrays, still: find 2D to be extra expressive on human level, for zero price paid. I get it it's all the same to the cpu. 2D rows-columns rectangle of data being the simplest data structure both necessary and sufficient covering a 1) matrix 2) spreadsheet 3) SQL table 4) directed graph of nodes and edges. (in the past I've read someplace that lists are for pie eaters, but wouldn't know myself
Octave covers all the Matlab functionality I need, not sure if it runs in a browser. I mean if you have the source code for something there must be some way to get it to run in a browser these days, right?
I assume that in most array languages, you also create "words" or however you want to call functions, to reuse code. I wonder about a purely aesthetic issue: how does it look to interleave those symbols with user-defined words that by nature will be much, much longer, i.e. "create-log-entry" or "calculate-estimated-revenue".
I never did any real programming in APL, but I studied it over about 2 months. When you get used to the symbols, reading spelled-out words feels like reading in slow motion, or being stuck in molasses.
Most (not all) APL code I've seen uses very short names, often one letter names, for function names. And APL programmers are famous for cataloging "idiom" which are short phrases for common subroutines. In other words, it's best practice to repeat 3- or 4- symbol phrases instead of defining a subroutine.
Of course, there's nothing about an array language that requires using symbols; but for some reason most do.
>Of course, there's nothing about an array language that requires using symbols; but for some reason most do.
The idioms become words and you read them like words, you don't step through each letter of a word when you read it, you recognize the shape. The same thing happens in APL and its ilk, any commonly used sequence is instantly understood as its function without having to parse each individual symbol and what it does.
It depends on the language and the programmer.
https://github.com/mlochbaum/BQN/blob/master/vm.bqn
R is also an array language, but a non-iversonian one. Another good ressource for array languages is https://aplwiki.com/.
r/apljk on reddit is also active.
That's my understanding too. R never seems to make these lists.
At one time I briefly spent a bunch of time learning kdb/q. I remember one particular day when I wrote a non-trivial program and it worked first time. I was so shocked I thought I must have suffered some kind of brain aneurism or something.
Array languages are such a mind twist and so fun. I dabbled in J at one point, and I love explaining
+/%#
to people. But the real expressive power comes when you start to get into tacit expressions yourself, understand function exponents, and "get" under.
Hmmm... maybe I need a refresher...
> I love explaining +/%#
Based on the one thing I remember in APL I'm guessing the first two characters are "sum over some data structure" and the data structure is what the next two mean. What does it mean entirely?
avg=: +/ % #
+/ sums the items of the array.
# counts the number of items in the array.
% divides the sum by the number of items.
2 replies →
There's an APK, for dabbling on the phone at times when there's no larger computer available but still time to spend.
https://code.jsoftware.com/wiki/Guides/JAndroid
Dumb question from an outsider: are array languages competitive with something like C or Fortran in their niche performance-wise?
> are array languages competitive with something like C or Fortran
The REPL is what matters - also while being performant.
Someone asks you a question, you write something, you run it and say an answer, the next question is asked etc.
I've seen these tools be invaluable in that model, over "write software, compile and run a thousand times" problems which C/Fortran lives in.
APL and K are still pretty daunting, but I've recently been dabbling in Lil[1], which is something like a cross between K and Lua. I can fall back on regular procedural code when I need to, but I appreciate being able to do things like:
This produces one second audio-clip of a "freq_hz" sine-wave, at the given sample-rate. The "range sample_rate" produces a list of integers from 0 to sample_rate, and all the other multiplications and divisions vectorise to apply to every item in the list. Even the "sin" operator transparently works on a list.
It also took me a little while to get used to the operator precedence (always right-to-left, no matter what), but it does indeed make expressions (and the compiler) simpler. The other thing that impresses me is being able to say:
...without grouping symbols around the condition or the statements. Well, I guess "end" is kind of a grouping symbol, but the language feels very clean and concise and fluent.
[1]: https://beyondloom.com/decker/lil.html
I assume this is the same as this?
For that matter,
Pretty much, yeah! The difference is that in Python the function that calculates a single value looks like:
...while the function that calculates a batch of values looks like:
Meanwhile in Lil (and I'd guess APL and K), the one function works in both situations.
You can get some nice speed-ups in Python by pushing iteration into a list comprehension, because it's more specialised in the byte-code than a for loop. It's a lot easier in Lil, since it often Just Works.
2 replies →
This is cool. Wish there was more examples for jtye/k so I would have a better chance of learning to use it.
Also missing Uiua.
This is wonderful: APL is there! And a visual APL keyboard too.
Is this written by Arthur Whitney himself?
It's missing Nial I think.
no uiua :(
Uiua is the first one that made array languages "click" for me due to the formatter.
Came here to say the same thing. Uiua is my favorite language by far. BQN is also a cool "Nu-APL" but Uiua is just a full generation ahead.
What makes Uiua a full generation ahead of BQN?
Array languages: where your first working program feels like a happy accident.
Programming in an array lang "should" generally feel like using a calculator.
You are working in a REPL, starting with small expressions to verify they are roughly doing what you want and then composing them to build up until you can plug it all together and now have a formula you can plug into the calculator to plug and chug all the rest of your data.
So in that sense yeah it does kind of replicate the magic of the first time you got a complex equation or BASIC program to run on your TI back in your school days.
MATLAB is an array language.
MATLAB doesn't even have 1-d arrays, it really is missing the principled and composable operations that make array languages useful
Yeah - IDK why it never makes it to these lists. R too. Matlab being 2D matrix first/default gets it right for me there. IK matrices trivially translate to arrays, still: find 2D to be extra expressive on human level, for zero price paid. I get it it's all the same to the cpu. 2D rows-columns rectangle of data being the simplest data structure both necessary and sufficient covering a 1) matrix 2) spreadsheet 3) SQL table 4) directed graph of nodes and edges. (in the past I've read someplace that lists are for pie eaters, but wouldn't know myself
MATLAB doesn't have a FOSS implementation that runs in a browser.
Octave covers all the Matlab functionality I need, not sure if it runs in a browser. I mean if you have the source code for something there must be some way to get it to run in a browser these days, right?
it is one of their cousins
[dead]
[flagged]