> Raul,
> I don't think we can lean very heavily on the portion that says
> "the use of assignment to assign names to functions" because
> assignment is also used to assign names to explicitly-specified
> functions.
Cavaet: I haven't read this thread. I don't know what question is being
asked. So I'm going to answer one I made up.
The most salient difference between tacit programming and explicit programming
is that tacit code never mentions its arguments,
and never refers (can't refer) to "variables". Tacit functions are entirely
specified in terms of functions composed with
functions [1]. Viz, functional programming.
Some day, I need to write up why this is such a novel paradigm. I can't quite
express why it's so beautiful, except to give an
example:
sum =. +/ y
count =. # y
mean =. sum % count
versus
sum =. +/
count =. #
mean =. sum % count
both "mean" the same thing, but the latter is reusable. Put another way: in
the former, sum and mean are nouns, in the latter,
verbs. But they might as well be nouns! The concept is expressed the same
way. The sentence "reads" the same. The only
difference is in the latter, the arguments are never mentioned -- they're
implied.
That's why we call the former explicit, and the latter tacit ("unsaid",
"ummentioned", "implied").
> The role of : (Explicit Definition) seems far more important.
The use of : is the technical definition of explicit code. But then, one
feels that ".'pronoun' is explicit, though : is
never used. Similarly, one feels that in 4 : 'x - (+/ % #) y' the (+/ % #)
is tacit, though it is part of an argument to :
.
Or, put another way, once we start talking about explicit code being defined
(only) as right-arguments to : , we become ill at
ease presented with sentences like this:
(+/values) % #values
typed into the session manager, or at the top level of scripts. So, we start
wondering if we need to identify 3 different
interpreters in J: tacit, explicit, and an explicitish "top level sentence".
Yet we know this isn't right: J provides only 2 interpreters, the parser in
Section E and the primitive : , which leverages the
former to a great extent (in fact, I believe the grammar is identical except
for the interpretation of control words). And we
know we can also have "top level sentences" like this:
(+/ % #) values
which is "tacitish" in the same sense that the previous sentence was
"explicitish".
... and then it occurs to us that all sentences, tacit or explicit, are really
"top level sentences". And the only difference
between tacit and explicit is *STYLE*.
Tacit code is expressed in terms of function composition, and doesn't mention
its arguments. Explicit code is expressed in terms
of operations on values (arguments, nouns, variables, whatever) and
definitionally mentions its arguments.
-Dan
[1] See a [very] nascent explanation at
http://rosettacode.org/wiki/Talk:Functional_Composition#J .
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
