J Has the Best Development Environment (2009)

It recently came to my mind that Math, J, lisp, ml are just anti-marketing artefacts. But on the intellectual/UX they're on point. When you have a good abstractions, and very consistent and orthogonal ones, appearance becomes almost irrelevant. They help you think and that's what matters.

FWIIW, the Jd database is pretty good (which works much like kdb+). It's not designed to work on distributed systems (kdb+ can do this), but it wouldn't be too difficult to make it do this.

I recently wrote a discrete wavelet transform algorithm in J. It took 4 lines. I could probably have done it in 1. Granted it took me a while to write these 4 lines, but it's pretty cool being able to take the whole thing in at a glance.

While I was at it, I wrote my own query system for a much larger than memory dataset; that part only took a few minutes.

One of the great things about J: it teaches you to appreciate the matrix subsystems of things like R. You can do a lot of J in R if you stay away from data.frames.

Oh yeah, while the IDE is pretty nice, I use it in emacs.

Some resources: Minimal J for beginners: http://www.jsoftware.com/jwiki/DevonMcCormick/MinimalBeginni...

A more wordy vocabulary for beginners: http://www.jsoftware.com/jwiki/NuVoc

There is a public Anki (spaced repetition app) deck available: https://ankiweb.net/shared/info/832417998

That one still looks very cryptic, though.

I learned J in very much this way, although instead of reading J code I chose to write it. I worked my way through a cheatsheet (http://www.jsoftware.com/jwiki/HenryRich?action=AttachFile&d...) inventing little toy problems to solve with particular verbs along the way. But words (verbs, gerunds, etc.) are not enough - you need to know the rules for composing them. Fortunately this is rather easy to learn.

I'd say that you need to know about hooks, forks (trains in general) and ranks before starting to learn the vocabulary. But maybe you can learn those things along the vocabulary too.

I have been toying with J for the past few years, and I think you only appreciate it when you see it as equivalent to mathematical notation, alien at first, but succinct and very useable when you know what the symbols mean. See Iverson's paper on 'Notation as a Tool of Thought' (http://www.jsoftware.com/papers/tot.htm). I am self-teaching mathematics, and even when trying Julia as a math tool, I find the basic unit of J, the array, as more amenable to my studies. It's interesting how there is all the talk about 'vectorization' and such in other languages, which J has been doing for decades. J is functional, and can have 'for' loops, but loopless programming is encouraged and easy. When dealing with images or large data sets that are memory mapped, the operations are succinct and powerful and eye-opening. My latest epiphany from moving away from using J as just a sophisticated calculator came after watching the 4 videos by Martin Saurer (https://www.youtube.com/watch?v=VSJpJt3c11c). Iverson's books on arithmetic and calculus using J are mind-blowing. You are engaged, not distracted by the language. J is fast too. From another talk (https://www.youtube.com/watch?v=IKfJRyoiBlY&feature=youtu.be), creating a 1x10^6 element array and summing over columns or rows is fast, and the code is simply:

  b=: ? 1000 1000 $ 10
  +/+/b

These two lines create a 1x10^6 element array and then sums the columns, and then sums the single row total. Fast. These guys have really distilled the libraries and made them work well with J (lapacke c interface to lapack). You get c speeds from an interpreter. I guess this is why q with kdb+ is used so much by the finance community despite how expensive it is. Anyway, I am currently staying with J, and I am writing my little tasks in J and julia to see how they fare against each other in speed and development efforts. Now that I have the knowledge to do Qt interfaces for J, I may just stick with J for the sheer joy.

Both of the major C# distributions (mono and CLR with VS) come with a repl now:

    $ csharp
    Mono C# Shell, type "help;" for help

    Enter statements below.
    csharp> var seq = Enumerable.Range(0, 100); 
    csharp> var mod17 = from num in seq
          > where num % 17 == 0
          > select num
    csharp> foreach (var n in mod17) { 
          >    Console.WriteLine(n);
          > }
    0
    17
    34
    51
    68
    85
    csharp>

Well, it's better than watching a movie instead, but not much.

Depends on what you want to do with it. If you're looking to develop mobile or desktop applications it's almost useless. The desktop GUI is stuck in the 80s and as far as I know even that isn't an option for mobile.

If you're doing web apps, it's probably worth a try provided you don't mind writing your own libraries for a lot of stuff.

Rebol is dead. The closed source is not maintained and was released as abandonware.

A few people have tried to keep it going, there is even a version for Android, but there have been no commits for over a year.

Check out Tracy Harms's talk:

http://www.infoq.com/presentations/j-language

Or, perhaps, this chapter of the (rather dense) "Learning J":

http://www.jsoftware.com/help/learning/03.htm

> where everything is a single character

Most things in J are actually two characters, take a look at the Vocabulary (http://www.jsoftware.com/help/dictionary/vocabul.htm)

> I'd like to see some elegant J programs "written out" with some more friendly syntax

The problem with J is that the syntax is highly context sensitive, not the length of identifiers. See here: http://www.jsoftware.com/jwiki/Guides/Language%20FAQ#Guides....

Also, you can use aliases for every word, which are defined in stdlib. You can write "each", "cut" etc. if you want. The reason nobody does that is a little complex.

J is suited for exploratory programming and rapid prototyping. This means that expressive power per character should be as high as possible - and J delivers on this promise. Also the standard J words you can see in the Vocabulary are all there is to J. Everything else is always defined in terms of those and you can't define words with symbolic names, like you can in Haskell, OCaml etc. - so once you know those, you can say you know the language. And as for reading J code, it's meant to be read with the help of the J system: you have at least three possible representation to choose from when viewing J code, and you have ability to evaluate each subexpression to see what it does.

Anyway, J is hard to learn, but after initial hump it's a pleasure to write, and then after a while it becomes possible to read it. In exchange for this difficulty level you get incredible expressive power and performance.