Table of Contents for Programming Languages: a survey

Iverson array languages

Links:

• Iverson College 2014 conference
• https://news.ycombinator.com/item?id=8475809
• http://kx.com/
• http://stackoverflow.com/questions/3887521/apl-versus-a-versus-j-versus-k

APL

Source code is in non-ASCII symbolic notation.

Retrospectives:

• Notation as a Tool of Thought by KENNETH E. IVERSON

Links:

• http://en.wikipedia.org/wiki/A%2B_%28programming_language%29
• https://www.finnapl.fi/idilib.htm
• https://en.wikipedia.org/wiki/APL_syntax_and_symbols

A+

"departs significantly from the "classic" APLs, but is like them in keeping most of the core character set. My sense is that it has not been kept up to date with technology changes. It was a precursor to K." -- [1]

Links:

• http://en.wikipedia.org/wiki/A%2B_%28programming_language%29

J

"a synthesis of APL (also by Iverson) and the FP and FL function-level languages created by John Backus.[5]" -- https://en.wikipedia.org/wiki/J_%28programming_language%29

relies "mainly on symbols, but these are drawn from the ASCII character set" -- [2]

"after a full career of applying and refining APL in commercial applications (Ken Iverson) turned to the task of making a "rationalized" revision, one that corrected the aspects of the language he'd found himself dissatisfied with over the years. This fresh take on the theme is called J. The differences between J and APL are sketched in a paper on the J Software wiki. One noticeable change is the elimination of array indexing syntax. The biggest feature, though, is tacit form, in which programs are written by composing functions without reference to their arguments. Tacit J is closely related to "point-free" style found in functional programming languages, but differs in that this form is fundamental to the J language." -- [3]

"Basically, it is a dialect of APL with the same functionality, but employing the ASCII character set instead of APL's original unique character set. " -- http://cgibin.erols.com/ziring/cgi-bin/cep/cep.pl?_alpha=jk

Successor to APL.

Creators: Ken Iverson, Roger Hui

Influenced: NumPy?

J Opinions:

• http://stackoverflow.com/questions/747625/would-anybody-recommend-learning-j-k-apl
• unreadable: http://stackoverflow.com/a/2088447/171761
• "Amazing programming language but if you don't use it for a couple of weeks, you just forget it all. It's so terse. But great fun " [4]
• http://www-cs-students.stanford.edu/~blynn/c/apl.html
• https://scottlocklin.wordpress.com/2012/09/18/a-look-at-the-j-language-the-fine-line-between-genius-and-insanity/
  • discussion: https://news.ycombinator.com/item?id=16393873
• https://www.adamtornhill.com/articles/jlang/beyondfunctional.html (sort of a little tutorial too)
• " I've programmed in J professionally (admittedly not for all that long) as a data scientist and, coincidentally, have just completed a small analysis using J as part of an internal workshop about data analysis I am planning. I typically work in R and Python and I have to say that at this stage there is almost no reason I would pick up J to do any work. Unless code-golf level conciseness is your only goal, these other platforms offer superior performance, clarity, ease of use, access to libraries and are, as programming languages, substantially better designed. I say this as a great lover of function-level programming and as a J enthusiast. I would say I am quite familiar with J's programming paradigm and conceptual widgets and doodads (I know the verbs, nouns, adverbs and conjunctions and can use them appropriately). I even remembered a pretty good portion of the Nuvoc. But doing even the simplest analysis in J was _excrutiatingly_ slow and inconvenient compared to using R and the tidyverse (in particular, I missed dplyr and ggplot). The tidyverse CSV readers are, for example, much faster and smarter and more convenient and informative than anything you'll get from the J universe. I love vector languages but at this point J can't compete with the major platforms for data analysis. Its less convenient, often _slower_, much more low level, strange, and its library situation is anemic at best. I recommend learning J because it will expand your mind, but I can't imagine picking it up for real work. ... J feels a lot like Smalltalk and Lisp to me. If you got on board early, you could do all sorts of stuff other languages struggled to make easy and performant. Hence the set of dedicated users. And there are some genuinely interesting conceptual things going on in array languages which have real appeal. But in the end I think J reflects a previous era and hasn't caught up to really useful ideas in more contemporary languages, probably because its user base is too conservative. I wouldn't recommend people use XLisp or run Genera in a VM to solve real problems. Recommending J feels like that to me. " -- Nathan Compton and [5]
• "Nothing in my programming career has changed the way I thought so much as learning J to the point of real fluency." -- [6]

Retrospectives:

• https://aplwiki.com/wiki/J

J Features

• Tacit function definitions: what is more commonly called 'pointfree' style

9 control structures [7]:

• if/then (if/"do")
• if/else
• if/elseif
• try/catch
• while
• whilst (like while except that the body is executed once before the first test)
• for
• for_i (todo is this semantically different from for?)
• select/case (some 'case's may be replaced with 'fcase's, or fallthru cases, which fallthru to the next case if executed, as opposed to ordinary 'case', which terminates after execution)

break/continue are available.

J Precedence

Note that J has a nonstandard meaning of the word 'precedence'. When J says that a word has high precedence, that means that that word 'executes first', where execution is understood to be mixed with parsing. The word that 'executes first' can then determine how to group the surrounding words together into arguments. If it chooses to group many words together, that would be equivalent to a situation that would be called "low precedence" with the standard use of the term "precedence". [8]

Verbs have no precedence (so, for example, multiplication does not take group tighter than addition, and must be explicitly grouped) [9].

J syntax

Parsing and execution of J are interleaved. Up to 4 consecutive J words are examined at once to see if their parts-of-speech match one of 9 patterns. If there is a match, a subset of the matching words are evaluated and replaced by their evaluation. If there is no match, the parser looks further left. Parsing and execution are interleaved because parsing depends on the part-of-speech of the words, but I think that in some cases this cannot be known until runtime.

Comprehensive description of J syntax and of how J is parsed: https://crypto.stanford.edu/~blynn/haskell/jfh.html

Introductory tutorial descriptons: https://www.jsoftware.com/help/jforc/preliminaries.htm#_Toc191734292 https://www.jsoftware.com/help/jforc/tacit_programs.htm https://www.jsoftware.com/help/jforc/introduction_to_forks.htm

https://www.jsoftware.com/help/learning/01.htm https://www.jsoftware.com/help/learning/02.htm https://www.jsoftware.com/help/learning/03.htm and later chapters in that one, eg: https://www.jsoftware.com/help/learning/09.htm

https://crypto.stanford.edu/~blynn/haskell/jfh.html

Parts of speech

Words (tokens) in J are classified as various parts of speech [10]:

• Nouns: eg 3.5 [11]
• Verbs: eg % (the division operator). The inputs and outputs to verbs (the arguments and result) must be nouns. Each verbs can have a separate definition when it is used as a unary operator (in which case the verb is on the left and the argument is on the right) and when it is used as a binary operator. J calls the unary case the 'monad' of the verb, and calls the binary case the 'dyad'. [12] [13]
• Adverbs: Adverbs are unary operators which can be higher-order functions. Adverbs are like verbs, except that (a) adverbs are only unary operators (verbs have both a unary and a binary definition); (b) the argument goes on the left and the adverb goes on the right (with verbs, it is the other way around), (c) an adverb's argument might be a verb (a verb's argument must be a noun), (d) an adverb's result might be a verb (a verb's result must be a noun). The left argument of an adverb is the entire verb phrase that precedes it. [14] [15]
• Conjunctions: Conjunctions are binary operators which can be higher-order functions. Conjunctions are like adverbs, but they are binary operators. [16]
• Gerunds: todo [17]

Forks

If three verbs are juxtaposed (ie separated by spaces), that is, (V0 V1 V2), then this is interpreted as a 'fork', meaning a function such that if a noun is applied, the noun will be applied to the first and to the third verb (taken as unary operators), and then the results will be applied to the second verb (taken as a binary operator); that is to say [18],

(V0 V1 V2) Ny is the same as (V0(Ny)) V1 (V2(Ny))

For example,

avg=: +/ % #

here, '+/' is a fold of + (ie. the sum function), '%' is division, and '#' takes the length of an array.

Control structures

• assert.
• break.
• continue.
• for.
• goto_label.
• if. else. elseif.
• return.
• select. case.
• throw.
• try. catch.
• while. whilst.

English ('primitives') script

https://code.jsoftware.com/wiki/Guides/Primitives

The Primitives script provides English aliases for various J primitives.

J implementations and variants

• An implementation of J by Roger K.W. Hui

J Incunabulum

A tiny implementation of a fragment of J. https://code.jsoftware.com/wiki/Essays/Incunabulum

https://rickyhan.com/jekyll/update/2020/01/16/j-incunabulum-disected.html

It's also in Appendix A of An implementation of J by Roger K.W. Hui

• debugging and fixing the J incunabulum for 64-bit machines: https://lobste.rs/s/2gza1a/incunabulum_for_21st_century_making_j
  • http://bollu.github.io/incunabulum-for-the-21st-century-making-the-j-interpreter-compile-in-2020.html
• a walk thru the J incunabulum: Ode to J
• J Incunabulum as C code: https://web.archive.org/web/20021127091012/http://www.kuro5hin.org/comments/2002/8/30/175531/763/1
• analysis of the J incunabulum: https://www.reddit.com/r/programming/comments/ep8hrq/incunabulum_for_the_21st_century_making_the/
• https://github.com/tangentstorm/j-incunabulum
• https://www.reddit.com/r/C_Programming/comments/w5khs/the_j_incunabulum_brace_yourself/

Related:

• https://github.com/luser-dr00g/inca
  • inca: a hacked-up apl in c based on the J incunabulum

J Tutorials

• http://jsoftware.com/help/primer/contents.htm
• http://kukuruku.co/hub/funcprog/j-can-be-readable
• http://jsoftware.com/help/jforc/contents.htm
• http://jsoftware.com/help/learning/contents.htm
• http://code.jsoftware.com/wiki/NuVoc
• http://www.jsoftware.com/help/dictionary/dict.htm
• http://stackoverflow.com/a/10576434/171761
• https://www.jsoftware.com/help/jforc/contents.htm
• https://code.jsoftware.com/wiki/Guides/Getting_Started
• https://asindu.xyz/posts/random-walk-in-2-lines-of-j/
  • https://lobste.rs/s/jsjank/random_walk_2_lines_j

Comparisons with other Iverson array languages

• https://www.jsoftware.com/papers/j4apl.htm
• https://stackoverflow.com/questions/3887521/apl-versus-a-versus-j-versus-k
• https://news.ycombinator.com/item?id=6458627
• https://code.jsoftware.com/wiki/Doc/J4APL
• vs K: "Instead of being inspired by J, I’m inspired by K. K has numbers, characters, symbols, lists, records and functions (anonymous function literals that make closures). Multidimensional arrays are represented by nested lists. There is need for “boxes”. J has more built in operations, but K has a richer and I think more elegant set of datatypes. I’m particularly bothered by the fact that J doesn’t have lambda expressions or closures: that’s why I never learned it." -- [19]
• vs APL,K: https://gist.github.com/deadpixi/7047ac40f026503b2dced261f9a1fac2

J links

• https://en.wikipedia.org/wiki/J_%28programming_language%29#Control_structures
• http://jsoftware.com/help/dictionary/ctrl.htm
• http://en.wikipedia.org/wiki/J_%28programming_language%29
• http://jsoftware.com/help/phrases/contents.htm
• http://jsoftware.com/help/dictionary/contents.htm
• http://jsoftware.com/help/dictionary/vocabul.htm
• http://jsoftware.com/help/dictionary/xmain.htm
• http://jsoftware.com/help/user/contents.htm
• http://jsoftware.com/help/index.htm
• about function-level programming, and its connection to point-free style: http://stackoverflow.com/a/20710065/171761
• http://jsoftware.com/help/user/contents.htm
• http://www.jsoftware.com/help/jforc/contents.htm
• http://www.math.bas.bg/bantchev/place/j.html

K

"K is a specialized language that is no longer being marketed on its own. Kx Systems is instead marketing the Kdb+ database and its Q (query) language, both of which are written in K. It's a powerful specialized tool, designed for high-speed processing of streaming data. It departs significantly from the original APL approach. Kx Systems products are expensive and their users mostly work in finance." -- [20]

however note that there is Kona, an open-source variant of K, and oK

Tutorials:

• https://nsl.com/k/training/idioms_K3.pdf
• https://codegolf.meta.stackexchange.com/questions/23743/language-of-the-month-for-august-2021-k

Comparisons with over Iverson array languages:

• vs APL,J: https://gist.github.com/deadpixi/7047ac40f026503b2dced261f9a1fac2

oK:

• https://github.com/JohnEarnest/ok/blob/gh-pages/oK.js

Comparisons with over Iverson array languages:

• vs J: "Instead of being inspired by J, I’m inspired by K. K has numbers, characters, symbols, lists, records and functions (anonymous function literals that make closures). Multidimensional arrays are represented by nested lists. There is need for “boxes”. J has more built in operations, but K has a richer and I think more elegant set of datatypes. I’m particularly bothered by the fact that J doesn’t have lambda expressions or closures: that’s why I never learned it." -- [21] "

Links:

• http://en.wikipedia.org/wiki/K_%28programming_language%29
• http://www.kparc.com/
• https://github.com/kevinlawler/kona/wiki
• http://www.math.bas.bg/bantchev/place/k.html
• https://cs.nyu.edu/courses/fall02/G22.3033-007/kintro.html

Q

"Q is a thin wrapper around K, providing a more readable, English-like interface." [22] [23]. Developed for the database kdb+.

Links:

• http://kx.com/q/d/q.htm
• http://en.wikipedia.org/wiki/Q_%28programming_language_from_Kx_Systems%29
• http://code.kx.com/wiki/Tutorials
• http://code.kx.com/wiki/JB:QforMortals2/contents
  • http://code.kx.com/mkdocs/qformortals3/

Kerf

https://scottlocklin.wordpress.com/2015/12/15/an-introduction-to-kerf/

BQN

https://aplwiki.com/wiki/BQN