I've been fascinated by J for the last week or so. After successfully
writing a simple script that's actually useful, I'm trying to decide
whether to keep learning J or just declare victory and return to
conventional languages.
I'm not really a programmer, I'm a math instructor, but I do some
programming in Perl and Clojure for the department. J looks like the
kind of language that might be useful for small practical tasks, but I
have some serious reservations.
1. J is clearly the work of an insane genius. The fetish for brevity
combined with the brilliantly thought out meta-operations is frightening.
2. The ideal use case for J is obviously an iPhone game where
programmers compete in code golf.
3. The heart of the language seems to be in tacit definitions, and
explicit ones seem to be just a necessary but ugly kludge.
4. Therefore the language can really only be used comfortably in domains
where functions of arity higher than 2 are rare.
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.
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.
7. Has anyone made up a set of aliases for beginners which provides
natural language based names for the operations? A newbie could slowly
add the abbreviations to his vocabulary, as one does with e.g. emacs.
8. The failure to clearly distinguish at the syntactic level between
monadic and dyadic verbs, along with the laconic culture, makes tacit
definitions almost unreadable for a beginner. This could have been
avoided, but it seems the drive to score an eagle won out over the
desire for clarity.
9. It's true that the choice of symbols for verbs was made carefully and
exhibits a logic not found in natural language. But here,
unsurprisingly, the latter shows its wisdom. There's a reason that
similar words in English tend to have unrelated meanings. For example I
often see "wary" written as "weary" in online forums. In practice this
causes little confusion because one can tell from the context which
meaning is intended. But if you mistake e.g. "{." for "{:" your code
will probably still run but with errors that could be hard to pin down.
Verbosity is better, at least for beginners.
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 feel better now. I continue to be fascinated by J, but point 4.
especially makes me leery of investing too heavily in it.
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
