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 (also by Iverson). 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 (or primitive) 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 (such as [] {} "" `` or <>) 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 (where every name exists in a specific locale) 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 (GPLv3). 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:
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:
(Note that current j implementations install either jconsole or (because jconsole is used by java), ijconsole and likely install this to /usr/bin or some other directory (perhaps the Application directory on macOS). So, there's a system dependency here which the user would have to solve.) 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 (÷). Because ASCII does not include a division symbol per se, J uses % to represent division, as a visual approximation or reminder. (This illustrates something of the mnemonic character of J's tokens, and some of the quandaries imposed by the use of ASCII.) Defining a J function named avg to calculate the average of a list of numbers yields:
avg=: +/ % #
+/ sums the items of the array. # counts the number of items in the array. % divides the sum by the number of items. This is a test execution of the function:
avg 1 2 3 4 2.5
Above, avg is defined using a train of three verbs (+/, %, and #) termed a fork. Specifically, (V0 V1 V2) Ny is the same as (V0(Ny)) V1 (V2(Ny)) which shows some of the power of J. (Here V0, V1, and V2 denote verbs and Ny denotes a noun.) Some examples of using avg:
v=: ?. 20 $100 NB. a random vector v 46 55 79 52 54 39 60 57 60 94 46 78 13 18 51 92 78 60 90 62 avg v 59.2
4 avg\ v 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
m=: ?. 4 5 $50 NB. a random matrix m 46 5 29 2 4 39 10 7 10 44 46 28 13 18 1 42 28 10 40 12
avg"1 m NB. apply avg to each rank 1 subarray (each row) of m 17.2 22 21.2 26.4
Rank is a crucial concept in J. Implementing quicksort, from the J Dictionary yields:
The following is an implementation of quicksort demonstrating tacit programming. The latter involves composing functions together and not referring explicitly to any variables. J's support for forks and hooks dictates rules on how arguments applied to this function will be applied to its component functions.
Sorting in J is usually accomplished using the built-in (primitive) verbs /: (sort up) and \: (sort down). User-defined sorts such as quicksort, above, typically are for illustration only. The following example demonstrates the usage of the self-reference verb $: to recursively calculate fibonacci numbers:
This recursion can also be accomplished by referring to the verb by name, although this is of course possible only if the verb is named:
The following expression exhibits pi with n digits and demonstrates the extended precision abilities of J:
n=: 50 NB. set n as the number of digits required <.@o. 10x^n NB. extended precision 10 to the nth * pi 314159265358979323846264338327950288419716939937510
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:
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
produces the effect of
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:
… excerpt ends here. Continue reading the full article.
