113 lines
No EOL
6.8 KiB
Text
113 lines
No EOL
6.8 KiB
Text
{{language|J
|
|
|exec=bytecode
|
|
|exec=interpreted
|
|
|site=http://www.jsoftware.com
|
|
|strength=strong (but regular)
|
|
|safety=safe
|
|
|checking=dynamic
|
|
|tags=j
|
|
|hopl id=1558
|
|
|LCT=yes
|
|
|bnf=https://code.jsoftware.com/wiki/Guides/Language_FAQ/J_BNF}}
|
|
{{language programming paradigm|Dynamic}}
|
|
{{language programming paradigm|functional}}
|
|
{{language programming paradigm|imperative}}
|
|
{{language programming paradigm|procedural}}
|
|
{{language programming paradigm|Reflective}}
|
|
{{language programming paradigm|Tacit}}
|
|
|
|
== 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 [http://en.wikipedia.org/wiki/Kenneth_E._Iverson 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.
|
|
<br clear="all"/>
|
|
|
|
The notation draws heavily from concepts of [[wp:Abstract algebra|Abstract algebra]] and [[wp:Tensor calculus|Tensor calculus]], simplified for describing computer architecture and design to a pragmatic business audience. (The ideas themselves are simple, but for some reason the topics scare most teachers.)
|
|
|
|
== 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.
|
|
When trying to understand contexts that use large data structures, it can often be wise to investigate small, representative samples until you understand how the code works.
|
|
|
|
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 [https://code.jsoftware.com/wiki/System/Installation 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 [[j:Guides/Getting%20Started#Documentation|documentation]].
|
|
|
|
For example, the phrase <code>(+/ % #)</code> finds the average of a list of numbers.
|
|
|
|
<lang J> (+/ % #) 1 2 3
|
|
2</lang>
|
|
|
|
To understand how this works, you might try working with simpler sentences and their variations.
|
|
|
|
<lang J> +/ 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</lang>
|
|
|
|
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 old school division symbols) then these experiments might help confirm that you have understood things properly.
|
|
|
|
== Some Perspective ==
|
|
|
|
If you wish to use J you will also have to learn a few grammatical rules (J's parser has [http://www.jsoftware.com/help/dictionary/dicte.htm 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 [[wp:Rank_(J_programming_language)|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).
|
|
|
|
== J on RosettaCode ==
|
|
|
|
Discussion of the goals of the J community on RC and general guidelines for presenting J solutions takes place at [[J/HouseStyle|House Style]].
|
|
|
|
|
|
== Jedi on RosettaCode ==
|
|
*[[User:Roger_Hui|Roger Hui]]: [[Special:Contributions/Roger_Hui|contributions]], [[j:User:RogerHui|J wiki]]
|
|
*[[User:TBH|Tracy Harms]]: [[Special:Contributions/TBH|contributions]], [[j:User:TracyHarms|J wiki]]
|
|
*[[User:DanBron|Dan Bron]]: [[Special:Contributions/DanBron|contributions]], [[j:User:DanBron|J wiki]]
|
|
*[[User:Gaaijz|Arie Groeneveld]]: [[Special:Contributions/Gaaijz|contributions]]
|
|
*[[User:Rdm|Raul Miller]]: [[Special:Contributions/Rdm|contributions]], [[j:User:Raul_Miller|J wiki]]
|
|
*[[User:96.57.161.34|Jose Quintana]]: [[Special:Contributions/96.57.161.34|contributions]], [[j:Stories/JoseQuintana|J wiki]]
|
|
*[[User:tikkanz|Ric Sherlock]]: [[Special:Contributions/tikkanz|contributions]], [[j:User:RicSherlock|J wiki]]
|
|
*[[User:Avmich|Avmich]]: [[Special:Contributions/Avmich|contributions]]
|
|
*[[User:VZC|VZC]]: [[Special:Contributions/VZC|contributions]]
|
|
*[[User:Bathala|Alex 'bathala' Rufon]]: [[Special:Contributions/Bathala|contributions]], [[j:bathala|J wiki]]
|
|
*[[User:Lambertdw|David Lambert]]:[[Special:Contributions/Lambertdw|contributions]]
|
|
*[[User:JimTheriot|JimTheriot]]: [[Special:Contributions/JimTheriot|contributions]]
|
|
*[[User:DevonMcC|Devon McCormick]]: [[Special:Contributions/DevonMcC|contributions]]
|
|
|
|
== Try me ==
|
|
|
|
Want to try one of those cryptic J lines you see peppered through RC?
|
|
Try pasting it into this [http://joebo.github.io/j-emscripten/ browser-based implementation of J].
|
|
|
|
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 [http://webchat.freenode.net/?randomnick=1&channels=jsoftware freenode's web interface] (or just [http://webchat.freenode.net/?channels=jsoftware&randomnick=1 give it a quick spin]).
|
|
More [[j:Community/IRC|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 [http://www.jsoftware.com/ download J] and [http://www.jsoftware.com/forums.htm 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 [http://forums.jsoftware.com 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.
|
|
|
|
==Todo==
|
|
[[Reports:Tasks_not_implemented_in_J]] |