-----Original Message-----
From: General [mailto:[email protected]] On Behalf
Of Rob Hodgkinson
Sent: maandag 20 november 2017 02:33
To: [email protected]
Subject: Re: [Jgeneral] initial reaction to J
Enjoyed your comments Daniel, I find them insightful for someone relatively
new to the language.
Liked your analogy about knives, chefs and kids too !
The general observation is to persist (Andrew) as the more you become
familiar with J the more the power dawns on
you to the kinds of possibilities.
Most often such power is entwined closely with concepts around higher level
arrays and linear algebra where such language
notations really shine. I have
found phrases around shortest path solution and transitive closure to be
incredibly succinctly and elegantly defined in J for example.
For more advanced applications in mathematics (like a J tutorial on steroids
focused on very interesting graphics applications) I would also highly
recommend Cliff Reiterâs work on Fractals
published in eBook form available
here (and in print from Amazon).
http://www.lulu.com/au/en/shop/clifford-reiter/fractals-
visualization-and-j/ebook/product-17513422.html
Thanks, Rob
On 20 Nov 2017, at 11:06 am, Daniel Lyons <[email protected]> wrote:
Andrew,
I've been seriously trying to learn J for the last 6 weeks or so. I am a
professional programmer, about 13 years in industry, with extensive
experience in many languages. And I am learning J because I am interested in
thinking different thoughts. There are a number of ways that programming
culture could have gone. APL and J represent a different path. Maybe things
that seem like chronic conditions in the main culture (huge reams of code,
programming as performance art, faddishness, etc.) may just be symptoms
of ingrained thoughts unexamined too long.
Six weeks in, I could still give up. It
certainly takes more effort to learn J. But
I kind of consider that a feature. It really
is different from other things. And I
am questioning the basis behind a lot of your
comments. I got a lot out of this
video from the Dyalog conference:
https://www.youtube.com/watch?v=9xCJ3BCIudI
<https://www.youtube.com/watch?v=9xCJ3BCIudI> the crux of it being,
readability is probably the most ill-defined concept in programming. When
we say Python is readable, we really mean it is familiar. We have the sense
that we could understand it. But I am not going to understand a complex
financial, statistical, or scientific
calculation in Python or J. The trouble I will
have understanding what the code is doing doesn't have much really to do
with the language, though as I'm new to J it will take longer.
To me, J represents thinking about computation at the chemical level
rather than at the quark level. Yes, there are a lot more elements in the
periodic table than there are types of quark. But, on the other hand, if you
have actual things to do, the chemistry might be more applicable than the
subatomic physics. As a professional
programmer, I feel like I spend a lot of
my time rehashing the same things with small variations. So the emphasis on
brevity isn't for the sake of laughs here.
It's to elevate your thinking to a
more abstract level. If I'm going to spend another 2030 years programming,
sppending one year really learning a powerful
tool like J doesn't seem like a
bad investment. It would be weird to take knives away from chefs because
kids cut themselves when they're beginning. Now to some of your specific
points.
On Nov 19, 2017, at 12:15 PM, Andrew Dabrowski
<[email protected]> wrote:
3. The heart of the language seems to be in
tacit definitions, and explicit
ones seem to be just a necessary but ugly kludge
On the other hand, I see a fair amount of non-tacit definitions in source
code in the addons. I think maybe we bring this to our learning of J because
we feel like this is the shining core of J,
but I'm not sure that's really the case.
I have made a habit of checking my definitions
with 13 : but if the result is
bigger or has too many [: caps, I keep the
explicit form. I don't so far have the
sense that people are policing the use of explicits.
The only way to get better at reading code is reading more code. You'd be
surprised how few people actually try it
though, preferring only to read their
own. I get the sense that the APL/J folks do a lot more trading of little
snippets, and thus, more actual code reading than people who do Java, for
some whatever reason.
4. Therefore the language can really only be used comfortably in domains
where functions of arity higher than 2 are rare.
Well, Haskell functions actually only have an arity of 1. If you need more
than one argument, behind the scenes it desugars a 2-arity function to a
function returning a function of one argument,
and so on. So far, this hasn't
been a huge problem for me; one of the manuals has some language about
this. I think the J mentality is "control f
data" so many cases where you would
need a bunch of arguments, you either don't because of adverbs or you
don't because you can bundle up a bunch of control data into a larger
package with boxes. But that's my beginner's interpretation of what's going
on here. Lots of languages have seemingly
impossible limitations like this yet
are able to get real work done.
5. The mania for terseness is clearly at
clinical levels. The family of circle
functions o. is something that seems like a good idea in the shower or the
middle of night, but no one would be foolish
enough to actually implement it.
Except Ken Iverson.
I assume that if you do a lot of trig, it
eventually comes in handy to use the
function numbers to simplify acquiring sine and cosine of a lot of things at
once, or something. It seems overly clever to
me too, but overly clever things
that survive several decades are probably
actually onto something, even if it
isn't obvious after first contact. ;)
6. In the age of unicode, why /not/ use the special symbols from APL? We
could use the J expressions to type them, but wouldn't the APL symbols look
and read better? As it is J might be said to have the worst of both worlds.
I have given this some thought myself, and I
spent a little time learning APL
as well. My first thought is to agree with you, but in fact most of the APL
operators are a bit more about convenience in 1960 than mathematical
purity. There's no particularly obvious mathematical reason for base and
decode to be T shapes. APL operators have a pleasing regularity because
inverses are often literally inverted and
whatnot, but the actual shapes they
have are more about how many shapes you could fit on a typeball and be
distinct after overstriking. So you get kind
of a taste of Chinese with radicals
that are added to different shapes. Well, J
has that too, with periods usually
changing a fundamental operator in a common way and colons doing
something less common.
I have found using the APL385 unicode font improves readability with J
somewhat because most fonts try so hard to make punctuation sort of
invisible. I imagine it just gets easier with time and we're starting out.
I think you could actually go further than APL. In the book _A Programming
Language_, Iverson describes several notations, including his inner product
notation, that are not the way APL the language implemented them,
probably because it's not super-feasible in a
linear setting. APL looks cool at
first blush, but I'm not convinced it's
better. J actually improved on APL (IMO)
by removing the indexing notation so that everything consistently is verbs
and adverbs, and it actually winds up with a simpler and more consistent
syntax.
10. Maybe beginners aren't the point? Is J really just the Shriners of
programming? A bunch of crabby geezers riding around on scooters? I might
in fact want to join that, but I did kind of
get the impression that you were
selling J as a serious programming language.
I'm not sure it's necessary for every language to take beginners so
seriously. After all, you will spend most of your time with a language as an
intermediate or expert user, and basically every modern language worries a
lot about beginners. As an expert programmer (at least in some languages) I
find it kind of alluring that there are a few
languages that are intended for
experts and have left the sharp tools exposed. It has made me want to be
better at mathematics, even more than Haskell did. I think if you look at
what's happened in the NodeJS ecosystem, you can see what you get if you
take a beginners-at-all-costs attitude. Maybe instead of trying to meet
people where they start at the bottom, we should inspire them to climb up.
--
Daniel Lyons
----------------------------------------------------------------------
For information about J forums see
http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
