J is an array programming language, developed in 1990 by Kenneth Iverson and Roger Hui. It is a synthesis of APL (earlier language by Iverson) and FP and FL languages created by John Backus.

Despite sharing the concept and the author with APL, J differs from it quite a lot. For example, J has no concept of a variable — it’s a function-level language, so the best it has are function renames. The authors also dropped special characters from the notation — the programs are written using 7-bit ASCII charset, and each function is written with at most two characters.

A distinctive feature of J is using grammar terms to describe entities of the program. Data pieces are called nouns, functions are verbs, and functions-creating operators are adverbs. Note that J allows to create user-defined adverbs, without restricting the programmer to the built-in ones.

Same as APL, J has only one data structure — hom*ogenous arrays of arbitrary dimensions. To organize more complex data structures, one can use boxing principle inherited from APL.

J introduces a set of block-oriented flow controls typical for procedural languages: loops, conditional statements and exception handlers.

Unlike APL, J programs and data are stored not in workspaces but in script files available to any text editor.

## Examples:

### Hello, World!:

Example for versions j602

1!:2 is the dyadic foreign conjunction for writing text, the left argument is the string to be written and the right argument specifies the file number, a file number 2 indicates that the text is to be written to the screen.

Alternatively we can use currying to convert the dyadic write conjunction into a monadic conjunction using the bond (&) operator and assign it to a named print function.

The printf library may also be used to print text to the screen.

`'Hello, World!' 1!:2]2print=: 1!:2&2print 'Hello, World!'load 'printf''' printf 'Hello, World!\n'`

### Fibonacci numbers:

Example for versions j602

This example uses the recursive definition of Fibonacci numbers. `@.`

(agenda) is a higher order dyadic function taking an array of functions(a gerund, created by tying together individual functions using the tie conjunction represented by a back-tick character) on the left and a function on the right that computes the index of the function in the function array(gerund) to be applied on the called argument.

The general call to agenda:

f1`f2@.g x

The function g is used to calculate an index using the argument x, this index is then used to select the function to be applied from the left argument of agenda, the function array. The function that is selected is then applied to the original argument x.

In the case of the above Fibonacci function, applying the semantics of the agenda function we get a function which checks whether its argument is less than two, if it is then 1 is returned otherwise the formal recursive calculation of the Fibonacci number is called on the argument.

`load 'printf'fibr=: 1:`(-&2 +&$: -&1)@.(2&<)"0fstr=: '...' ,~ ,~^:4 '%d, 'fstr printf fibr >: i.16`

### Fibonacci numbers:

Example for versions j602

This example uses iterative definition of Fibonacci numbers.

`load 'printf'fibi=: 3 : '(,+/@(_2&{.))^:y(0 1)'fstr=: '...' ,~ ,~^:4 '%d, 'fstr printf }.fibi 15`

### Fibonacci numbers:

Example for versions j602

This example uses Binet’s formula.

`g =: -: >: %:5`

is equivalent to `g =: 0.5 * (1 + 5 ^ 0.5)`

and assigns name `g`

to value of golden ratio. `%:`

extracts square root of the number, `>:`

increments the number, `-:`

divides the number by two. Operations are done from right to left, unless there are no parenthesis in the formula.

`fibb=: (%:5) %~ g&^ -- (1-g)&^`

is equivalent to `fibb =: (0.2 ^ 0.5) * (g &^ -- (1-g) &^)`

; this defines a formula for F(n) given the value of n. `%~`

is division, with dividend and divisor swapped.

`i.16`

generates numbers from 0 to 15, inclusive.

`load 'printf'g=: -: >: %:5fibb=: (%:5) %~ g&^ - (1-g)&^fstr=: '...' ,~ ,~^:4 '%d, 'fstr printf fibb 1+i.16`

### Factorial:

Example for versions j602

This example implements three methods of calculating factorial. `fact`

represents a factorial function which generates the first `n`

integers as an array and multiplies them together. `factr`

represents the recursive definition. `!`

is the built-in factorial function.

`load 'printf'fact=: [: */ [: >: i.factr=: 1:`(]*$:@<:)@.*'!%d = %d' printf (,"0 fact) i.17x'!%d = %d' printf (,"0 factr) i.17x'!%d = %d' printf (,"0 !) i.17x`

### Quadratic equation:

Example for versions j602

Run `calc''`

in an interactive J session after loading the file. The function `calc2`

calculates the roots of the equation using J’s built in root function(`p.`

).

`print=: 1!:2&2read=: 3 : '". 1!:1[1'a=: 0&{ [ b=: 1&{ [ c=: 2&{d=: *:@b - [:*/4,a,croots=: ([:-b%2*a)`(+:@a %~ (,-)@%:@d + -@b)@.([:*/*)input=: 3 : 0A=: read'' [ print 'A = 'B=: read'' [ print 'B = 'C=: read'' [ print 'C = ')calc=: 3 : 0input''if. A=0 do. print 'Not a quadratic equation' throw. end.rt=: roots A,B,Cdisp rt)disp=: 3 : 0form=: ((('('&,)@":@{.,',',(,&')')@":@}.)@+.)`":@.(=+)if. 1<# ~.y do. print 'x1 = ', form 0{y print 'x2 = ', form 1{yelse. print 'x = ', form {.yend.)calc2=: 3 : 0input''rt=: ;}.p.|.A,B,Cdisp rt)`

### Fibonacci numbers:

Example for versions j602

Maxtrix closed form

`load 'printf'mat =: 1 1,.1 0fibm=: 3 : '1 { , mat&(+/ . *)^:y mat'"0fstr=: '...' ,~ ,~^:4 '%d, 'fstr printf fibm >:i.16`

Fibonacci Matrix Closed Form

### CamelCase:

Example for versions j602

`alpha`

is the set of upper and lower case alphabetic characters.

`camel`

is an explicit solution to the problem, meaning that the variables to the function(`y`

) are mentioned in the function body. The strategy used is to calculate the indices(`i`

) of the alphabetic characters from the bit vector(`b`

) which represents whether or not a character is alphabetic. The function then takes the leading index of each interval of these alphabetic characters and uses that to replace them by their capitalized form. Finally the string is sieved using `b`

so that it contains only the alphabetic characters.

`camel2`

is a tacit definition, it cuts the input string at the delimiters(non-alphabetic characters), leaving a collection of boxed strings. The leading character of each of these boxed strings is then capitalized and they are all concatenated together forming the final result.

`camel3`

takes advantage of the built-in libraries, a regular expression is used to split the string into boxed strings, each of these is then capitalized and concatenated.

In all three functions the input is first converted to lower case.

`check`

can be used to ensure that all the functions produce equivalent output.

`alpha=: a.{~,65 97+/i.26camel=: 3 : 0y=. tolower yi=. I. (> 0,}:) b=. y e. alpha(b # toupper@(i&{) i} ]) y)isalpha=: e.&alphacapital=: (toupper@{.,}.)^:(1<:#)format =: [: ,&' ' tolowercase =: [: ; [: capital&.> ] <;._2~ [: -. isalphacamel2 =: case@formatrequire'regex text'camel3=: [: ; [: capitalize&.> [: '[a-zA-Z]+'&rxall tolowercheck=: [: ,. camel;camel2;camel3`