Hi Ian -

Thanks for the reply. I was more so interested in APL from the
perspective of how to think in arrays or idioms of array programming.
For example,  Devon posted the old trick of counting
parentheses/brackets yesterday.

I'm getting there, but still feel like I'm approaching things from the
wrong perspective sometimes.

I don't see myself using a traditional APL. I am quite demotivated the
non-ascii characters.  I ask after learning LISP I found that the
concepts applied to different interpreters.

I stumbled upon this wiki post from you last night while researching,
http://www.jsoftware.com/jwiki/APL2JPhraseBook, which encourages
unlearning APL. If I were to make a poor metaphor, I took algebra
based physics in college. I learned that there was a calculus based
physics later and studied some if it on my own and realized how much
simpler, or less repetitive at least to learn it would have been. To
some degree, with J being a superset of APL, I can see why it would
make sense to unlearn. I won't go down that rabbit hole here though...

As Henry Rich said: practice, practice, practice is probably best.
I've been on a good run of practicing every chance I get for probably
five months now. I definitely appreciate the group's feedback on the
public practice. All the other languages I've learned had some other
person in my life that also knew it or learned it (aside from LISP,
which has a fair amount of open source to learn from). It's difficult
to learn if there's not an avenue for feedback.

Since we're in programming, I'll post some code. I wanted to write
something today that would take this string and produce this result:

'=:' splitstring "1 > ',' splitstring > {. 'reads' splitstring
'foo=:baz,abc=:123 reads from q'
┌───┬────┐
│foo│baz │
├───┼────┤
│abc│123 │
└───┴────┘

I still can't figure out why this doesn't work:

'=:' splitstring each ',' splitstring > {. 'reads' splitstring
'foo=:baz,abc=:123 reads from q'
┌──────────┬───────────┐
│┌───┬────┐│┌────┬────┐│
││foo│:baz│││abc=│123 ││
│└───┴────┘│└────┴────┘│
└──────────┴───────────┘

I can normally use each on boxed list of strings and have it operate
as though it was a single string.

So I stumble around  trying bits and pieces out until something works.
I suspect it has something to do with rank, which I understand at a
high level when it's something I have explicit control over,
http://csilo.com/!article?2013/10/15/J-rank-in-a-nutshell

Roger posted mentioned an essay yesterday that is apropos:
http://www.jsoftware.com/papers/perlis78.htm

If you take a problem, even a very simple one, and give it to a class
of 50 people to program in APL, there’s a very good chance that you’re
going to get 35 to 40 different solutions. To some, that’s a horrible
state of affairs. To me it indicates the language really has some
power to it, some value; it’s just perfect for people, in a sense, to
use who like to think originally, if possibly poorly, about things.

I do think it's wonderful. I just want to get my solutions less on the
fringe and more in the middle. Perhaps I'm getting there.
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

Reply via email to