
J Has the Best Development Environment (2009) - epsylon
http://prog21.dadgum.com/48.html
======
james_hague
I'd like to clarify that I was using J6.02 for Windows when I wrote that. You
can still download it from jsoftware.com.

Since then the priority has been for J to be platform independent, but it's
resulted in some big steps backward for beauty and usability. That's for the
environment only--not the language.

------
wyc
I have some thin (read: incomplete) notes that hint at how math-oriented the J
verbs are:
[http://wycd.net/notes/jlang/jlang.pdf](http://wycd.net/notes/jlang/jlang.pdf)

Among my favorite parts of the language is the sole set of vocabulary[0] that
you have to learn to be proficient in J. It's daunting at first, but after
this "alphabet" is internalized, you can understand most code. Just as our
integral symbols save us from writing out "Integral()", J's operators are
shorthand for fundamental computational functions. For example, here's a very
naive kNN implementation in J, without pulling in any "jlearn" external
libraries or anything:

[https://github.com/wyc/snippets/blob/master/j/knn.ijs](https://github.com/wyc/snippets/blob/master/j/knn.ijs)

One of the stated purposes of J is the clear expression of algorithms. How are
you supposed to clearly do that with layers upon layers of abstractions? The
language excels at matrix and statistical operations on sets of homogeneous
data. Many financial institutions deploy J's close sister, K (also a
descendant of APL) coupled with KDB[1].

Does it have potential for use on "Big Data"? Maybe. It's not SMP, but the
interpreter is rather light, so it can be spun up in multiple processes.
Cutting up the data correctly is still a problem. I would also not use J to
write a webapp; CRUD isn't its strong point.

Some more examples of J:
[https://github.com/wyc/snippets/blob/master/j/jtalk/examples...](https://github.com/wyc/snippets/blob/master/j/jtalk/examples.txt)

Come hang out at #jsoftware on freenode to find people much more knowledgeable
than me. :P

[0]
[http://www.jsoftware.com/help/dictionary/vocabul.htm](http://www.jsoftware.com/help/dictionary/vocabul.htm)

[1] not the kernel debugger, but the time-series K database:
[http://kx.com/kdb-plus.php](http://kx.com/kdb-plus.php)

~~~
scottlocklin
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...](http://www.jsoftware.com/jwiki/DevonMcCormick/MinimalBeginningJ)

A more wordy vocabulary for beginners:
[http://www.jsoftware.com/jwiki/NuVoc](http://www.jsoftware.com/jwiki/NuVoc)

------
minikomi
I've been dabbling with learning J recently and, yes, it's really really
humbling. However, I think it can be much easier. The thing I have the most
trouble with is, predictably, unfamiliarity with the large amount of verbs.

So, what to do?

I'm beginning to think approaching it more like a foreign language will make
more sense - i.e., reading & spaced repetition of phrases (short programs -
J's specialty!) / vocab (useful hooks, forks) using a flash card system.

It's a compelling language to learn (even just for the fact you can pretty
much program using a pen and paper while waiting for the bus - short little
rows of verbs you build out gradually as you reason about it or type them in
your iphone), and I hope my approach has merit.

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

That one still looks very cryptic, though.

~~~
minikomi
Ah, good find! I'll give it a whirl.

~~~
RBerenguel
Actually, I'm learning APL with a homemade Anki deck (APL is slightly easier
for me to read than J, since it uses symbols)

------
S4M
>> The IDE is more akin to Python's IDLE than monstrosities which may come to
mind. There's a window for entering commands and seeing the results, and you
can open up separate, syntax-colored editor windows, running the contents of
each with a keypress. It's nothing groundbreaking, but it's something that
most languages don't provide.

What? I have considered that standard for all the languages that have an
interpreter (which is roughly, everything except C,C++,C#, Java).

~~~
mgraczyk
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>

~~~
S4M
Oh, that's nice, thanks - I haven't used C# since 2008. What you said just
reinforces my point: the OP boasts over a feature that is very, very common.

~~~
Avshalom
it's wasn't just a repl it's a graphical repl (important on windows with its
horrible terminal) with an integrated editor it was more like (wait for it)
Dr.Ed or IDLE.

~~~
S4M
In that case something like a screenshot wouldn't have hurt to make his point.

On a totally different topic, are you Avshalom as well on #emacs on freenode?
If that's the case I once spoke to you about improving how ESS shows graphics
- something I haven't worked on further, sadly.

------
adamnemecek
Speaking of exotic languages, I'm somewhat intrigued by Rebol and Red. How bad
of an idea is investing any time into learning either of these?

~~~
purpletoned
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.

~~~
kbd
> The desktop GUI is stuck in the 80s and as far as I know even that isn't an
> option for mobile.

It's a shame that REBOL was open sourced a decade and a half too late. Back
when Perl was still king of scripting languages and Python/Ruby etc. hadn't
taken over for Perl yet, REBOL could have had success. The community was fun
and creative and the implementation seemed like it would be small and able to
be improved through open source.

Just checked, and the repository hasn't had a checkin for 7 months:

[https://github.com/rebol/rebol](https://github.com/rebol/rebol)

------
chubot
I like vectorized languages -- I know R fairly well, and used to use Matlab.

J's syntax, where everything is a single character, kind of turns me off. Is
that incidental or is the syntax essential to the language? (In the case of
Lisp, the "weird" syntax isn't incidental but rather essential, since code is
data)

If it's incidental, I'd like to see some elegant J programs "written out" with
some more friendly syntax.

EDIT: If you want a laugh, download the source for J, and run wc -l _.c_.h.

[http://www.jsoftware.com/source.htm](http://www.jsoftware.com/source.htm)

~~~
minikomi
Check out Tracy Harms's talk:

[http://www.infoq.com/presentations/j-language](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](http://www.jsoftware.com/help/learning/03.htm)

~~~
huehue
I guess it's a matter of taste.

As someone versed in both APL and K/Kona, J's syntax puts me off as well.

~~~
Avshalom
J suffers vs APL/K. The verb trains; number of verbs vs number of available
symbols; variable lengths and semantic baggage we bring to various symbols
contribute to a much worse 'line barf problem'. I understand why Iverson went
with ascii but frankly I don't even know APL beyond 'advanced calculator'
level but every time I look at an APL program it just seems cleaner.

~~~
seanstickle
This is my difficulty with J as well.

APL has a better mental "feeling" for me, more like mathematical symbols.
Oftentimes, these are pretty direct.

Want to drop the first element of a vector?

APL: 1 ↓ 1 2 3 4 5

J: 1 }. 1 2 3 4 5

The APL version looks like a drop to me. The J version looks like two
characters that I have to remember the meaning of.

I'm sure if I was deeply proficient at J, the two-characters would stand out
by their meaning, but it's hard for me to get that far when APL is so much
cleaner for me to read.

~~~
klibertp
The APL version looks like addition (cons, prepending value to a list) to me.
The point being that you have to learn the meaning of symbols anyway, no
matter which character set they use. Going for easier input (from the
keyboard) and sacrificing a bit of legibility for this is a perfectly fine
design trade off to me.

------
kevinSuttle
I'd love to see screenshots or videos of the more visual parts of the
environment. Especially the Labs.

------
ww2
one hurdle of J is that the verb train approach is too raw.

