J hooks make evaluating exotic expressions easy
You might see the approximation:
and think:
Hmmm! How accurate is that?
You might then proceed to check using a scientific calculator, your phone, or your favourite programming language. But if you’re like me, your next thought will be:
…this is tedious and surely more effort than necessary for a simple pattern.
Here we have a compelling reason to learn a language that allows us to express and extend computational patterns with minimal effort.
I want to focus on the J programming language and one of its many clever abstractions: hooks. This is nottoodifficult to learn and will make swathes of repetitive mathematical expressions typable in a dozen or so characters. Once you get the hang of the language, it’s a great replacement for a scientific calculator.
You can even get a free J interpreter app for your phone.
Before you read on, I should tell you that I myself am very much a beginner in J. This fact should:
 reassure you that the language is useful to those who are well below an intermediate/advanced level
 alert you to the fact that my explanations in this post may not be as nuanced or informative as those from a more experienced user
Regarding (2) I’ve taken care to try and explain the key points clearly, but for a more complete overview please do refer to an actual expert! I’ve linked to several resources at the foot of the page.
Now to introduce and explore a few of the useful tools of J, let’s continue the theme of approximating $\pi$ using expressions picked from Wikipedia and Wolfram Mathworld.
J arithmetic
Here’s a wellknown approximation which is accurate to two decimal places:
Like many other languages, +
, 
and *
represent addition, subtraction and multiplication of two numbers in J. However, the symbol %
is the verb for division:
22 % 7
3.14286
Note that in the J console, the line that is executed is indented, followed by the (unindented) result.
There are a couple of things to say here. Firstly, the word “verb” is used instead of “function” in J. Verbs are (usually) monadic (take a single argument on the righthand side) or dyadic (take two arguments, one on either side). Above, the dyadic form of %
was used. The monadic form of %
gives the reciprocal, e.g. % 2
is 0.5.
Secondly, verbs in J associate to the right and have the same precedence as each other. For instance, consider:
Knowing that the monadic verb %:
computes the squareroot of its argument, we could try:
%: 2 + %: 3
1.93185
Because of the rightassociativity and equal precedence of these verbs, we are actually computing $ \sqrt{ 2 + \sqrt{3} }$. To get the correct result, one option is to use parentheses to force the evaluation in the order we require:
(%: 2) + (%: 3)
3.14626
Here we compute the squareroots of 2 and 3, then add these results using the dyadic verb +
. However, we can write expressions such as these more easily and idiomatically using J’s fundamental data structure: the array.
Array building and reduction
J is an arraybased language. Its verbs can operate not just on single values, but on arrays (i.e. sequences of one or more values in one or more dimensions). Syntactically, elements in onedimensional arrays are separated by a single space. For instance, an array containing the integers 2 and 3 is written:
2 3
To compute the square root of each element of the array, apply the verb to the array:
%: 2 3
1.41421 1.73205
How can we sum the elements of this new array? To do this we can modify the verb +
using the insert adverb /
. This has the effect of putting the verb between each element of the array. For example, +/ 7 8 9
is equivalent to 7 + 8 + 9
.
For our purposes, +/
is placed to the left of %:
to sum our array of square roots:
+/ %: 2 3
3.14626
You can see how this arraybased approach implies looping. We’re essentially applying functions to multiple values but there’s no need for explicit for (i; i < length, i++)
looping syntax.
To carry the pattern of applying multiple functions to arrays a step or two further, let’s look at the interesting expression:
One easy way to evaluate this powertower of logarithms in J is:
^/ ^. . 2 + i.5
3.14158
Here is how it works. Let’s first pick out the numbers 2, 3, 4, 5 and 6 which appear in the expression:
i.5
0 1 2 3 4
2 + i.5
2 3 4 5 6
The monadic verb i.
gives you an array of integers from 0 up to the specified argument. In this case, we want five integers. We also want to begin at 2 rather than 0, so we add 2 to each of the numbers in the array using +
.
Reading up the tower, it will be convenient to consider these integers numbers in reverse order. The monad .
reverses the array:
. 2 + i. 5
6 5 4 3 2
Next, we require the natural logarithm of each integer. To produce an array of these logarithms, we apply the monadic verb ^.
:
^. . 2 + i. 5
1.79176 1.60944 1.38629 1.09861 0.693147
Finally, we want to stack these logarithms in a tower and evaluate the result. In J, the dyadic verb ^
is used to raise the lefthand argument to the power of the righthand argument. As we have seen, J expressions are rightassociative so x ^ y ^ z
will be treated as $x ^ {y ^ z}$.
We want to stick ^
between each element of our array. We do this by using the adverb /
again to modify ^
and produce the new verb ^/
to operate on the array:
^/ ^. . 2 + i. 5
3.14158
As a final example of arrays and reduction, consider the Gregory–Leibniz series:
Look at the denominators: if we put those in an array, find the reciprocal values and compute the alternative sum then we’re done.
J can’t handle limits, so we’ll only use the first 1 million odd integers. If you’ll allow me to deviate from the central point of this post for one moment, one nice consequence of J’s grammar is that we can assign names to arrays and verbs and then the resulting expression is just like reading English:
odd_integers =: 1 + 2 * i. 1000000
alternating_sum_of =: /
reciprocals_of =: %
4 * alternating_sum_of reciprocals_of odd_integers
3.14159
Hooks
So far we have executed verbs on arrays one after the other in the sequence they appear from right to left.
For example, %: 4
will produce $2$, as both the verbs 
(negative) and %:
(square root) operate in turn on their input, equivalent to the expression $\sqrt{4}$.
J allows multiple verbs grouped with parentheses to be composed using trains. A train consisting of two verbs is called a hook. This is an interesting form of function composition that allows a single input to be operated on separately by two different functions to produce a new result.
To motivate hooks, here’s another approximation of $\pi$, due to Ramanujan:
We could translate into J this as:
(9%5) + %: 9%5
3.14164
But this is needlessly verbose: repeating the single numerical value and using parentheses for the correct precedence is not necessary in J. Instead, we’ll use a hook consisting of these two verbs:
(+%:) 9%5
3.14164
This computes the square root of the input and then adds this new value back on to the input.
If there is a lefthand argument to the hook, then it uses that argument instead of the first argument (a dyadic hook).
It turns out that dyadic hooks are great for repetitive mathematical expressions:
There’s an obvious pattern we should take advantage of here. We have three integers $7$, $6$ and $5$ with an operation (squareroot and then add) between each one, to be evaluated from the righthand side to the left.
In other words we want to insert (using /
) the dyadic hook (+ %:)
between these integers:
%: (+%:)/ 7 6 5
3.14163
The final (leftmost) squareroot completes the expression. No need for any explicit nesting of functions, temporary variables or recursion that may be necessary in other languages.
Imagine the tedium of trying to verify this approximation using a scientific calculator, or even a more mainstream programming language:
Hmmm, so that’s a run of seven $2$’s, then $2+1$, all preceded by a couple of other operations. Knowing that the dyad $
will build an array of the righthand side value repeated lefthandsidemany times, and the dyad ,
concatenates arrays, we can write this in J without much effort:
768 * %: 2  %: (+%:)/ (7$2),2+1
3.14159
As we’ve made it this far, here’s one final use of hooks: continued fractions.
This continued fraction is merely an ‘addsixthendivide’ pattern so our hook is just (% 6&+)
(the &
binds an argument to a verb, making a dyad into a monad). The only slightly fiddly bit is building an array of odd squares. I’ll use *: 1 + 2 * i.100
to build an array of the first hundred, so then:
3 + (% 6&+)/ *:1+2*i.100
3.14159
More J
That was a quickfire introduction to simple arithmetic, onedimensional arrays, a few J verbs, and finally hooks.
This barely scratches the surface of J programming, but I think it makes a convincing case for J as a means to evaluating repetitive mathematical expressions that are tedious to type in many other languages.
To go beyond this post, there are excellent J resources available online:

First and foremost the J Software website. I particularly like the essays which focus on solving specific mathematical and algorithmic problems.

The creator of J, Kenneth Iverson, wrote many books and articles about the language. I read ‘Arithmetic’ first and found it both incredibly helpful and the style very readable.

Henry Rich’s ‘J for C programmers’ is a great resource and helped me understand J’s concept of ‘rank’ a little bit better.

Unsurprisingly, the thoughts and themes in this post are not unique. Halfway through typing it I searched and found various other blog posts. Here are a couple I read: ‘Handwriting J’, ‘Beyond Functional Programming: Manipulate Functions with the J Language’.