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.
countrymile 2 days ago [-]
That's my understanding too. R never seems to make these lists.
kelas 17 hours ago [-]
numpy is also an array language, with a userbase that of (R+k)^10
never seems to make these lists :)
seanhunter 2 days ago [-]
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.
kelas 17 hours ago [-]
oh, gosh. sorry for your loss.
if you don't mind me asking, do you also remember the day when you wrote some non-trivial program in any language and it "worked" the first time, whatever that means (i presume "correctly")? what was the language? are you sure you've made a full recovery from that shock as well?
on a serious note, APL (and, by proxy, its descendants) invented REPL (dubbed "dialogue approach") long before the people who coined "REPL" even came to be. When that happened, C lanugage wasn't around either. Fortran was, granted, and sure enough it "worked" every time. you didn't even have to try, just punch it up on a punchcard, stick it in, wait a while. done. flawless.
on a closing note: writing correct programs takes skill and happens in iterations. the faster you can iterate, the faster you can justify your money's worth. the less you type, the more you think. less code less bug.
does that help?
seanhunter 52 minutes ago [-]
What I mean by "worked" in this context is compiled/parsed[1] without error and had correct behaviour when executed.
I have been programming professionally for about 30 years at this point, so it has happened to me literally hundreds of times at this point in at least 10 other languages- in fact in some languages (especially Haskell and Rust) I would say it's the norm for me rather than the exception to have the code work correctly if it passes compilation (which is sort of the point of strict type systems obviously).
It literally only ever happened the one time in kdb which is why I remember it so vividly and not in those other languages.
I have no idea why you thought your closing note might help, but sure.
[1] Depending on language obviously.
BoiledCabbage 16 hours ago [-]
>on a serious note, APL (and, by proxy, its descendants) invented REPL (dubbed "dialogue approach") long before the people who coined "REPL" even came to be.
While I have enjoyed learning array languages, and think they are still underrated, Wikipedia seems to disagree with this statement above.
According to wikiepdia, REPL seems to have been coined after Iverson created his notation, but before the first APL was ever written.
"The 1974 Maclisp reference manual by David A. Moon attests "Read-eval-print loop" on page 89, but does not use the acronym REPL.[7]
Since at least the 1980s, the abbreviations REP Loop and REPL are attested in the context of Scheme.[8][9]"
The first APL interpreter was implemented on System/360 in 1965. Iverson got a Turing in 1979.
BoiledCabbage 14 hours ago [-]
> In 1964, the expression READ-EVAL-PRINT cycle is used by L. Peter Deutsch and Edmund Berkeley for an implementation of Lisp on the PDP-1.
If you're arguing that "Read-Eval-Print cycle" doesn't count as REPL, then it pretty strongly undercuts your argument that "dialog approach" is.
And 1964 predates APL implementation.
kelas 13 hours ago [-]
ok, you have a point there. all 53 PDP-1s were "cheap" computers compared to IBM stuff (only $1M, adjusted) and used paper drum instead of punch cards. that was a nightmare to deal with, so people were buying IBM M typewriters to punch stuff in. Although Deutsch and Berkeley's LISP was in large part a copycat of IBM's LISP, people were indeed typing in LISP expressions in a REPL'ish manner. But if you ever saw a line of LISP, you can imagine what kind of "REPL" that was. "Miss one paren" comes to mind :)
APL\360 used a much more advanced selectric with a dedicated typeball, was designed for a machine of a totally different class, and could not be compared to literally kilometers of paper containing mostly mistyped parentheses. it was TRULY terse, expressive and interactive.
but yeah, PDP-1 hackers technically got there first - they had no choice :) check this out:
6-7 Input and Output, System Operation is where the READ-EVAL-PRINT is indeed mentioned. but if you read the entire paragraph, and the next one ("if the system drops dead" lol) you'll agree that PDP-1 "REPL" was hell on earth, at the very end of the manual there are some really juicy REPL expressions :)
LISP was a torture compared to short and powerful APL notation.
less code less bug.
gitonthescene 5 hours ago [-]
I know you! We worked together for a MF at GS.
seanhunter 1 hours ago [-]
Hey there. Hope you’re doing well. Last I heard of him he was doing some sort of real-estate thing in Japan.
gcanyon 2 days ago [-]
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...
1-more 2 days ago [-]
> 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?
Romario77 2 days ago [-]
avg=: +/ % #
+/ sums the items of the array.
# counts the number of items in the array.
% divides the sum by the number of items.
1-more 2 days ago [-]
delightful, ty. How does it handle empty arrays? Throw? Average is zero? Average is infinity?
Further validation for n / 0 = 0 in Elm and Pony and a couple other places! TYSM
deepsun 1 days ago [-]
I'd call that code obfuscation.
a.sum() / a.count()
you would not need an explanation.
kelas 16 hours ago [-]
> I'd call that code obfuscation.
we call them "trains". since this one has a descriptive name, `avg a`, is not cryptic at all. just a bit fewer of absolutely meaningless parens and duplication.
but it doesn't end there:
1. imagine you wanted a moving average instead. i need to change one character in this train to get `mavg`. what would you need to do?
2. imagine you want to compute moving averages for each of 1000 arrays using both instruction-level parallelism and all available cores? while you'd be writing your unobfuscated code for that, i'd be done way before you're back from your lunch break. in two keystrokes.
once you'd be done with your solution, there would be no need to discuss productivity, or so i hope, but to discuss performance would be interesting.
hatefulmoron 1 days ago [-]
K et al. can look like that, but this example doesn't require any explanation to someone who has any familiarity.
pasquinelli 1 days ago [-]
the thing about tacit programming is that it wouldn't use 'a' in the above. if you wrote average in j without it being tacit, it would probably be more readable to you. the question of how to thread data around without naming it is an interesting one to me.
kelas 15 hours ago [-]
> without it being tacit, it would probably be more readable
definitely. tacit can be taken a bit too far sometimes, but when a certain discipline is observed (just like in any language, really) it is no less readable than... let me see. oh, lets take some typical pandas/polars heroics - no, those things don't give me brain aneurisms and not too shocking either. they just make wanna vomit no less than the poor people who were forced to write it and contemplate what they've done.
> tacit is "bad"
not at all. it takes one time to see how avg looks in explicit notation to understand that the idea of trains is totally justified.
> the question of how to thread data around without naming it is an interesting one to me.
good question. see above - yes indeed, things can be taken to extremes. when an apl/k program is a oneliner 80 chars long, that's just not cool. there is no reason not to break it down a bit into moving parts with names (and ample space on the right margin for annotations). in no way APL and friends are somehow exempt from commenting their code. but that's not really endemic to array languages, you'd agree.
cess11 2 days ago [-]
There's an APK, for dabbling on the phone at times when there's no larger computer available but still time to spend.
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.
# python
[127 * sin(x * tau * freq / samplerate) for x in range(samplerate)]
zahlman 2 days ago [-]
For that matter,
# python
from numpy import sin, arange, pi
127 * sin(arange(samplerate) * 2 * pi * freq / samplerate)
kelas 14 hours ago [-]
for that matter, i always wonder how people mistake python for numpy :) they have surprisingly little in common.
but enough talking about languages that suck. let's talk about python!
i'm not some braniac on a nerd patrol, i'm a simple guy and i write simple programs, so i need simple things. let's say i want an identity matrix of order x*x.
nothing simpler. i just chose one of 6 versions of python found on my system, create a venv, activate it, pip install numpy (and a terabyte of its dependencies), and that's it - i got my matrix straight away. i absolutely love it:
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.
RodgerTheGreat 2 days ago [-]
A few more examples in K and Lil where pervasive implicit iteration is useful, and why their conforming behavior is not equivalent to a simple .map() or a flat comprehension: http://beyondloom.com/blog/conforming.html
leephillips 2 days ago [-]
And in Julia it’s foo.(x).
graboid 2 days ago [-]
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".
tailrecursion 2 days ago [-]
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.
ofalkaed 1 days ago [-]
>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.
tailrecursion 1 days ago [-]
Yes the symbols in a way are the letters of APL, and the phrases are the words.
kelas 17 hours ago [-]
in k, we say "primitive operators are verbs", and "lambdas, functions, variables, literals are nouns".
higher-order functions (over, scan, each, etc) are called adverbs.
kelas 17 hours ago [-]
> i assume that in most array languages, you also create "words" or however you want to call functions, to reuse code.
sure, that's a very useful feature, like elsewhere.
> 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".
strictly speaking, dashes and underscores in k can't even be a part of identifier - they are core language primitives. it is very uncommon to see java-like identifiers like CalculateEstimatedRevenue, why would you want that?
to your question:
here's a bit of an oddity: all user-defined functions and core language operators can be called using functional notation:
v:1 2 3 / some vector
v+v / usual infix notation, two operands: left and right
2 4 6
+[v;v] / same as infix, but called as it were a function.
2 4 6
add:{x+y} / a user-defined function: a lambda with a name and two operands.
add[v;v]
2 4 6
but there is an important distinction between the two. you can't use your `add` function infix, you must call it as a function, and there are good reasons for that:
2 add 2 / that's not gonna work
that said, mixing language primitives with function calls looks and reads just fine:
+/add[v;v]
12
hope this helps!
kbelder 10 hours ago [-]
How does that scale up to program that's thousands of lines? What if you have a hundred different vectors? You're not going to be calling them v1, v2, ...
Or, do you just not do that sort of stuff in these languages? I'm not very familiar with them, but I have ended up with some pretty long programs using Pandas in Python.
RodgerTheGreat 10 hours ago [-]
very important things should have short names.
locals you're immediately operating upon should have short names.
short names should be used in a consistent way.
less important things can have longer names.
variables in a broader scope can have longer names.
if you have a hundred different vectors, don't just dump them in a pile; put them in dictionaries, tables, namespaces, or scopes.
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.
jacobgorm 16 hours ago [-]
I once took a graduate course from Larry Snyder on ZPL. I found it pretty neat because it made communication costs very easy to reason about.
mirawelner 1 days ago [-]
Today I learned that there is such a thing as an array language! This is so neat! Need to learn all of them.
feraloink 2 days ago [-]
This is wonderful: APL is there! And a visual APL keyboard too.
bee_rider 2 days ago [-]
Dumb question from an outsider: are array languages competitive with something like C or Fortran in their niche performance-wise?
gitonthescene 5 hours ago [-]
Perhaps a more precise question is whether you can write programs as performant as those written in C or Fortran and the answer is it depends on the program (and more likely the programmer). The languages tend to do memory management for you which means giving up some control. Most use “immutable” data structures which force more contraints.
But for the loss of control you get stuff like fancy SIMD implementation for nothing.
All and all there’s a cost/benefit calculation but that ratio can get quite low.
gopalv 2 days ago [-]
> 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.
nathell 2 days ago [-]
Is this written by Arthur Whitney himself?
gitonthescene 5 hours ago [-]
The zoo is a collection of web interfaces to a number of array languages written by several people including ATW.
ludsan 2 days ago [-]
no uiua :(
evnu 2 days ago [-]
Uiua is the first one that made array languages "click" for me due to the formatter.
etatoby 2 days ago [-]
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.
ofalkaed 2 days ago [-]
What makes Uiua a full generation ahead of BQN?
srean 2 days ago [-]
It's missing Nial I think.
kelas 17 hours ago [-]
i'm sure niall is missing it too :)
what does he do these days?
JoshGG 2 days ago [-]
MATLAB is an array language.
ljosifov 2 days ago [-]
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
cobbal 2 days ago [-]
MATLAB doesn't even have 1-d arrays, it really is missing the principled and composable operations that make array languages useful
OneDeuxTriSeiGo 1 days ago [-]
I believe the ArrayCast had this debate on whether it's considered an arraylang when they had some of the MATLAB devs on.
The determination they came to was that MATLAB is an array lang but not an iversonian array lang.
kelas 16 hours ago [-]
guys,
symbolic algebra package and a computer language are not the same thing :) not even remotely.
RodgerTheGreat 2 days ago [-]
MATLAB doesn't have a FOSS implementation that runs in a browser.
bee_rider 2 days ago [-]
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?
kelas 16 hours ago [-]
of course it runs in a browser - pretty much everything you can build using clang will run on the web. including linux kernel and llvm itself.
to hell with peanuts: i'm pretty sure someone must even built cpython interpreter to wasm target, why not. there is no limit of what can be achieved by a group of motivated people with zero sense of direction.
k, however, makes quite a bit of sense on the web - also on your phone. and time to prompt is going to be MUCH faster than python and octave. and i mean their native builds :)
Array languages: where your first working program feels like a happy accident.
OneDeuxTriSeiGo 2 days ago [-]
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.
kelas 16 hours ago [-]
> your first working program feels like a happy accident.
if you don't mind sharing: how did your own first working program felt like, and what was it written in?
by the way, did it work, or did it work correctly? it's a small but important distinction.
r/apljk on reddit is also active.
never seems to make these lists :)
if you don't mind me asking, do you also remember the day when you wrote some non-trivial program in any language and it "worked" the first time, whatever that means (i presume "correctly")? what was the language? are you sure you've made a full recovery from that shock as well?
on a serious note, APL (and, by proxy, its descendants) invented REPL (dubbed "dialogue approach") long before the people who coined "REPL" even came to be. When that happened, C lanugage wasn't around either. Fortran was, granted, and sure enough it "worked" every time. you didn't even have to try, just punch it up on a punchcard, stick it in, wait a while. done. flawless.
on a closing note: writing correct programs takes skill and happens in iterations. the faster you can iterate, the faster you can justify your money's worth. the less you type, the more you think. less code less bug.
does that help?
I have been programming professionally for about 30 years at this point, so it has happened to me literally hundreds of times at this point in at least 10 other languages- in fact in some languages (especially Haskell and Rust) I would say it's the norm for me rather than the exception to have the code work correctly if it passes compilation (which is sort of the point of strict type systems obviously).
It literally only ever happened the one time in kdb which is why I remember it so vividly and not in those other languages.
I have no idea why you thought your closing note might help, but sure.
[1] Depending on language obviously.
While I have enjoyed learning array languages, and think they are still underrated, Wikipedia seems to disagree with this statement above.
According to wikiepdia, REPL seems to have been coined after Iverson created his notation, but before the first APL was ever written.
https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93prin...
no, actually i think Wikipedia got it right:
The first APL interpreter was implemented on System/360 in 1965. Iverson got a Turing in 1979.If you're arguing that "Read-Eval-Print cycle" doesn't count as REPL, then it pretty strongly undercuts your argument that "dialog approach" is.
And 1964 predates APL implementation.
APL\360 used a much more advanced selectric with a dedicated typeball, was designed for a machine of a totally different class, and could not be compared to literally kilometers of paper containing mostly mistyped parentheses. it was TRULY terse, expressive and interactive.
but yeah, PDP-1 hackers technically got there first - they had no choice :) check this out:
https://s3data.computerhistory.org/pdp-1/DEC.pdp_1.1964.1026...
6-7 Input and Output, System Operation is where the READ-EVAL-PRINT is indeed mentioned. but if you read the entire paragraph, and the next one ("if the system drops dead" lol) you'll agree that PDP-1 "REPL" was hell on earth, at the very end of the manual there are some really juicy REPL expressions :)
LISP was a torture compared to short and powerful APL notation.
less code less bug.
+/%#
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...
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?
+/ sums the items of the array.
# counts the number of items in the array.
% divides the sum by the number of items.
we call them "trains". since this one has a descriptive name, `avg a`, is not cryptic at all. just a bit fewer of absolutely meaningless parens and duplication.
but it doesn't end there:
1. imagine you wanted a moving average instead. i need to change one character in this train to get `mavg`. what would you need to do?
2. imagine you want to compute moving averages for each of 1000 arrays using both instruction-level parallelism and all available cores? while you'd be writing your unobfuscated code for that, i'd be done way before you're back from your lunch break. in two keystrokes.
once you'd be done with your solution, there would be no need to discuss productivity, or so i hope, but to discuss performance would be interesting.
definitely. tacit can be taken a bit too far sometimes, but when a certain discipline is observed (just like in any language, really) it is no less readable than... let me see. oh, lets take some typical pandas/polars heroics - no, those things don't give me brain aneurisms and not too shocking either. they just make wanna vomit no less than the poor people who were forced to write it and contemplate what they've done.
> tacit is "bad"
not at all. it takes one time to see how avg looks in explicit notation to understand that the idea of trains is totally justified.
> the question of how to thread data around without naming it is an interesting one to me.
good question. see above - yes indeed, things can be taken to extremes. when an apl/k program is a oneliner 80 chars long, that's just not cool. there is no reason not to break it down a bit into moving parts with names (and ample space on the right margin for annotations). in no way APL and friends are somehow exempt from commenting their code. but that's not really endemic to array languages, you'd agree.
https://code.jsoftware.com/wiki/Guides/JAndroid
And lots of the "labs" (interactive tutorials) are built in too: 3 dots -> Help -> Labs..
Edit: I should also have mentioned that Termux on android can build ngn-k, goal and a bunch of other open source array languages too.
There's also Rob Pike's Ivy language for Android too.
https://github.com/dzaima/APL/tree/master/AndroidIDE
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
but enough talking about languages that suck. let's talk about python!
i'm not some braniac on a nerd patrol, i'm a simple guy and i write simple programs, so i need simple things. let's say i want an identity matrix of order x*x.
nothing simpler. i just chose one of 6 versions of python found on my system, create a venv, activate it, pip install numpy (and a terabyte of its dependencies), and that's it - i got my matrix straight away. i absolutely love it:
and now lets see just how obscure and unreadable exactly the same thing looks in k: no wonder innocent people end up with brain aneurisms and nervous breakdowns.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.
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.
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.
higher-order functions (over, scan, each, etc) are called adverbs.
sure, that's a very useful feature, like elsewhere.
> 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".
strictly speaking, dashes and underscores in k can't even be a part of identifier - they are core language primitives. it is very uncommon to see java-like identifiers like CalculateEstimatedRevenue, why would you want that?
to your question:
here's a bit of an oddity: all user-defined functions and core language operators can be called using functional notation:
but there is an important distinction between the two. you can't use your `add` function infix, you must call it as a function, and there are good reasons for that: that said, mixing language primitives with function calls looks and reads just fine: hope this helps!So does it end up as
Or, do you just not do that sort of stuff in these languages? I'm not very familiar with them, but I have ended up with some pretty long programs using Pandas in Python.less important things can have longer names. variables in a broader scope can have longer names.
if you have a hundred different vectors, don't just dump them in a pile; put them in dictionaries, tables, namespaces, or scopes.
https://github.com/mlochbaum/BQN/blob/master/vm.bqn
Also missing Uiua.
But for the loss of control you get stuff like fancy SIMD implementation for nothing.
All and all there’s a cost/benefit calculation but that ratio can get quite low.
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.
what does he do these days?
The determination they came to was that MATLAB is an array lang but not an iversonian array lang.
symbolic algebra package and a computer language are not the same thing :) not even remotely.
to hell with peanuts: i'm pretty sure someone must even built cpython interpreter to wasm target, why not. there is no limit of what can be achieved by a group of motivated people with zero sense of direction.
k, however, makes quite a bit of sense on the web - also on your phone. and time to prompt is going to be MUCH faster than python and octave. and i mean their native builds :)
https://kparc.io/k/
backslash is reference card, cmd+[] some examples
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.
if you don't mind sharing: how did your own first working program felt like, and what was it written in?
by the way, did it work, or did it work correctly? it's a small but important distinction.