J (programming language)


The J programming language, developed in the early 1990s by Kenneth E. Iverson and Roger Hui, is an array programming language based primarily on APL.
To avoid repeating the APL special-character problem, J uses only the basic ASCII character set, resorting to the use of the dot and colon as inflections to form short words similar to digraphs. Most such primary J words serve as mathematical symbols, with the dot or colon extending the meaning of the basic characters available. Also, many characters which in other languages often must be paired are treated by J as stand-alone words or, when inflected, as single-character roots of multi-character words.
J is a very terse array programming language, and is most suited to mathematical and statistical programming, especially when performing operations on matrices. It has also been used in extreme programming and network performance analysis.
Like John Backus's languages FP and FL, J supports function-level programming via its tacit programming features.
Unlike most languages that support object-oriented programming, J's flexible hierarchical namespace scheme can be effectively used as a framework for both class-based and prototype-based object-oriented programming.
Since March 2011, J is free and open-source software under the GNU General Public License version 3. One may also purchase source under a negotiated license.

Examples

J permits point-free style and function composition. Thus, its programs can be very terse and are considered difficult to read by some programmers.
The "Hello, World!" program in J is
'Hello, world!'
This implementation of hello world reflects the traditional use of J – programs are entered into a J interpreter session, and the results of expressions are displayed. It's also possible to arrange for J scripts to be executed as standalone programs. Here's how this might look on a Unix system:

#!/bin/jc
echo 'Hello, world!'
exit

Historically, APL used / to indicate the fold, so +/1 2 3 was equivalent to 1+2+3. Meanwhile, division was represented with the mathematical division symbol, which was implemented by overstriking a minus sign and a colon. Because ASCII in general does not support overstrikes in a device-independent way, and does not include a division symbol per se, J uses % to represent division, as a visual approximation or reminder.
Defining a J function named avg to calculate the average of a list of numbers yields:

This is a test execution of the function:

2.5
# counts the number of items in the array. +/ sums the items
of the array. % divides the sum by the number of items. Above, avg is defined using a train of three verbs termed a fork''. Specifically Ny is the same as V1 which shows some of the power of J.
Some examples of using avg:
NB. a random vector

46 55 79 52 54 39 60 57 60 94 46 78 13 18 51 92 78 60 90 62

59.2
NB. moving average on periods of size 4
58 60 56 51.25 52.5 54 67.75 64.25 69.5 57.75 38.75 40 43.5 59.75 70.25 80 72.5
NB. a random matrix

46 5 29 2 4
39 10 7 10 44
46 28 13 18 1
42 28 10 40 12
NB. apply avg to each rank 1 subarray of m
17.2 22 21.2 26.4
Rank is a crucial concept in J. Its significance in J is similar to the significance of select in SQL and of while in C.
Implementing quicksort, from the J Dictionary yields:

sel=: adverb def 'u # '

quicksort=: verb define
if. 1 >: #y do. y
else.
,,quicksort y >sel e=.y

Verbs and Modifiers

A program or routine - something that takes data as input and produces data as output - is called a verb. J has a rich set of predefined verbs, all of which work on multiple [data types automatically: for example, the verb i. searches within arrays of any size to find matches:

3 1 4 1 5 9 i. 3 1 NB. find the index of the first occurrence of 3, and of 1
0 1
3 1 4 1 5 9 i: 3 1 NB. find the index of the last occurrence of 3, and of 1
0 3

User programs can be named and used wherever primitives are allowed.
The power of J comes largely from its modifiers: symbols that take nouns and verbs as operands and apply the operands in a specified way. For example, the modifier / takes one operand, a verb to its left, and produces a verb that applies that verb between each item of its argument. That is, +/ is a verb, defined as 'apply + between the items of your argument' Thus, the sentence

+/ 1 2 3 4 5

produces the effect of

1 + 2 + 3 + 4 + 5
+/ 1 2 3 4 5
15

J has roughly two dozen of these modifiers. All of them can apply to any verb, even a user-written verb, and users may write their own modifiers. While modifiers are powerful individually, allowing
  • repeated execution, i. e. do-while
  • conditional execution, i. e. if
  • execution of regular or irregular subsets of arguments
some of the modifiers control the order in which components are executed, allowing modifiers to be combined in any order to produce the unlimited variety of operations needed for practical programming.

Data types and structures

J supports three simple types:
  • Numeric
  • Literal
  • Boxed
Of these, numeric has the most variants.
One of J's numeric types is the bit. There are two bit values: 0, and 1. Also, bits can be formed into lists. For example, 1 0 1 0 1 1 0 0 is a list of eight bits. Syntactically, the J parser treats that as one word. Lists of arbitrary length are supported.
Further, J supports all the usual binary operations on these lists, such as and, or, exclusive or, rotate, shift, not, etc. For example,
1 0 0 1 0 0 1 0 +. 0 1 0 1 1 0 1 0 NB. or
1 1 0 1 1 0 1 0
3 |. 1 0 1 1 0 0 1 1 1 1 1 NB. rotate
1 0 0 1 1 1 1 1 1 0 1
J also supports higher order arrays of bits. They can be formed into two-dimensional, three-dimensional, etc. arrays. The above operations perform equally well on these arrays.
Other numeric types include integer, floating point, complex, extended precision integer, and rational fraction. As with bits, these can be formed into lists or arbitrarily dimensioned arrays. As with bits, operations are performed on all numbers in an array.
Lists of bits can be converted to integer using the #. verb. Integers can be converted to lists of bits using the #: verb. and :
J also supports the literal type. Literals are enclosed in quotes, for example, 'a' or 'b'. Lists of literals are also supported using the usual convention of putting multiple characters in quotes, such as 'abcdefg'. Typically, individual literals are 8-bits wide, but J also supports other literals. Numeric and boolean operations are not supported on literals, but collection-oriented operations are supported.
Finally, there is a boxed data type. Typically, data is put in a box using the < operation. This is analogous to C's & operation. However, where the result of C's & has reference semantics, the result of J's < has value semantics. In other words, < is a function and it produces a result. The result has 0 dimensions, regardless of the structure of the contained data. From the viewpoint of a J programmer, < puts the data into a box and allows working with an array of boxes.
<1 0 0 1 0
+---------+
|1 0 0 1 0|
+---------+
The only collection type offered by J is the arbitrarily dimensioned array. Most algorithms can be expressed very concisely using operations on these arrays.
J's arrays are homogeneously typed, for example the list 1 2 3 is a list of integers despite 1 being a bit. For the most part, these sorts of type issues are transparent to programmers. Only certain specialized operations reveal differences in type. For example, the list 1.0 0.0 1.0 0.0 would be treated exactly the same, by most operations, as the list 1 0 1 0 .
J also supports sparse numeric arrays where non-zero values are stored with their indices. This is an efficient mechanism where relatively few values are non-zero.
J also supports objects and classes, but these are an artifact of the way things are named, and are not data types. Instead, boxed literals are used to refer to objects. J data has value semantics, but objects and classes need reference semantics.
Another pseudo-type—associated with name, rather than value—is the memory mapped file.

Debugging

J has the usual facilities for stopping on error or at specified places within verbs. It also has a unique visual debugger, called , that gives a 2-D interactive display of the execution of a single J sentence. Because a single sentence of J performs as much computation as an entire subroutine in lower-level languages, the visual display is quite helpful.

Documentation

J's documentation includes a , with words in J identified as , , , and so on. Primary words are listed in the , in which their respective are indicated using markup. Note that verbs have two forms: monadic and dyadic. For example, in '-1' the hyphen is a monadic verb, and in '3-2' the hyphen is a dyadic verb. The monadic definition is mostly independent of the dyadic definition, regardless of whether the verb is a primitive verb or a derived verb.

Control structures

J provides control structures similar to other procedural languages. Prominent control words in each category include:
  • assert.
  • break.
  • continue.
  • for.
  • goto_label.
  • if. else. elseif.
  • return.
  • select. case.
  • throw.
  • try. catch.
  • while. whilst.