Subject: Re: Which one, Lisp or Scheme?
From: Erik Naggum <>
Date: 1997/02/01
Newsgroups: comp.lang.lisp,comp.lang.scheme
Message-ID: <>

I find it symptomatic of Schemers attacks on Common Lisp that they are
ignorant, arrogant, and so devoid of correctnes and precision as to merit
no other badge than "prejudice".

* Ray S. Dillinger
| In scheme, a function is simply a value, like a number or a string.  In
| CL, a function is in a separate class -- it has to be funcalled for
| example if you're evaluating to it.

Ray, you don't know what you're talking about.  it also looks as if you
don't know what a namespace is.  a namespace is simply a mechanism to refer
to objects by names taken from different sets of possible names.  whether
an object is found by a name in one namespace or in another makes no
difference to the object.  you seem to believe it does.

let me paraphrase your complaint with an example of a similar complaint
about Scheme:

    in CL, a function is simply a value, like a number or string.  to use
    any value as a function, apply `funcall' to it.  in Scheme, a value has
    to be placed first in a form if you wish to call it as a function.
    this is unlike the use of any other variable, which do not need this
    special position in a form when using their value.

I guess you will automatically think the above is a specious argument, and
will ignore it, without having taken the care to examine the fact that it
is entirely valid, and that its main function is to show that your position
is not one of understanding.

occasionally, we hear that syntax is unimportant, that what matters is the
semantics of languages, indeed that arguments about syntax are _invalid_
because all languages are Turing equivalent.  however, when some Scheme
users need to debunk Common Lisp, it is tragically common for them to
stumble in the syntax, and make such utterly false accusations as the above
complaints about namespaces.

let's look at one of your ignorant, invalid examples:

| ((function-that-returns-another-function) argument1 argument2)


| (define-function ?foo (function-that-returns-another-function))
| (funcall ?foo argument1 argument2) 

I find it interesting that most Common Lisp users who criticize Scheme do
so with syntactically correct Scheme programs or real examples, whereas
Scheme users who criticize Common Lisp generally don't have a clue.  here's
how it would be done by somebody who had actually _seen_ Common Lisp:

(funcall (function-that-returns-another-function) argument1 argument2)

| I'm just guessing about the use of the define-function syntax; I must
| admit it's darn weird as far as I can tell to have different defines for
| everything when it's only one operation.

maybe if you didn't guess as much, you wouldn't make a fool of yourself.
and if you had paid attention, you would have known that it isn't only one
"operation" that is performed by differently-named functions, unless you
define "operation" so generally as to make all computers perform the same
operation, namely heat their immediate surroundings.

I wonder why so many people who love Scheme tend to be so unbelievably
arrogant in their belief that Scheme is superior that they don't even
bother to _learn_ anything about the languages they compare to.  this
really makes me wonder what made them love Scheme in the first place.  it
surely cannot be intelligent, rational, or informed balancing of features.
it cannot be based on a desire to study and learn languages.  instead, Ray,
explains to us, it's based on "a trifling effort of memorization and
practice", if I understood what he meant by that, alien as it is to me.

| But the point is that functions are treated differently than other values
| in CL.

that may be your point, but it is a _fact_ that functions are treated just
like other values in Common Lisp.  the difference between Common Lisp and
Scheme is that Scheme evaluates the first element of a form to find which
function to call, whereas Common Lisp regards the first element of a form
as a constant symbol, and looks up the function definition of that symbol.

I'm rather surprised by the many Scheme users who fail to understand such a
simple _fact_, instead preferring to make various bogus "points".  every
such "point" reduces the credibility of the entire Scheme community.

| You can't insert a subexpression evaluating to your function in place of
| the function the way you can with any other value.

yes, you can.  the problem is that you're very confused, mostly because you
treat Common Lisp as if it were Scheme, and then complain when it isn't.
Common Lisp does not _evaluate_ symbols to a function.  period.

| You can't use your standard assignment statement to assign a value to a
| variable if that value happens to be of type function.

Ray, you don't know what you're talking about.

| And numerous other warts and inconsistencies.

I'm sorry to say that you seem to produce the warts you wish to attack
straight out of thin air, and that you wouldn't find half as many if you
had bothered to study Common Lisp before your ignorant attacks on it.

| But Scheme has the cleanest, simplest, and most consistent rules of
| operation and evaluation of any language I've ever come across, and that
| enables me to write correct programs much more easily; I always know
| exactly what an operation means, because it always means exactly the same
| thing, and doesn't have weird exceptions like "you can always substitute
| an expression evaluating to a value for the value itself in any
| expression -- UNLESS it's a function..." and "the value of ?foo is 27 --
| UNLESS it's the function ?foo instead of the variable ?foo -- and so on.

I find this entertaining.  you don't know diddlysquat about Common Lisp,
yet speak with a stunning degree of certainty in which you prove beyond
_any_ reasonable doubt that you don't even care to look things up, yet you
know _exactly_ what Scheme does.  yeah, right.  I think the latter is pure
hyperbole -- that the degree to which you "know exactly" what Scheme does
is the same degree to which you know vaguely how Common Lisp works.

perhaps the difference between Scheme and Common Lisp programmers is that
the Common Lisp programmers _know_ they need to look things up, whereas the
Scheme programmers always _think_ they never need to.  I guess that's also
why Common Lisp has documentation strings and Scheme doesn't.  the lack of
documentation strings has always bothered me in Scheme.  (yes, it's been
rehashed a few times.  I know all the arguments.)

| That, I suppose, is why I love scheme -- no other language gives me such
| returns of precision and capability for such a trifling effort of
| memorization and practice.

this is _very_ amusing.  your utter lack of precision in your description
of Common Lisp really drives a stake through the heart of your arguments.
but I guess that's the _real_ return you get from a trifling effort of
memorization and practice.

why do so few Scheme users seem to care enough to be accurate?  could it be
influence from the language?  or could it be that people who _don't_ care
flock to Scheme?  I'm led to wonder by the many Scheme proponents who like
to attack strawmen and problems only of their own imagination.

1,3,7-trimethylxanthine -- a basic ingredient in quality software.