I hesitate to ask this question because I really don't want to start a
flame war.  To me it seems clear that Scheme is a dialect of Lisp.  The
Scheme standard says it's a dialect of Lisp.  Many textbooks say it's a
dialect of Lisp (e.g. Norvig's book, which has a chapter called "Scheme -
an uncommon Lisp".  Quiennec I believe also includes Scheme as a dialect
of Lisp.)

So my question is directed to those of you who say that Scheme is not a
Lisp, notably Erik, but I gather that there are many out there who agree
with him.  Why is Scheme not a Lisp?  Does Scheme lack some necessary
feature that is required to be considered a Lisp in your book?  Was Lisp
1.5 a Lisp?

Please note that I don't want to get into the argument about whether or
not Scheme is or is not a Lisp.  I'm just interested in hearing from those
people who already believe that it isn't what their rationale is.

Moreover, if scheme were a lisp, then ML would be a lisp. As would
dylan, logo, perl, ruby, and lots of other languages which have
closures and recusive functions. ML and scheme are far more similar to
each other than either is to Common Lisp.

I've been reading a very interesting book called "The Power of Babel",
about the evolution of human languages.  He gives numerous examples of
pairs of languages that are easily intelligible between their respective
speakers, but are considered separate languages mostly due to nationalistic
attitudes; e.g. the Scandinavian languages and Spanish vs. Portugese.
Conversely, there are dialects that are spoken within the same country, but
speakers of each dialect have a hard time understanding each other; Germany
has examples of these.

These same issues occur with computer languages.  Visual BASIC is a far cry
from the original Dartmouth BASIC, and the PDP-8 BASIC I used 25 years ago
was crippled in comparison to Dartmouth BASIC, but they're all considered
dialects of BASIC.  C and C++ are about as similar as Lisp and Scheme, but
they're also generally considered separate languages, although with very
close ties (the C++ standard is expected to adopt changes in the C standard
that don't directly conflict with its goals).

In ANSI CL, I was forced by the fact of committee vote to refer to things
as I did, so count that merely as a majority wish, not the view of the
neutral editor (me, at least  I tried to be neutral with my "Editor" hat
on ... sometimes tricky to keep the hats separated, but I think I did ok).

Second, at the Lisp & Functional Programming conference, there was
serious difficulty getting Lisp papers accepted.  Lisp papers were
about engineering, and Scheme papers were about mathy and theoretical
issues.  And, to be utterly crude about it, what I think gets papers
accepted to such conferences is heavy use of greek letters (and
spelling out the word LAMBDA does not appear seem to count).  Merely
talking about satisfying users doesn't tend to float anyone's boat
there.  Even before L&FP broke up, it got to the point that when there
was a Lisp paper, all the Scheme folks left the room and when there as
a Scheme paper all the Lisp folks left the room.  That's an empirical
observation that I'm not the only one to have made.  People were on
divergent paths.

Third, the priorities of the language design of the two languages are
different.  That means that if the two communities are viewed as
merged, they appear to have no coherent theory of what they do or
don't want.  But if you separate them into two groups, you see they
are massively more likely to converge on two fairly coherent theories
of the universe.  That, in turn, suggests they are happier separated.

I think the question of what makes a Lisp is taken historically by
examining the torch passing.  Lisp 1.5 was of course a Lisp because it
was passed the torch by other Lisps.  Emacs Lisp and Common Lisp are
both Lisps because they both ascended from Maclisp with a substantial
(even if divergent) desire to be true to the original Maclisp concepts
and user base.  But at design meetings of Scheme I have repeatedly
seen the designers say that compatibility was not relevant.  That, to
me, says there is no allegiance to existing codebases and userbases
and there is more desire to build a new community.  That, to me, is
the very essence of the launch of a new language--the breaking of
essential links with the past.  They did it voluntarily, the people
outside their community did not do it to them.

Moreover, it was the right thing to do, both for them and for us.
They were hampered by the tradition in what they wanted to do and
sought to build a new life.  Your question is very much like
questioning why the United States is a different country than England,
and questioning whether it was true even in the time when Jamestown
was founded.  Of course it wasn't.  But there came a point where
breaking free was administratively appropriate because of divergent
goals.  It doesn't mean we can't be pals in our cultural stance
against "those evildoers" who seek sanctuary in C and Java, but it
does mean neither our systems of laws nor our cultural priorities are
the same.

And it doesn't mean you can't use both languages either.  It just means
one is more likely to care about the needs of certain people, and one is
more likely to care about others.

McCarthy has asked that no single language take the name Lisp.  That
it be kept a language family.  That's fine.  But it also makes the
name close to meaningless.  The only common operator which has the
same meaning in all Lisp dialects I know of is CONS.  I don't think
that's much to go on.  I find it more useful to think of a tighter
space than this, and leaving out Scheme makes it easier to cluster
than leaving out any other thing and keeping Scheme.  Sure, we can
be like the datatype ATOM, defined by what we are not (that is, as
a non-cons).  We're not C.  We're not Javascript.  We're not Teco.
Yeah, that must be us.  Those guys with the parentheses.  I don't want
to be defined by that.  At some point I think you have to drive in the
stake and say difference is useful.

In the end, it is indeed political. Serbo-Croatian was once one
language, written in two alphabets (Latin and Cyrillic) but will
probably grow apart under political pressure. Contrariwise, Flemish
and Dutch were fairly apart in the 19th century and have grown more
alike under political pressure.

To sum it up with a Ritchie quote: "Some languages were meant to get
work done, some were meant to prove a point." I put Lisp in the first
category and Scheme and ML in the second. (See also the reliance on
tail call elimination to be able to prove the point that a looping
construct isn't necessary.)

I don't know enough about Lisp 1.5 to answer your last question.

Internally to c.l.l it seems the consensus is leaning towards a
distinction, at least amongst the more active posters who have been
here awhile.  I think this is a good thing, since with the influx of
CL programmers coming in the last year or two it allows the community
to focus its commonly held interests and "philosophies" when
discussing issues facing the language at the level of specificity
required to coordinate different projects while maintaining
cohesiveness.

Additionally, they get to defame the name of Lisp by making people
think that it's as limited at Scheme. That's what I had thought from
my prior education, before being informed by Sriram Krishnamurthi and
c.l.l that Lisp really is very different from Scheme. Turned out that
the language I had been building and semi-specifying was a subset of
CL, and I effectively replaced the copy of that language's spec with
the Hyperspec and never looked back. :)

What those Schemers get from defaming Lisp beats me. Probaby some sort
of jealous envy. If they really like Scheme, I don't see why they
should need to dupe others out of wanting to learn Lisp.

I thank you for your vigorous response.

Also, it's unlikely that all Scheme users are of like mind in this regard.
I'm sure there are plenty who consider it to be a dialect of Lisp, such as
the ones who wrote the second sentence of the specification, where they say
"Scheme is a ... dialect of the Lisp programming language ..."

There was a recent thread about garbage collection (about writing it in the
language being collected).  There's not much about GC that's dependent on
the particular dialect, so this question seemed appropriate to c.l.l,
IMHO.  I think he actually posted it to both groups.

And even though Emacs Lisp is considered a Lisp, most questions about it
are more appropriate to comp.emacs or gnu.emacs.help rather than
comp.lang.lisp.  When there's a forum oriented towards any specific
dialect, the experts are more likely to be found there than in the more
general group like this one.

Also, read Kent's and Lieven's posts carefully, I think they really
show just how different the two communities are and how that can be
seen in natural language evolution as well. And what are languages
other than a way for communities to express themselves?

  The "Lisp" Scheme is a dialect of is no longer the current meaning of
  "Lisp".  It is somewhat like calling English a dialect of German because
  of ancient history that has since between invalidated by each of their
  separate evolution, Fahrvergnügen, Weltanschauung, Kindergarten, and
  Pennsylvania to the contrary notwithstanding.  There is also a very
  limited value in talking about "Germanic languages" in terms of your
  actual ability to use any of the Germanic languags.  You do not order the
  "vertebrate" in a restaurant, but generally choose between fish or bird
  or meat.  In other words, there is a time when an abstraction and a
  commonality has completely ceased to be valuable.

  Because of this accident a long time ago, people who hear that "Scheme is
  a Lisp" tend to think that what they have learned is valid for some other
  Lisps they meet, too.  Today, this is flat out wrong.  It used to be
  somewhat true _before_ Common Lisp, because "Lisp" had no particular
  direction on is own, so Scheme was not much different from the rest,
  which had many serious internal differences, which would pale the Scheme
  differences in comparison.  After Common Lisp, this is no longer true,
  because the whole point was to consolidate and compromise away those
  differences.  Therefore, there is no _present_ value to make Scheme look
  like or pretend be a Lisp.  The direction that Scheme took was _not_ part
  of this consolidation and compromise process, no matter how much this
  lexical scoping thing may be credited to Scheme (history has a way of
  showing that cross-pollination happens when the time is right), and
  Scheme is therefore the odd language out -- it left the Lisp family
  before the important shift.  Scheme is what the Lisp community did _not_
  agree upon.  That Scheme predates Common Lisp by several years strongly
  supports this view.  Those who were not enamored by Scheme, went on to
  work with the Lisp that remained.

  The Scheme that was a dialect of "Lisp" is no longer the same Scheme,
  either -- it has evolved quite a bit and in a very different direction
  than the _supposed_ other "dialects of Lisp".  By choosing a new name,
  the budding community also made it clear that it was departing from the
  rest of the Lisp fold to go independent.  When they got what they wanted,
  some mysteriously want back in the fold, and that is incomprehensible
  from an evolutionary stand-point, unless they intend to be predators on
  their heritage and want "Lisp" for themselves -- which is also what many
  object to when they hear "Scheme is a Lisp", because it no longer is in
  any meaningful sense that people immediately understand unless they are
  purposefully obtuse.

  Both of these clearly imply that it is counterproductive for both
  languages to claim to be dialects of each other, because the _evolution_
  and "growing apart" that Common Lisp and Scheme have done from whatever
  the ancient "Lisp" they could have been dialects of, is effectively
  _denied_ to have taken place when Scheme and Common Lisp are portrayed as
  just as closely related as they were, what, 25 years ago.  The message
  that is therefore actually being sent by "Scheme is a Lisp" is "neither
  Lisp nor Scheme have evolved in 25 years", and that is wrong and very,
  very counterproductive.

| Why is Scheme not a Lisp?  Does Scheme lack some necessary feature that
| is required to be considered a Lisp in your book?  Was Lisp 1.5 a Lisp?

  You _should_ be asking what "being a Lisp" means that would make "Scheme
  is a Lisp" and "Common Lisp is a Lisp" true.  The two languages and their
  attendant communities have drifted so far apart that there is nothing of
  value in their intersection.  Add D*lan to the fray, and I think there is
  actually _nothing_ left, and that "being a Lisp" is diluted beyond any
  possibly useful and informative meaning.

  So by saying "Scheme is not a Lisp" I do not deny the historical and the
  evolutionary commonality up to a particular point, I am just saying it in
  the same sense as "Homo sapiens is not a simian", although some would
  probably spend all day arguing that any evidence of evolution has yet to
  show up in, say, the Middle East.

  But what is this "Lisp" that Scheme is?  I maintain that it is a concept
  evacuated by evolllution.  What is left in this concept for you?  Please
  remember that you have to accomodate D*lan users who argue the same way
  Scheme users do about the supposed Lisp nature of their pet language.

[*] Totally OT: _Homo sapiens_ is an African Ape, certainly a simian.
We're far closer evolutionarily to chimpanzees and gorillas than
either of those are to orangutans, not to mention New World monkeys.
There's really no debate here (if you want debate, ask if chimpanzees
and bonobos should be genus Pan or Homo...)

I don't offer this as an argument for or against
`Scheme is/is not a Lisp', I'm just trying to clear up a common
misconception.

------------ old post follows ------------

Near the end of R5RS, there is a section that gives a BNF grammar for
Scheme.  There are two relevant sections, the one on `Programs and
Definitions' and the one on `Expressions'.

There are two ways to interpret the right-hand-side of these grammars:
a purely textual way, or as printed representation.
For example, the rule for a conditional:

<conditional> --> (if <test> <consequent> <alternate>)

If you adopt a `purely textual' interpretation, you would say that a
conditional expression is defined the token sequence:

<(> <optional whitespace> <if> <whitespace> [expression] <whitespace>
[expression] <whitespace> [expression] <optional whitespace> <)>

Suppose instead, that the right-hand-side was interpreted as the
printed representation of the grammar.  Then,

<conditional> --> (if <test> <consequent> <alternative>)

would mean that a conditional is formed from a list of four elements,
the first being the symbol if, the second, third, and fourth being
whatever subexpressions are in the list.

If you attempt to apply the `purely textual' interpretation, you run
into numerous difficulties:

  1.  Eval takes `expressions represented as data'.  But expressions
      are defined solely as token sequences, and there is no mapping
      between expressions and data.

  2.  Many places in the text point out how useful it is to be able
      to use read to read programs.

  3.  Quasiquote (backquote) is an operation defined on lists,
      therefore it could not be used in a program.

  4.  Macros, too, would be disallowed.

  5.  The interpretation of a subform as <expression> or <datum> is
      context sensitive. For example, the second element in
      "(foo (+ a b c))" may or may not be an <expression> depending
      upon whether foo is a macro that expands into QUOTE.  If
      the external representation of expressions cannot include dotted
      lists, the reader would be required to discriminate between
      "(foo (+ a b . (c)))" and "(foo (+ a b c))" in precisely those
      contexts where foo has a macro binding -- information that is
      not available at read time!

  6.  Derived expressions are defined as macro expansions.  Macros
      accept <datum> as an argument, not <expression>.  Therefore, the
      BNF grammar for derived expressions is inconsistent with the
      recommended macro expansions.

[much snippage]

  But that is the whole point.  There are so many things that are true only
  of homo sapiens but not of other simians that talking about people as
  "simians" is completely worthless.  So it certainly seems you missed my
  point entirely and got hung up the exact same taxonomic snag that has
  caught the Scheme freaks who want it to be a Lisp.  In particular, my
  stab at the warring idiots in the Middle East was intended to communicate
  what it would mean to call somebody a "simian" today.

  Put another way: arguing that Scheme is "a Lisp" is like arguing that it
  is "a programming language".  On the one hand, of course it is.  On the
  other hand, of _course_ saying this does something in a discussion where
  people already know what a programming language is and that Scheme is one
  of them.  Take this scenario: You discuss the merits of several
  programming languages with a group of friends, and then you make a huge
  point out of Scheme being a programming language.  There are basically
  two ways to react to this: either (1) you are an annoying idiot who has
  failed to grasp what people have been talking about -- and gets whatever
  beer is left poured over your head, or (2) you are an arrogant bastard
  who denigrates every other programming language by effectively arguing
  that Scheme is the only one that _really_ merits that name -- and gets
  whatever beer is left poured over your head.  People assume that when you
  say something, it has greater value to you than to shut up, so if you
  something that is either blindingly obvious and irrelevant, it does in
  fact communicate hostility to any _thinking_ audience.  (I do not care
  much about unthinking audiences, who sometimes react very differently to
  redundant idiocy and empty, meaningless statements -- some even vote for
  the guy.)

  When was this written?

| Injured?  No.  Whatever gave you that impression?

  If not you, some people sure act terribly injured if you say "Scheme is
  not a Lisp" to them or tell them to stop saying "Scheme is a Lisp".

(variously attributed to Uriel Weinreich, Max Reinreich, Noam Chomsky,
Joshua Fishman ...)

-dan

--