A value in electrical engineering equivalent to the square root of negative one. It is analagous to i in the world of mathematics.

From the J FAQ:


J is a very high level general-purpose language, with a strong emphasis on functional programming and array processing. J was designed and developed by Ken Iverson and Roger Hui, and implemented by Iverson Software Inc. (ISI).

J is distinguished by its simple and consistent rules, a large set of built-in functions, powerful facilities for defining new operations, and a general and systematic treatment of arrays. It is ideal for complex analytical work, modelling, and rapid application development.

It is available on most popular hardware platforms, and the script files 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.

This is the genealogy of the programming language J:

J is a child of APL.
J was born in year 1996, and has not changed much since that time.

This genealogy is brought to you by the Programming Languages Genealogy Project.

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 cryptic syntax. 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.

For the skeptics among us, consider the following C-language snippet:

int a[] = { 1, 2, 3 }, b[] = { 3, 2, 1 }, c[], i;
for(i = 0; i < 3; ++i)
    c[i] = a[i] + b[i];
and compare it to the following J:
a=. 1 2 3
b=. 3 2 1
c=. a + b
I think there will be few arguments about which is clearer in intent.

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:

for(i=3; i < length_of_v; ++i)
   result[i-3] = v[i] > v[i-1] && v[i] > v[i-2] && v[i] > v[i-3];

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.

In physics, J (vector) is equal to the sigma sum of all k for qk * mk * Fk (vector), where q is the charge of the k particle, m is the number of k particles in a volume, and F is the flux of the k particles through the volume. The dot product of J and the area vector is equal to I, the current. A scalar J can be defined as current/area.

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.
J is a pretty cool programming language. Here's a function that outputs Fibonacci numbers:
fib=:1:`((],+/@(_2&{.))@$:@<:)@.*
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.

Ahem, "tadaa".

J (jay)

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

J is etymologically most closely related to i, y, g; as in jot, iota; jest, gesture; join, jugular, yoke. See I.

J is a compound vocal consonant, nearly equivalent in sound to dzh. It is exactly the same as g in gem. See Guide to Pronunciation, §§ 179, 211, 239.

 

© Webster 1913.

Log in or registerto write something here or to contact authors.