J's performance is a blend of the language design, Roger Hui's years of implementation, and probably Arthur Whitney's influence.
Also, there isn't anything you can do with lambda notation that you cannot do in J. J's gerunds have all the expressiveness of lambdas, and you can implement anything in them up to and including call/cc. But you probably should not go down that path because: * This kind of programming is mostly only meaningful for things that you can do in other ways, and * the current implementation gives awful performance for gerunds-each-step-of-the-way code, and * J's arrays give you most of the power of lambdas (and what it leaves off is arguably a good thing). For example, a list of 1s and 0s is semantically equivalent to a list of variables in a constrained domain. And if you are using something like (gensym), you should not look down your nose at array indices. In other words: you could easily implement threads using gerunds, but the performance will be so awful that you would not want to use them in the current implementation of J. Anyways, if you like Scheme, I'm not sure why you would have a problem with syntax from the 60s. And, for that matter, J is something of a dual of Scheme. For example, J's dyads serve a role similar to Scheme's cons cell, but without bogging down data representation. Also, as for booleans -- I have a strong opinion that booleans should be 1s and 0s and not some other data type. If you are calling them booleans, instead of truth values, it just makes sense to be consistent with what George Boole was doing. That said, when I want to translate J into a language other people understand, Javascript is usually my first choice. But one of the nicest things about J is one of its most reviled features: it's line oriented. So I can iterate testing an expression by recalling the previous line, editing it, and hitting enter. In contrast, for example, in DrRacket I have the annoyance of having to position the cursor at the end of the input region before hitting enter, and even then I do not get a session log showing the history of statements with their associated results. Anyways, it's great that arrays are starting to appear in other languages. I can hope that within the next years languages like python will have the array expressiveness that APL had back in the 60s. But languages like python have so many irregularities that I don't see any reason to use them over something like perl (well... except I'm getting paid to use them...). -- Raul On Sun, Dec 2, 2012 at 12:43 AM, Alex Giannakopoulos <aeg...@blueyonder.co.uk> wrote: > I am not sure Ian really meant BASIC when he said "people who know BASIC". > Perhaps the gist of what he meant was "people who want to do basic > programming". > > No-one really uses old-style BASIC today, regardless of what marketing > blurbs may say. I have *never* seen anyone recommend it to people who ask > "what language should I start with?" on any programming forum whatsoever. > > OTOH, the languages that J would be competing with, if it wanted to become > more widespread, would be today's popular scripting languages - the likes > of javascript, python, ruby, even PHP. These are today's "BASIC"s. And > believe me, they certainly have facilities for booleans and not only that, > many of them are functional, or functionally oriented, as well as having > popular features like-object orientation and other modern concepts. > > The J community would be doing itself a disservice (perhaps even absenting > itself from reality) if it thought it was competing with the world of > BASIC!! We are not in the 80s any more. Javascript will easily do maps, > and its default container is basically a dictionary. It features an > interesting and very powerful way of doing OOP using prototypes. Python > has handy things like list comprehensions, several tons of (established) > libraries and is fast moving towards becoming the sane individual's Perl. > Even my own favourite (if not widespread) educational language, Scheme, is > starting to make a serious appearance with systems like PLT/Racket which > are pretty complete. All these languages can be used to make teaching > examples as elegant as Bo's, in almost as few lines. And elegant though J > might be, nothing will ever beat lambda-calculus in that arena, not even > Iverson notation! (personal opinion, I know) > > So let us not kid ourselves with anachronisms re line-numbers in BASIC... > sheesh. > > The question is what is the real advantage of J. Why are we using it? > For me the answer would be power of expression and PERFORMANCE. I doubt > that I would use it if it wasn't about 100x faster than a good Scheme > interpreter. I won't even mention the superiority in terms of space > requirements. You can get near-C performance, without the associated > overhead baggage, plus functions for free. > > These are *real* issues, otherwise why bother? So, I see J as an > incredibly flexible and powerful RAD environment, which frankly, I think > has no peer at the moment. From concept to production in amazing time. > Not to mention that if it ever gets to use CUDA-like GPU technology, it > will blow *everything* out of the water. > > So I think that *THIS* is what has to be emphasised when people ask why the > should bother with the steep learning curve. Frankly. I'd struggle to > think of a reason why anyone would otherwise bother with concepts like > capped forks, a binary infix syntax from the 60s (which may be very wise, > but certainly not in today's mainstream) and boxes. And while I love the > array operation philosophy, it is starting to appear in other languages > too, you know.... no disrespect meant to anyone or anything, just trying to > reflect something of the attitudes I see out there every day. > > ====== > > Love the cos rule suggestion by the way Ric, THAT'S what I'm on about, > that's the way to showxase J for beginners! > > Should be included in the math/misc/trig file. (At the moment it only has > the most basic of stuff, function redefinitions and some dfr-rfd stuff - > hardly a beginners trig library.) > > > > On 1 December 2012 23:10, Boyko Bantchev <boyk...@gmail.com> wrote: > >> On 1 December 2012 16:17, Ian Clark <earthspo...@gmail.com> wrote: >> > A "training wheels" form of J, tailored to people who know BASIC, >> > would be so easy to write. >> >> Not necessarily. A BASIC thinking can be so different that hardly >> any tailoring could possibly exist as a bridge to J. >> >> > ---------------------------------------------------------------------- > For information about J forums see http://www.jsoftware.com/forums.htm ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
