The J programming language, developed in the early 1990s by Ken Iverson and Roger Hui, is a synthesis of APL (also by Iverson) and the FP and FL functional programming languages created by John Backus (of FORTRAN, ALGOL, and BNF fame). Kenneth E. Iverson (17 December 1920, Camrose, Alberta/Canada –October 19, 2004,Toronto, Ontario/Canada) was a computer scientist most notable for developing the APL programming language. ... Roger Hui was co-developer of the J Programming Language. ... APL (for A Programming Language, or sometimes Array Processing Language) is an array programming language based on a notation invented in 1957 by Kenneth E. Iverson while at Harvard University. ... FP (short for Function Programming) is a programming language created by John Backus to support the Function-level programming paradigm. ... FL (short for Function Level) is a programming language created at the IBM Almaden Research Center by John Backus, John Williams, and Edward Wimmers in 1989. ... Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions. ... John Backus (born December 3, 1924) is an American computer scientist, notable as the inventor of the first high-level programming language (FORTRAN), the Backus-Naur form (BNF, the almost universally used notation to define formal language syntax), and the concept of Function-level programming. ... Fortran (also FORTRAN) is a computer programming language originally developed in the 1950s; it is still used for scientific computing and numerical computation half a century later. ... ALGOL (short for ALGOrithmic Language) is a programming language originally developed in the mid 1950s which became the de facto standard way to report algorithms in print for almost the next 30 years. ... The Backus-Naur form (BNF) (also known as Backus normal form) is a metasyntax used to express context-free grammars: that is, a formal way to describe formal languages. ...

To avoid the problems faced by the special character set of APL, J requires only the basic ASCII character set, resorting to the use of dot and colon characters to extend the meaning of the basic characters available. For other uses, see ASCII (disambiguation). ...

Being an array programming language, J is very terse and powerful, and is often found to be useful for mathematical and statistical programming, especially when performing operations on matrices. Array programming languages (also known as vector or multidimensional languages) generalize operations on scalars to apply transparently to vectors, matrices, and higher dimensional arrays. ... Mathematics is commonly defined as the study of patterns of structure, change, and space; more informally, one might say it is the study of figures and numbers. Mathematical knowledge is constantly growing, through research and application, but mathematics itself is not usually considered a natural science. ... For Wikipedia statistics, see m:Statistics Statistics is the science and practice of developing human knowledge through the use of empirical data expressed in quantitative form. ... In mathematics, a matrix (plural matrices) is a rectangular table of numbers or, more generally, of elements of a ring-like algebraic structure. ...

Like the original FP/FL languages, J supports function-level programming (also known as higher-order functional programming), via its tacit programming features (note that function-level programming is not the same as functional programming). Function-level programming refers to one of the two contrasting programming paradigms identified by John Backus in his work on Programs as mathematical objects, the other being Value-level programming. ...

Unlike most languages that support object-oriented programming, J's flexible hierarchichal namespace scheme (where every name exists in a particular locale) can be effectively used as a framework for both class-based and instance-based object oriented programming. In computer science, object-oriented programming, OOP for short, is a computer programming paradigm. ... In general, a namespace is an abstract container, which is or could be filled by names, or technical terms, or words, and these represent (stand for) real-world things. ... Class-based programming, or more commonly class-orientation, refers to the style of object-oriented programming in which inheritance is achieved by defining classes of objects, as opposed to the objects themselves (compare Prototype-based programming). ... Prototype-based programming is a style and subset of object-oriented programming in which classes are not present, and behaviour reuse (known as inheritance in class-based languages) is accomplished through a process of cloning existing objects which serve as prototypes. ... Object-oriented programming (OOP) is a computer programming paradigm in which a software system is modeled as a set of objects that interact with each other. ...

J is a non-von Neumann programming language that nevertheless allows the programmer to use von Neumann programming style when desired. The term von Neumann language refers to those programming languages that are high-level abstract isomorphisms of von Neumann architectures. ...

Note that the J programming language is not related to J++ (and its new version J#), a version of Java developed by Microsoft. // Overview Visual J++ (pronounced Jay Plus Plus) is Microsofts now discontinued implementation of the Java programming language. ... The J# (pronounced J-sharp) programming language is a transitional language for programmers of Suns Java and Microsofts J++ languages, so they may use their existing knowledge, and applications on Microsofts . ... Java is an object-oriented programming language developed by James Gosling and colleagues at Sun Microsystems in the early 1990s. ...

Examples

J is an extremely powerful language, and its programs can be very terse but even more cryptic.

The hello world program in J is To meet Wikipedias quality standards, this article or section may require cleanup. ...

 '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, but the mechanisms for associating a script with the interpreter are system dependent. Here's how this might look on a unix system:

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

But many accomplished J programmers never resort to such mechanisms.

Here's a J program to calculate the average of a list of numbers:

 avg =. +/ % # avg 1 2 3 4 2.5 

'#' - counts the number of elements in the string. '+/' - adds up all the elements in the string. '%' - divides the sum of the elements by the number of elements.

Now let's generate some random numbers and find the average:

 a =. ?20$100 a 31 16 60 64 64 71 13 3 76 26 25 77 68 48 42 91 99 97 99 9 avg a 53.95 

Here is an implementation of quicksort, from the J Dictionary:

 sel=: adverb def 'x. # [' quicksort=: verb define if. 1 >: #y. do. y. else. (quicksort y. <sel e),(y. =sel e),quicksort y. >sel e=.y.{~?#y. end. ) 

The following expression (thanks to Roger Hui) computes n digits of pi and demonstrates the extended precision capabilities 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 

Also have a look at Cliff Reiter's implementation of Conway's game of life at http://ww2.lafayette.edu/~reiterc/j/vector/vlife_index.html Gospers Glider Gun creating gliders. The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. ...

Data Types and Structures

J supports three simple types:

• Numeric
• Literal (Character)
• 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. Additionally, bits can be formed into lists. For example, 1 0 1 0 1 1 0 0 is a list of eight bits. And, syntactically, the J parser treats that as a single word (space characters are recognized as a word forming character when they're between what would otherwise be numeric words). Lists of arbitrary length are supported.

Furthermore, 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 

Note that 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 (3, 42), floating point (3.14, 8.8e22), complex (0j1, 2.5j3e88), extended precision integer (12345678901234567890x), and (extended precision) rational fraction (1r2, 3r4). 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, when parsing J, . and : are word forming characters. They're never tokens by themselves unless preceded by a space.)

J also supports the literal (character) 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 (ascii), but J also supports other literals (unicode). Numeric and boolean operations are not supported on literals, but collection oriented operations (such as rotate) are supported.

Finally, there's the boxed data type. Typically, data is put in a box using the < operation (without any left argument -- if there's a left argument, this would be the 'less than' operation). This is analogous to C's & operation (without any left argument). 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 lets the programmer work with an array of boxes (it can be assembled with other boxes, and/or additional copies can be made of the box). Boxed data is displayed by J, somewhat after the fashion some SQL interpreters decorate table results from select statements. The C Programming Language, Brian Kernighan and Dennis Ritchie, the original edition that served for many years as an informal specification of the language The C programming language is a general-purpose, procedural, imperative computer programming language developed in the early 1970s by Dennis Ritchie for use on the UNIX... SQL (commonly expanded to Structured Query Language — see History for the terms derivation) is the most popular computer language used to create, modify and retrieve and manipulate data from relational database management systems. ...

 <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 homogenously typed, for example the list 1 2 3 is a list of integers despite the fact that 1 is a bit. For the most part, these sorts of type issues are transparent to the programmer. 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 in and of themselves. Instead, boxed literals are used to refer to objects (and classes). 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.

Dictionary

J's documentation is organized as a dictionary, with words in J identified as nouns, verbs, adverbs, conjunctions, and so on. Here's an overview (with external links into the corresponding definitions,). Parts of speech are indicated using markup: nouns verbs, and miscellaneous adverbs, and conjunctions. Note that verbs have two forms -- monads (arguments only on the right) and dyads (arguments on the left and on the right). For example, in '-1' the hyphen is a monad, and in '3-2' the hyphen is a dyad. The monad definition is mostly independent of the dyad definition, regardless of whether the verb is a primitive verb or a derived verb.

Vocabulary

 Constants Controls Foreigns Parts of Speech 

The word rank in the J programming language, has several different meanings. ...

See also

• Function-level programming
• Related programming languages: APL, FP, FL, K

Function-level programming refers to one of the two contrasting programming paradigms identified by John Backus in his work on Programs as mathematical objects, the other being Value-level programming. ... APL (for A Programming Language, or sometimes Array Processing Language) is an array programming language based on a notation invented in 1957 by Kenneth E. Iverson while at Harvard University. ... FP (short for Function Programming) is a programming language created by John Backus to support the Function-level programming paradigm. ... FL (short for Function Level) is a programming language created at the IBM Almaden Research Center by John Backus, John Williams, and Edward Wimmers in 1989. ... K is a high level array programming language developed by Arthur Whitney, a very influential member of the APL community. ...

External links

• JSoftware- Creators of J (currently free for all uses)
• Cliff Reiter- Chaos, fractals and mathematical symmetries... in J
• Ewart Shaw- Bayesian inference, medical statistics, and numerical methods, using J
• Keith Smillie- Statistical applications of array programming languages, especially J
• John Howland- Research on parallelization of array programming languages, especially J
• J Forum Archives- Discussion of the language