Category:J
This programming language may be used to instruct a computer to perform a task.
| Official website |
|---|
| Execution method: | Interpreted |
|---|---|
| Type safety: | Safe |
| Type strength: | Strong (but regular) |
| Type checking: | Dynamic |
| Lang tag(s): | j |
| See Also: |
If you know J, please write code for some of the tasks not implemented in J.
Contents |
[edit] the J language
J is a notational programming language designed for interactive use.
It is an array language; data is universally structured as rectangular arrays.
It is a functional language; creation and composition of functions is emphasized.
Object-module and imperative techniques are supported, but not required.
The J programming language was designed and developed by Ken Iverson and Roger Hui. It is a closely related successor to APL, also by Iverson which itself was a successor to the notation Ken Iverson used to teach his classes about computers in the 1950s.
[edit] Reading J
J is meant to be read with the aid of a computer. J sentences are single lines and trying variations and simplifications of an expression is common practice. The first step in understanding any J sentence is to understand the data you started with and the data which resulted. When learning how a J sentence works, you can also try simpler sentences with the same data or perhaps related data.
Unless you attend an institution which has made a J interpreter available to you through your web browser (or preinstalled on your machine), if you want to see how J works you should probably install a copy of J -- or you can try one of the "try me" links, below. If you want to understand how to experiment with alternative expressions you should probably also be studying some of its documentation.
For example, the phrase (+/ % #) finds the average of a list of numbers.
(+/ % #) 1 2 3
2
To understand how this works, you might try working with simpler sentences and their variations.
+/ 1 2 3
6
+/4 5 6
15
# 1 2 3
3
# 2 3 4
3
6 % 3
2
15 % 3
5
(+/ % #) 4 5 6
5
By themselves, these experiments mean nothing, but if you know that +/ was finding the sum of a list and # was finding the length of a list and that % was dividing the two quantities (and looks almost like one of the classical division symbols) then these experiments might help confirm that you have understood things properly.
[edit] Some Perspective
If you wish to use J you will also have to learn a few grammatical rules (J's parser has 9 reduction rules and "shift" and "accept" - the above examples use four of those rules). J verbs have two definitions - a single argument "monadic" definition and a two argument "dyadic" definition. These terms are borrowed from music and are distinct from Haskell's use of the word "monad". The dyadic definitions are in some sense related to LISP's "cons cell" but are implemented as grammar rather than data structure, and are a pervasive part of the language.
Another pervasive feature of the language is rank.
The language represents capabilities of hardware. For example, if language did not have an internal stack, a word's definition could not be used during the execution of that word. All current J implementations support recursion, but in some sense this is a convenience, and it's reasonable to imagine J implementations which do not (perhaps in a "compile to silicon" implementation).
[edit] J on RosettaCode
Discussion of the goals of the J community on RC and general guidelines for presenting J solutions takes place at House Style.
[edit] Jers on RosettaCode
- Roger Hui: contributions, J wiki
- Tracy Harms: contributions, J wiki
- Dan Bron: contributions, J wiki
- Arie Groeneveld: contributions
- Raul Miller: contributions, J wiki
- Jose Quintana: contributions, J wiki
- Ric Sherlock: contributions, J wiki
- Avmich: contributions
- VZC: contributions
- Alex 'bathala' Rufon: contributions, J wiki
- David Lambert:contributions
[edit] try me
Want to try one of those cryptic J lines you see peppered through RC? Try pasting it into the web interface for buubot (broken link) (a Perl IRC bot which has a J evaluation mode: just prefix your line with jeval).
If you want to be a bit more interactive, and get some guidance from J gurus, you can join the actual J IRC channel on Freenode, #jsoftware. Buubot and several other J eval bots run there. If you don't have an IRC client you can try freenode's web interface (or just give it a quick spin). More details about the J IRC community is available.
If any of that piques your interest, and you want to explore a little more, you can download J and join the J forums.
If you have problems executing any of the J code here on Rosetta, please make a note of it either on the task page itself, on the talk page, or on the appropriate J forum, whichever is best. It might be that there's a version dependency that needs to be documented, or you might have found an actual bug.
Subcategories
This category has the following 3 subcategories, out of 3 total.
Pages in category "J"
The following 754 pages are in this category, out of 754 total.
