Thanks for your comments. I imagine you're used to newbies getting
exasperated during their first exposure to J, so I didn't hold back. Of
course you're right that it can take years before one becomes
comfortable in a language. But with so many languages out there one has
to perform triage, and when I see the Circle Function or the kludges to
permit ternary functions I have to wonder about the prognosis for J.
On 11/19/2017 03:00 PM, Don Guinn wrote:
APL and J are more natural to mathematics and the real world than
traditional programming languages. The fact that they treat arrays as
natural and unnecessary to convert array calculations to scalar loops is a
major step forward in programming.
That may have been true when they were new, but I think packages like
Mathematica have eaten their lunch since then. Mathematica has a lot of
the meta-level features that J has (if not more) and gives you the
option of using verbose or abbreviated forms. Of course Mathematica is
expensive, if I didn't work at a University I'd never be able to afford
it. So J is attractive for being open source(?).
There are several concepts in J that are difficult to grasp, until you
understand them. Then they are obvious. Rank gave me months and years to
fully grasp. But now it is obvious.
I probably don't understand rank, but it's one of those things that of
which the misunderstanding is hard to recognize until it's passed.
Modifiers (adverbs and conjunctions) are a major step in extending math
concepts. A great example is insert (/) as it combines several mathematical
concepts into one. Sum (sigma) and product (big pi) are separate concepts
in math, but the same concept in J. Even continued fractions become similar
to sum and product series. Try "(+%)/10#1". And to see something really
interesting, try "(+%)/\10#1x".
Again, major when they were new, routine now. Clojure has almost entire
sublanguage devoted to reducing arrays with operations between elements.
Long strings of verbs and modifiers can be intimidating. I have difficulty
reading them too. But I have always wondered why I have trouble and feel
pressured to read a couple lines of APL or J which are equivalent to
several pages of FORTRAN. Yet I have no problem spending the hours
necessary to understand those pages of FORTRAN.
I've never dealt with Fortran, but in general verbosity and redundancy
are a learner's friends. I find it's almost always easier to read 10
clear pages than 1 cramped one.
You have only been playing with J for a short time. Remember when you first
started programming in C or whatever. If you tried to grasp the
complexities of pointers, classes, objects and the whole scope of the
language you would probably have been overwhelmed. How would a beginning
math student do if he was thrown into integral calculus and matrix algebra
on the first day of class?
As to using the APL symbols. APL programs are "pretty". They look nice. J
looks like a core dump. But I remember the difficulty entering the APL
symbols from a keyboard. Alternate shifts etc. were not easy.
As I suggested, why not use the J abbreviations to type the code and
then display it using APL symbols?
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
