It is available on most popular hardwareplatforms, and the scriptfiles used to represent programs are completely portable. Only ASCII characters are used, and there are no reserved words: primitives are represented by single characters (such as + and <), or by a character followed by a period (+. for Boolean OR and <. for lesser-of, or minimum), or by a colon (+: for not-OR and <: for less than or equal).

Vectors (lists), matrices (tables), and higher-rank arrays are treated as single entities. Thus a+b adds a to b, whether they are single numbers, lists or tables.

In other words, it's another successor language to APL (which, you will note, is mentioned as little as possible). Like K, it does not require a special font (thought to be one of the reasons why APL wasn't so popular). However, apart from some success in the financial modelling community, J (and K) haven't found widespread popularity. Apparently the need to combine extremely efficient array primitives in novel ways is either less useful or harder to justify than might be hoped.

As noted above, J is a derivative of APL which restricts its character set to ASCII for the sake of portability. That is, it is an array-based dynamically-typed language in which one can do highly impressive things with extremely crypticsyntax. In fact, I would say that it goes above and beyond the call of duty as far as being compact and powerful, blowing by the likes of Perl in that department.

Now, many will claim, ``This is not a good thing; it's hard enough to read the languages we already have...how on earth are we going to deal with this?'' However, I think that J (as designed by Ken Iverson and company) really delivers on its promise of being a useful pedagogical tool, especially for mathematics.

However, that is not to say that J is always going to be transparent to anyone who reads it; consider 4 ({: > >./@}:)\ v. To the unitiated, this looks like gobbledygook, like line noise. However, using the rules set forth in The J Dictionary, this can be decoded rather cleanly:

Reading from the outside in, we see that it applies a monadic (one-argument) operator to successive values of a sliding window of size 4 over v and returns the results. (This comes from the pattern 4 f\ v.)

Looking deeper, we see that it compares (>) the tail or last element ({:) of the window to something else.

Finally, we see that the other operand is the maximum (>./) of the result of (@) ``curtailing'' the window (}:).

Putting that all together, we see that, for each window, it tells us if the last element is greater than the other three; the equivalent in C:

If one puts the time and effort into learning the symbols behind the language, there is a lot to be gained here. For further information, see http://www.jsoftware.com/, where free copies of the software and HTML versions of the documentation are available.

Also a source of boundless merriment in Physics 16, Winter 2001 term, at Dartmouth College. As the great Professor Gleiser was talking about J, saying stuff like "J is pointing in this direction" and "J is very large", a group of cohorts and I were holding back laughter...as I myself am a very large J(ay). When the Professor stopped to ask what was so funny, we told him. From that point on, whenever he was about to do something with current/area value, he'd say something to me first, such as, "Jay, I need you to stay constant in time", or when he was differentiating "J", he wrote the standard dJ/dt on the board and remarked, "Hey, Jay, you've got a second job now, you're a DJ now!" I only wish it were that much fun when we got to relativity.

J is the oldest of the five authors (J, E, D, P, and R) of the Pentateuch or Torah, the first five books of the Bible, theorized by Biblical scholars. S/he may have lived between 950 and 750 BC, though this dating is in dispute. J is short for Jahwe, the German spelling of Jehovah or Yahweh. J consistently refers to God by the name Yahweh, while other authors use different words.

The writings of J in the Bible are considered by many to be more engaging, interesting, humorous, and human than the work of the other authors. J is the author of the second creation story in Genesis (Genesis 2:4-25) and the famous poetic image of God strolling around in the Garden of Eden in "the cool of the day" (Genesis 3:8). Some also credit J with the story of the warrior woman Deborah in the book of Judges and other parts of later books.

Conservative literary scholar Harold Bloom injected J into the mainstream consciousness with his controversial bestselling work The Book of J (1991), which theorized that J was female.

If you've never seen J before, it's probably not easy to
try to figure out what it does, so I'll try to explain what
it does. I'll begin with pointing out a few things that
will be helpful:

Functions may take one or two arguments, as in !4
(monadic verb) or 1+2 (dyadic verb). Each verb
may behave differently depending on its use. Arguments
can be functions or values.
Evaluation happens right to left which is, when you get
used to it, pretty intuitive. The idea is that A+B+C is
really "A plus the result of B plus C". There is no
operator precedence.
Finally, arguments in J are always treated as arrays, even
scalars - they're just arrays of rank 0. Thus all functions
can be used on arrays of any rank and size where that
makes sense.

Let's call fib, for example like this:

fib 7
1 1 2 3 5 8 13 21

The argument 7 will be "appended" at the right side of the
expression. Note that negative arguments don't make sense
here since the Fibonacci numbers start at index 0.

The monadic verb *
("sign") is applied to our argument, resulting in
1 if it's positive, 0 if it's zero (and -1 if it's negative)
. The result is passed on to the verb on the left, which is...

@. ("agenda"). This dyadic function acts as something like an
if- or switch-statment of some languages; depending on
the value of its right argument it will return one of the
functions on its left. 0 yields the first, 1 the second
and so on, these functions being separated by `
("gerund").

The first function is 1:, which is basically a
constant function returning the value 1 regardless of its
argument, and it will only get called with argument 0.
Positive arguments will be applied to the function

(],+/@(_2&{.))@$:@<:

(parentheses are only used for "grouping" words into
separate "statements"). This is where the magic happens.

Monadic <: ("decrease") will return its argument minus 1.
@ doesn't really do anything other than passing its argument
on to the left; it's there to prevent the language from
treating this expression as a "fork", a concept that will
be explained below.

$: is a "self reference" i.e. refers to the whole
function again, making a recursion. Here we can see that,
while the argument to fib is positive, the
function will keep calling itself, each time decreasing
the argument by one. However, as we saw above, as soon as
the argument reaches zero, 1 will be returned, and the
recursion can start "unwrapping" itself.

This result is passed on, to the function

],+/@(_2&{.)

The statement _2&{. returns the two last elements
in it's argument. The dyadic verb {. ("head") normally
returns elements from the beginning of an array, but the negative left
argument (_2) makes it "wrap around". & ("compose")
ties an argument to a function, creating a new function.
This is also known as "currying" a function.

@ again passes this result to +/. Dyadic + is
the old familiar plus operator, but the / function
causes it to be inserted between all the elements in the argument,
effectively acting as a "sum over" function. So, now we
have the sum of the two last elements.

] ("right") just gives the right argument back
and , ("append") will put the surrounding arguments
together, creating an array. This way, the first argument
gets appended to itself ({. 1 returns 0 1, filling
the empty parts of the array with zeros), yielding 1 1.
The next time this "inner" function gets called, it's with
this as argument, producing 1 1 2 (since 2=1+1). And so
on, until all recursions have returned. The end result
is the Fibonacci numbers with indexes 0 through 7.

. J is the tenth letter of the English alphabet. It is a later variant form of the Roman letter I, used to express a consonantal sound, that is, originally, the sound of English y in yet. The forms J and I have, until a recent time, been classed together, and they have been used interchangeably.

In medical prescriptions j is still used in place of i at the end of a number, as a Roman numeral; as, vj, xij.