This book should also be mentioned http://www.lulu.com/shop/henry-rich/j-for-c-programmers/ebook/product-17439968.html
Being a mathematician, the most important thing J brought me is a complete other way of thinking. And always remember, the learning curve remains steep quite some time. Well, at least it did for me. R.E. Boss > -----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 20–30 years programming, > spending 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 ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
