There is another language
within J, a microcode for J as it were.
Like Moliere's M. Jourdain, who was astonished to find he had been
speaking prose for forty years without knowing it, you have been using a small
subset of this language unwittingly throughout our investigations.The hidden language describes a way of coding
called tacit programming, and it is time for you
to learn it in full. J's tacit language
is the irreducible essence of a programming language.It describes your algorithm using only the ordering
of the J primitives you have already learned.
It has a grammar without words, which you use to write programs without
visible operands; yet its renouncing these seemingly essential components is
self-denial rather than self-mutilation, for it retains the vigor to express
any algorithm. It is as evanescent as
the breeze and as powerful as the hurricane.
It is a sublime creation.

We begin our exploration with this simple program:

-

The first step toward enlightenment is to realize
that something so simple is a program.
You may object: But it can't be a program.It has no parameters.It has no name.How would I invoke it?It's a primitive, maybe.Or a verb.
Or a typographical error. But not
a program.

Let me make the case that it is indeed a program.I say that a bit of text deserves the title
of 'program' if it produces a systematic result when executed with suitable
arguments. And I say that the program '-'
satisfies this definition. Certainly I
can supply it with arguments

5 7 - 2

3 5

and get the expected result.The program does not refer to its operands
explicitly, but as long as we make the agreement that the arguments to a
program appear as nouns to its left and right, the program has no doubt about
how to find its arguments. Of course, we
have been using this convention for verbs all along.

I can give this program a name:

minus =: -

5 7 minus 2

3 5

minus can be used in place of -
anywhere. When we look at the value of minus,
we see what it contains:

9!:3 (5)NB. Do this once to select simplified display

minus

-

minus
is equivalent to - .In J we call it a verb, but it has all the
essential features of a program. In
fact, minus
is two programs, because it can be executed monadically as well:

minus 6 8

_6 _8

The point is that every J verb, even the primitives and
the compound verbs, is a program in the usual sense.Verbs like minus, that do not
mention their operands by name but instead apply them according to J's parsing
rules, are called tacit verbs.Verbs created by m :n, like dyad : '+/ y',
that mention their operands by name are called explicit
verbs. The compound verbs we have
learned already are examples of tacit verbs.
Some of the verbs that we have had occasion to define so far can be
written in tacit form:

addrow =: monad : '+/ y'"1

could be rewritten as

addrow =: +/"1

and

v =: dyad : '1.04 * x + y'

is equivalent to

v =: 1.04&*@:+

as we have seen.
We have already encountered tacit definitions without noticing:

dotprod =:
+/@:*"1

1 2 3 dotprod
1 2 3

14

and we can certainly define more.

sortup =: /:~

defines a verb that sorts its operand into ascending
order:

sortup 31 41
59 26 53

26 31 41 53 59

Some of the verbs we have encountered seem too complex for
a compound verb. For example, in

mean =: monad
: '(+/ y) % #y'

we need to perform two operations on y
and combine their results, something that is beyond the capabilities of the
compound verbs we have encountered so far.
We will next learn how to produce a tacit equivalent for mean
and a great many other verbs.