J and APL share the same damning problem: they see the world as arrays

You see that as a problem?! HA!

when it comes time to do anything that isn’t array bound, you get ground to a halt.

1) you don’t get ground to a halt

2) many, if not most things, are “array bound” anyway

3) you could say that “non-array languages” suffer from the opposite problem – the minute you get into anything “array bound” you ground to a halt… yet you didn’t say that, did you?

4) efficiency arguments in the days of GHz processors, quad cores, and terrabytes of memory, are just silly. that’s assuming your efficiency argument was valid anyway, which it isn’t.

That’s why they’re both dead languages.

What a joke. I’d love to know what the rationale is for this statement.

There are public domain Js, and the reason they’re not developed is that J and APL aren’t particularly expressive. Whereas yes, their syntax and notation are surprisingly dense, and well suited to trivial math toys, the fact of the matter is that expressing complex data structures is borderline impossible in J; you can’t so much as put together fundamental basics like doubly linked lists and hash tables, let alone the aggressive datastructures you need to appropriately represent real problems.

A lie. I put together complex data structures all the time, for major projects no less (just finished a private electronic exchange – stocks, commodities, etc.) all in J, and done in 10% of the time and code it would have taken in a more “mainstream” programming language.

And dear god help you if you need to express an algorithm more complex than quicksort (which is meant as a low water mark.)

More lies.

The reason J failed is because it confuses the ability to tersely express math with the tools software developers actually need.

I’d love to know the definition of “failed.” If “failed” means “didn’t become one of the 10 most popular programming languages,” yeah, it failed. I also don’t see why on earth anyone would want to use such a moronic metric. I could care less how popular a language is. It is irrelevant. As long as it is just popular enough to ensure that it continues to be developed (which is the case with J), it suits me just fine.

APL was a good idea because it used actual math symbols, which allowed mathematicians to write simple math software without becoming programmers.

Taking those symbols away just means it’s useless.

Really, at this point you are just making a fool out of yourself.

There are elegant natural languages, perhaps aboriginal ones in remote countries, that have unique powers for expressing human feelings and perception. The people who learn these will be rewarded, but within the small world of other people who speak these languages.

Mathematica is also beautiful. Moving from APL to Mathematica for me was something like leaving a lovely small town and coming to the city. It took awhile, but I can only go back home for short visits.

John Haugeland said:
“Uh, no, it isn’t. J and APL share the same damning problem: they see the world as arrays, so when it comes time to do anything that isn’t array bound, you get ground to a halt. That’s why they’re both dead languages.”

John,

I routinely perform queries and calculations on huge amounts of data using J. The performance of J has changed the game for me.
No longer do I build large databases with queries that take minutes or hours to run, now I can load the same data in J’s data engine (JDB) and run the same queries in sub-second times. In addition, I have the freedom to do manipulate the query results in ways that would be very difficult in other languages. I’m not saying that J is easy to learn, but the time you spend with J is time well spent.

“J isn’t even particularly efficient in the few data structures it knows how to do.”

“… J and APL aren’t particularly expressive. Whereas yes, their syntax and notation are surprisingly dense, and well suited to trivial math toys, …”

Regarding efficiency, IBM’s APL compiler from the mid 1980’s actually beat their optimizing “H” FORTRAN compiler on boolean array manipulation (presumably because it could “see” the forest of an algorithm expressed in APL better than the “trees” expressed in FORTRAN-style nested loops). So I would be cautious before assuming that J can’t be implemented efficiently.

Regarding paucity of data structures, APL 2 at least has nested arrays, which can make up for some of the blinders (I don’t honestly know if J has them or not). One could just as easily toss tomatoes at LISP and Scheme for “only” having S-expressions, or at Haskell for “only” having algebraic data types (although neither of these is quite true). I have actually heard exactly this done over the years in various venues. Of course for real-world problem solving, one would like to have the widest variety of concepts that can fit comfortably in one’s paradigm, but there is great value in exploring ways of expressing things with a “restricted” set of concepts and language. (E.g., pure functional style, or logic programming, constraint-based, etc.)

But I find your “trivial math toys” remark especially ironic: many, many people would level the same criticism against Haskell (and Clean and Erlang and others you mention as well). Many, many people did, especially a couple of years ago, before STM, RWH, etc.

Can’t we just leave it at “J is interesting, fun, and will change your perspective on what’s possible”? As will Haskell, Clojure, Scheme, Erlang, etc., albeit in different ways.

Why rain on someone’s parade as they experience the joy of a new language? Why not be more charitable? (Hey, Sam, Joy and Charity are another fun couple of languages: check ‘em out!)

I guess I just find the “X isn’t a REAL programming language” kind of talk counter-productive and a little tiresome, independent of the X involved. I’ve heard it said about APL, LISP, C, SML, Scheme, Haskell, Java, Miranda and lots of others over the years, and I’ve enjoyed using all those languages in their own way.

Can’t we leave this kind of “trash talk” to the high school football crowd, or their “grown-up” counterparts, the war and religion crowds? Do we really have to constantly hear this kind of stuff from the programming language geek crowd?

(Yeah, I know: me and Rodney King, both. I’ll get off my own soapbox now . And nothing personal, John, everyone seems to do it … .)

the speed is good. It is a fully dynamic language so good is relative to other dynamic languages.

IMO, data structures is a huge strength of J. Weaknesses, IMO, are the maintainers refusal to add enhancements useful for DSLs, and a lack of batteries.

J’s notation is poorly defined, there are no acceptance tests, et cetera. It isn’t for lack of a free implementation that J has failed; that didn’t stop other non-free languages like Delphi, LISP (in its heyday), Prolog (in its heyday and arguably today, since no free Prolog passes the prolog acceptance tests), et cetera.

The reason J failed is because it confuses the ability to tersely express math with the tools software developers actually need.

Find yourself a problem that J looks like a good candidate for, but which Occam, Haskell or Ocaml don’t look better for, and you’ll be a magician. APL was a good idea because it used actual math symbols, which allowed mathematicians to write simple math software without becoming programmers.

Taking those symbols away just means it’s useless.

Seriously, you could be looking into Clean, Erlang, Mozart-Oz, Fortress, Factor, Haskell, C++, Clojure, the list goes on. Why waste your time on J?