a public apology to Jeffrey Mark Siskind

[William D Clinger <will@ccs.neu.edu>]

I have never felt, nor have I intended to convey through any
innuendo in what I have written, that Jeffrey Mark Siskind is
uninformed, doesn't learn, doesn't consult sources, is not of
good will, or does not discuss technical issues.  For me or
anyone else to have suggested any of these would have been
utterly ridiculous, because Siskind is clearly well informed,
well read, and extremely eager to discuss technical issues.

I had concluded that Siskind's remarks concerning the lack of
precision about tail recursion in the R4RS were correct, and
were probably motivated by a genuine concern that some of his
users might not understand the intent of the R4RS, and might
therefore object to perfectly legitimate implementation
techniques; or that the lack of precision in the R4RS does
not provide adequate guidance to an implementor.  It is
perfectly reasonable to insist upon clear rules.

In his own remarks, throughout this thread, Siskind had given
many examples of situations in which an implementor must
judge whether some particular implementation technique is
allowed by the requirement for proper tail recursion.
Siskind seemed to be asking for a mathematically precise
definition that would decide, for each such situation,
whether the technique was allowed.  In my opinion we would
need that kind of precision if we didn't trust the
implementor's judgement, or if the Scheme world were being
overwhelmed by non-conforming implementations whose authors
had devised perverse rationalizations in order to claim
conformance; but that is just not the case.

Yes, there are several popular implementations of Scheme that
do not fully conform to the requirement for proper tail
recursion, just as there are implementations that do not fully
conform to the requirements for invertible numeric i/o, but
their existence has enhanced rather than diminished the
viability of Scheme.  In particular, the authors of these
implementations have generally had some engineering reason
for implementing less-than-fully-general tail recursion, have
identified the limits of tail recursion as an implementation
restriction, and are not devising perverse justifications to
mislead users about the status of tail recursion in these
systems.  The users of these systems take these limitations
into account when selecting an implementation, and work
around them afterwards with no more than the appropriate
amount of grumbling.  I therefore see no reason to fear that
the Scheme world will be overwhelmed by unscrupulous
implementors or by unreasonable users.

My remarks were intended to explain why I do not agree that
a mathematically precise characterization of proper tail
recursion is needed for the Scheme standards.  I would prefer
an informal characterization that would be accessible to more
people.  The reason I think an informal characterization is
good enough is that the people who read standards documents
in general, and the people who read the Scheme standards in
particular, are in fact of good will and well informed.

I am chagrined to see that my words could be interpreted as
meaning the very opposite of this.  People _are_ of good will
and eager to learn; revisions to the Scheme standards should
take this into account.

There are several reasons why the current wording in the R4RS
is less adequate now than when it was written.  A large
percentage of the people who read that paragraph when it was
new had also read, or at least had easy access to, Guy
Steele's classic papers.  That is no longer the case.
Furthermore the phrase "proper tail recursion" has become
popular, partly because of Scheme, and has begun to be used
by other communities in which it has begun to acquire
meanings that are considerably weaker than the meaning it has
long had for the Scheme/ML/FP communities.  In the moderated
newsgroup comp.compilers, for example, there seems to be a
new thread every few months that begins with a well-meaning
statement by a generally well-informed person who says
something like

    I don't understand why C and C++ don't require proper
    tail recursion like Scheme.  It's trivial to implement,
    although it also seems pretty useless.

and then runs through a discussion of the conflict between
stack allocation and tail recursion, ending with a few whimpers
such as "Why is it called tail recursion when it's really about
garbage collection?"  It now seems to be the case that most
people who have heard of "proper tail recursion" don't really
understand it.  In the old days fewer people had heard of it,
but those who had were more likely to understand it.

My remarks should also not be construed as an attack on formal
characterizations of tail recursion.  I sketched a formalization
in a previous message to rrrs-authors because I believe such
formalizations are indeed useful.  Except for Matthias Felleisen,
no one has made any technical comments about it.  I think that's
pretty much what would happen if we put a mathematically precise,
formal characterization of proper tail recursion into the Scheme
standards:  Almost no one would read it, and the many people who
are uncomfortable with that level of formality would in effect
be excluded from understanding this very important aspect of the
Scheme standards.

Will