Why is Scheme not a Lisp?

2983 views
Skip to first unread message

Erann Gat

unread,
Mar 12, 2002, 3:00:23 PM3/12/02
to

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.

Thanks,
Erann
g...@jpl.nasa.gov

Rahul Jain

unread,
Mar 12, 2002, 4:06:08 PM3/12/02
to
g...@jpl.nasa.gov (Erann Gat) writes:

> I'm just interested in hearing from those people who already believe
> that it isn't what their rationale is.

Here's my rationale: If Scheme were a lisp, it would call itself a
Lisp. Does Java call itself a C? No, because it's not a C.

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.

--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- mailto:rj...@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.

Barry Margolin

unread,
Mar 12, 2002, 4:16:13 PM3/12/02
to
In article <gat-120302...@eglaptop.jpl.nasa.gov>,

Erann Gat <g...@jpl.nasa.gov> wrote:
>
>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?

The decision of whether to call something a dialect or a separate language
is generally arbitrary and subjective, and frequently based more on
political issues rather than technical ones. Scheme users have chosen to
separate themselves philosophically from Lisp users, so despite the many
similarities, they consider them distinct languages.

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).

--
Barry Margolin, bar...@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.

Carl Shapiro

unread,
Mar 12, 2002, 4:16:57 PM3/12/02
to
g...@jpl.nasa.gov (Erann Gat) writes:

> 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?

If you would like instant gratification, Google Groups has a complete
record of discussions dealing with this very question.

Kent M Pitman

unread,
Mar 12, 2002, 4:44:35 PM3/12/02
to
g...@jpl.nasa.gov (Erann Gat) writes:

> 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.)

This isn't quite fair. You can find writing of mine that calls it a Lisp,
too, but this is because it is sometimes easier to use another's terminology
than to make a political statement every time you want to have a simple
discussion.

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).

> 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.

Count me in with Erik. Even if I don't get to be notable. ;)

> 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?

First, it doesn't call itself Lisp. It calls itself Scheme.

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.

> 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.

I don't think it's got to be totally one way or the other. Sometimes
it's useful to blur the distinction, e.g., for outreach, as I did when
discussing Lisp and Scheme on Slashdot. It wasn't worth portraying us
as separate communities there, where people are standing at such a
distance. But as one gets closer, I think the differences very much
matter. And proper placement in the right political party is better
than trying to bang your head against the wall in the wrong one.

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.

Let me turn the question around: Make a list of the value you get from
insisting there is not a division. Then make a list of the confusions,
irritations, frustrations, and deadlocks that occur by merging them.
Then ask--which list has the most weight? For me, the answer is plainly
one where the grief to be avoided by separation is bigger than the value
to be gained by globbing things together. Don't you agree? What is
your agenda/purpose in wanting the answer to come out that we're all
indistinguishable under a then-completely-useless predicate of Lispness?
I feel as if I'm missing something because it sounds like you're somehow
injured by this, and I just don't see how. I think everyone is enriched
by the current division.

Dorai Sitaram

unread,
Mar 12, 2002, 4:57:12 PM3/12/02
to
In article <xeuj8.16$on4...@paloalto-snr2.gtei.net>,

Barry Margolin <bar...@genuity.net> wrote:
>Scheme users have chosen to
>separate themselves philosophically from Lisp users, so despite the many
>similarities, they consider them distinct languages.

If Scheme users themselves consider Scheme to be a
non-Lisp as you say, I can't see where the conflict
of views is coming from. Who are the two groups
holding opposing views here?

--d

Lieven Marchand

unread,
Mar 12, 2002, 3:35:02 PM3/12/02
to
Barry Margolin <bar...@genuity.net> writes:

> 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.

Defining what a language is in linguistics has about the same problems
as defining a species in biology. The mutual intelligibility criterium
shows the analogue of ring species, it isn't transitive and so you
can't use it as an equivalence relation on "languages". Starting from
the west coast of Flanders, you can go through Flanders towards
Germany and so onto Austria and Swiss along a path of mutually
understandable dialects but the end points are very different
languages.

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.

--
Lieven Marchand <m...@wyrd.be>
She says, "Honey, you're a Bastard of great proportion."
He says, "Darling, I plead guilty to that sin."
Cowboy Junkies -- A few simple words

Lieven Marchand

unread,
Mar 12, 2002, 3:44:58 PM3/12/02
to
g...@jpl.nasa.gov (Erann Gat) writes:

> 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?

Scheme is not a Lisp IMO because of two types of reasons: first,
technical, which have been argued on this group ad nauseam (the
deepest difference there to me is that a scheme program is defined as
a string of characters whereas a CL program is defined as a sequence
of lists of Lisp objects. This may seem pedantic or trivial but a lot
of different design decisions follow from this. It makes Scheme an
infix member of the Algol language family.); but more important,
philosophically. The Scheme community has evolved a set of values at
odds with the spirit of Lisp: the goal for simplicity at the expense
of convenience (compare the concept of CL's $item designators with the
design of convert stuff explicitly like Scheme's exact->inexact), the
goal of only giving basic blocks and letting you assemble stuff
yourself (call/cc isn't a replacement for a worked out exception
system).

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.

Dorai Sitaram

unread,
Mar 12, 2002, 5:16:10 PM3/12/02
to
>
>First, it doesn't call itself Lisp. It calls itself Scheme.

Actually it does too calls itself a Lisp. Vide
the standard. But if one means that it doesn't have
the substring "Lisp" in its name, then taxonomy isn't
determined by name substrings. An elephant is a
mammal, a hammer is a tool, a car is a vehicle, and a
German is a European.

--d

Craig Brozefsky

unread,
Mar 12, 2002, 5:19:44 PM3/12/02
to
ds...@goldshoe.gte.com (Dorai Sitaram) writes:

Since the issue of making the distinction depends on the context
(political and technical) it is not surprising that in various heated
discussions the participants come to different conclusions about
wether to uphold the distinction or not, often depending upon how it
suits their argument.

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.


--
Craig Brozefsky <cr...@red-bean.com>
http://www.red-bean.com/~craig
Ask me about Common Lisp Enterprise Eggplants at Red Bean!

Rahul Jain

unread,
Mar 12, 2002, 5:26:07 PM3/12/02
to
ds...@goldshoe.gte.com (Dorai Sitaram) writes:

> If Scheme users themselves consider Scheme to be a non-Lisp as you
> say, I can't see where the conflict of views is coming from. Who
> are the two groups holding opposing views here?

I think it's a small group of insecure Scheme users who think that
they should be considered "A Lisp" so that they get all the
"publicity" that Lisp does along with the publicity that Scheme does.

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.

Dorai Sitaram

unread,
Mar 12, 2002, 6:06:19 PM3/12/02
to
In article <87g0352...@photino.sid.rice.edu>,

Rahul Jain <rj...@sid-1129.sid.rice.edu> wrote:
>
>I think it's a small group of insecure Scheme users who think that
>they should be considered "A Lisp" so that they get all the
>"publicity" that Lisp does along with the publicity that Scheme does.
>
>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'll admit I don't want those epithets any more than
the next guy, Rahul, but I find I cannot honestly alter
my opinion that Scheme is a Lisp. Perhaps
Erann's call will unearth some new technical insight
that will change my mind.

I thank you for your vigorous response.

--d

Barry Margolin

unread,
Mar 12, 2002, 5:25:28 PM3/12/02
to

Many Lisp programmers consider Scheme to be a dialect of Lisp. In my
opinion, Scheme, Interlisp, Maclisp, Common Lisp, Lisp 1.5, and even Dylan
are all dialects within the Lisp family of languages. (Dylan's surface
syntax is no longer Lisp-like, although it originally was, but its
underlying operation is very much like most other Lisps.)

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 ..."

Barry Margolin

unread,
Mar 12, 2002, 5:35:04 PM3/12/02
to
In article <87g035i...@piracy.red-bean.com>,

Craig Brozefsky <cr...@red-bean.com> wrote:
>Since the issue of making the distinction depends on the context
>(political and technical) it is not surprising that in various heated
>discussions the participants come to different conclusions about
>wether to uphold the distinction or not, often depending upon how it
>suits their argument.
>
>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.

Although it often depends on the specific subject matter.

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.

Rahul Jain

unread,
Mar 12, 2002, 6:14:51 PM3/12/02
to
ds...@goldshoe.gte.com (Dorai Sitaram) writes:

> I find I cannot honestly alter my opinion that Scheme is a Lisp.

It all depends on how you define "Lisp". Remember that meanings
change, communities change over time. At one time, scheme was a
lisp. Now Lisp has moved on, as has Scheme. Scheme people like where
Scheme has gone. Lisp people like where Lisp has gone. There's usually
not much overlap.

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?

Erik Naggum

unread,
Mar 12, 2002, 6:20:41 PM3/12/02
to
* Erann Gat

| 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.)

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.

///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.

Kent M Pitman

unread,
Mar 12, 2002, 6:23:07 PM3/12/02
to
ds...@goldshoe.gte.com (Dorai Sitaram) writes:

> ... I find I cannot honestly alter my opinion that Scheme is a Lisp.


> Perhaps Erann's call will unearth some new technical insight that
> will change my mind.

Are you wedded to the idea that the insight to be sought should be
technical? Most human language divisions are not drawn on technical
lines, or, if they are, it's only among researchers and not among the
general public. Ultimately, aren't the real issues things like "who
has the right to speak for it?" and "who has the right to change it?"
and things like that? Whatever you think of who that might be, surely
you don't think that's decided by some sort of technical criterion...?
Why is the choice of a name, something that has no material technical
implication on any program's execution, a technical matter?

Erik Naggum

unread,
Mar 12, 2002, 6:33:46 PM3/12/02
to
* Dorai Sitaram

| I'll admit I don't want those epithets any more than the next guy, Rahul,
| but I find I cannot honestly alter my opinion that Scheme is a Lisp.

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.

Thomas F. Burdick

unread,
Mar 12, 2002, 6:43:08 PM3/12/02
to
Erik Naggum <er...@naggum.net> writes:

> 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.

Terrible, terrible example, and I'm jumping on it hoping to beat
others to the punch. The rest of your post was quite good, I just
hope the ending example doesn't color your conclusion for others[*].

[*] 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...)

--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'

Joe Marshall

unread,
Mar 12, 2002, 6:44:21 PM3/12/02
to

"Lieven Marchand" <m...@wyrd.be> wrote in message
news:m3pu29o...@localhost.localdomain...

> Scheme is not a Lisp IMO because of two types of reasons: first,
> technical, which have been argued on this group ad nauseam (the
> deepest difference there to me is that a scheme program is defined as
> a string of characters whereas a CL program is defined as a sequence
> of lists of Lisp objects.

For those insufficiently nauseated, here is something I posted
to comp.lang.lisp some time ago that argues that the notion
that ``a scheme program is defined as a string of characters''
is not supportable.

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.

If you instead accept that the right-hand-side of the BNF grammar is
to be interpreted as the printed representation of the list structure
by which programs are representable, *all* of the above problems
disappear. Note that I said `representable'. The spec does not
*require* that programs be `read' by the procedure `read', nor that
the entire program be turned into list structure before compiling, but it
*does* require that program fragments be representable and manipulable
as list structure for the purposes of eval and macro expansion, and
that the fragments behave as if they were read by read.

Erann Gat

unread,
Mar 12, 2002, 6:42:07 PM3/12/02
to
In article <sfwy9gx...@shell01.TheWorld.com>, Kent M Pitman
<pit...@world.std.com> wrote:

> First, it doesn't call itself Lisp. It calls itself Scheme.

The introduction to R5RS says, "Scheme was the first major dialect of Lisp
to [have certain distinguishing features]". So it does call itself a
"dialect of Lisp."

[much snippage]

> Let me turn the question around: Make a list of the value you get from
> insisting there is not a division.

I'm not insisting on anything. I'm just asking a question.

> Then make a list of the confusions,
> irritations, frustrations, and deadlocks that occur by merging them.
> Then ask--which list has the most weight? For me, the answer is plainly
> one where the grief to be avoided by separation is bigger than the value
> to be gained by globbing things together. Don't you agree?

No, but my experience has obviously been different from yours.

> What is
> your agenda/purpose in wanting the answer to come out that we're all
> indistinguishable under a then-completely-useless predicate of Lispness?

I don't have an agenda. I was just curious.

> I feel as if I'm missing something because it sounds like you're somehow
> injured by this, and I just don't see how.

Injured? No. Whatever gave you that impression?

E.

Erik Naggum

unread,
Mar 12, 2002, 7:18:24 PM3/12/02
to
* Erik Naggum

> 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.

* Thomas F. Burdick


| Terrible, terrible example, and I'm jumping on it hoping to beat others
| to the punch. The rest of your post was quite good, I just hope the
| ending example doesn't color your conclusion for others[*].
|
| [*] 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...)

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.)

Erik Naggum

unread,
Mar 12, 2002, 7:23:34 PM3/12/02
to
* Erann Gat

| The introduction to R5RS says, "Scheme was the first major dialect of
| Lisp to [have certain distinguishing features]". So it does call itself
| a "dialect of Lisp."

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".

Daniel Barlow

unread,
Mar 12, 2002, 7:08:15 PM3/12/02
to
Lieven Marchand <m...@wyrd.be> writes:

> Defining what a language is in linguistics has about the same problems
> as defining a species in biology.

[...]


> 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.


"A language is a dialect with an army and a navy"

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


-dan

--

http://ww.telent.net/cliki/ - Link farm for free CL-on-Unix resources

Erann Gat

unread,
Mar 12, 2002, 8:05:57 PM3/12/02
to
In article <32249678...@naggum.net>, Erik Naggum <er...@naggum.net> wrote:

> * Erann Gat
> | The introduction to R5RS says, "Scheme was the first major dialect of
> | Lisp to [have certain distinguishing features]". So it does call itself
> | a "dialect of Lisp."
>
> When was this written?

R5RS is dated 20 February 1998. It's the most recent Scheme standard.

> The two languages and their
> attendant communities have drifted so far apart that there is nothing of
> value in their intersection.

What about the use of S-expressions to represent both code and data?

E.

Larry Clapp

unread,
Mar 12, 2002, 9:12:21 PM3/12/02
to
In article <gat-120302...@eglaptop.jpl.nasa.gov>, Erann Gat wrote:
> 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?

If you ask me (and you sort of did :), the problem arises in part from the use
of "is". See www.generalsemantics.org and in particular
http://www.generalsemantics.org/eprime/contents.htm and other articles on
E-prime, which describe speaking and writing English without the use of the
verb "to be".

Kent, I think, dealt with this issue very clearly and yet subtly. Omitting
much excellent and thoughtful writing, I might make free to summarize Kent's
article: "Scheme has these characteristics and this community, and Common Lisp
has these other characteristics and this other community. While these
characteristics and communities overlap in some places, they diverge in many
much more important places."[1]

I don't think one can say that a) Common Lisp comes from a subset of Scheme,
b) Scheme comes from a subset of Common Lisp, c) Common Lisp and Scheme form
different subsets of some larger language, or d) Common Lisp and Scheme form
different supersets of some smaller language.[2]

You can (maybe) say that Common Lisp and Scheme diverged from a common
ancestor (should I give a link to the talk.origins FAQ? ;), but not much
else.

My US$0.02.

-- Larry


[1] Any errors in this summary come from me, of course.

[2] Note: I don't accuse you or anyone of making any of these claims.

Geoffrey Summerhayes

unread,
Mar 12, 2002, 10:57:41 PM3/12/02
to

"Erann Gat" <g...@jpl.nasa.gov> wrote in message
news:gat-120302...@eglaptop.jpl.nasa.gov...

> In article <32249678...@naggum.net>, Erik Naggum <er...@naggum.net>
wrote:
>
> > * Erann Gat
> > | The introduction to R5RS says, "Scheme was the first major dialect of
> > | Lisp to [have certain distinguishing features]". So it does call
itself
> > | a "dialect of Lisp."
> >
> > When was this written?
>
> R5RS is dated 20 February 1998. It's the most recent Scheme standard.
>

LOL Good comeback.

I have a published copy of Hamlet with the date 1994. What does
say about when, "I am but mad north-north-west. When the wind is
southerly, I know a hawk from a handsaw." was penned?

Take a look at the introduction to R4RS and think recursively. :-)

-------------

Geoff

Christopher C. Stacy

unread,
Mar 13, 2002, 12:20:43 AM3/13/02
to
The "Is Scheme a Lisp" debate implies that there is an answer to
the following question: "What is Lisp?". Good luck.

Anyway, as KMP will no doubt write, these are political questions
about different camps and self-identities. When the ensuing flame
war dies down to a smolder, there will still be no definitive answer.

Christopher C. Stacy

unread,
Mar 13, 2002, 12:33:34 AM3/13/02
to
>>>>> On Tue, 12 Mar 2002 23:20:41 GMT, Erik Naggum ("Erik") writes:
Erik> people who hear that "Scheme is a Lisp" tend to think that
Erik> what they have learned is valid for some other Lisps they
Erik> meet, too.

This goes to the reason why I make the distinction, and is
exactly the same as when around 1982 I used to have to explain
that "Lisp" does not mean: "Lisp 1.5, as badly explained to you".
The technicalities are different in those two examples, but the
problem is the same: a bunch of incorrect assumptions and
misunderstandings that will make a useful discussion difficult.

Rahul Jain

unread,
Mar 13, 2002, 12:30:23 AM3/13/02
to
cst...@theworld.com (Christopher C. Stacy) writes:

> Anyway, as KMP will no doubt write, these are political questions
> about different camps and self-identities.

This just made me think of the Republican and Democratic parties in
the US. They were originally the same party, which split some time in
the mid 19th century or so, IIRC.

Thomas Bushnell, BSG

unread,
Mar 13, 2002, 1:26:04 AM3/13/02
to
Rahul Jain <rj...@sid-1129.sid.rice.edu> writes:

> This just made me think of the Republican and Democratic parties in
> the US. They were originally the same party, which split some time in
> the mid 19th century or so, IIRC.

No, you recall incorrectly.

The Democratic party dates back to a previous party named the
"Democratic Republican Party", which was an opponent of the Federalist
Party. The Democratic Republicans wanted the US to be a "democratic
republic", you see; the Federalists stressed the federal system.

The Democratic Republicans morphed their name into the Democrats, for
the obvious reason--a shorter name is better; that happened when
Andrew Jackson was president. (He was elected in 1824 as a Democratic
Republican, and in 1828 as a Democrat.)

The Democratic Republicans trounced the Federalists very quickly, in
1800. There was a "National Republican" party of some brief note, and
some coalition opponents as well, but from 1801 to 1840,with the sole
exception of the 1824 election, the Democratic Republicans ruled the
White House. The Whig party was formed to offer credible opposition
to the Democrats, and did win the White House in 1840, and things went
back and forth until the Republican Party was formed.

The Republicans were brand spankin new; they first contended in 1856,
and then won the White House in 1860 under Abraham Lincoln.

Since that time, it's mostly been the Republicans and the Democrats,
though some Democratic Presidential candidates ran under double
affiliations, linking up with the Progressives or the Liberal
Republicans. Teddy Roosevelt ran in 1912 as a Progressive (and lost
to Woodrow Wilson).

Thomas

Thomas Bushnell, BSG

unread,
Mar 13, 2002, 1:29:09 AM3/13/02
to
Rahul Jain <rj...@sid-1129.sid.rice.edu> writes:

> Here's my rationale: If Scheme were a lisp, it would call itself a
> Lisp. Does Java call itself a C? No, because it's not a C.

But Scheme does call itself a Lisp!

The very beginning of the R5RS reads:

"The report gives a defining description of the programming language
Scheme. Scheme is a statically scoped and properly tail-recursive
dialect of the Lisp programming language invented by Guy Lewis Steele
Jr. and Gerald Jay Sussman."

Thomas

Thomas Bushnell, BSG

unread,
Mar 13, 2002, 1:32:17 AM3/13/02
to
Rahul Jain <rj...@sid-1129.sid.rice.edu> writes:

> I think it's a small group of insecure Scheme users who think that
> they should be considered "A Lisp" so that they get all the
> "publicity" that Lisp does along with the publicity that Scheme does.

People like that indeed have a problem. Scheme doesn't want to be "a
Lisp" so that it gets some publicity or caché. Or at least, sensible
people shouldn't be caring about such things.

> 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.

Maybe you've misunderstood them.

Thomas Bushnell, BSG

unread,
Mar 13, 2002, 1:33:11 AM3/13/02
to
Rahul Jain <rj...@sid-1129.sid.rice.edu> writes:

> It all depends on how you define "Lisp". Remember that meanings
> change, communities change over time. At one time, scheme was a
> lisp. Now Lisp has moved on, as has Scheme. Scheme people like where
> Scheme has gone. Lisp people like where Lisp has gone. There's usually
> not much overlap.

I'm a Scheme person. And I like where Scheme has gone.

I also like where Common Lisp has gone.

Why should I pick? Both are cool languages.

Thomas

Thaddeus L Olczyk

unread,
Mar 13, 2002, 3:38:25 AM3/13/02
to
On 12 Mar 2002 23:30:23 -0600, Rahul Jain
<rj...@sid-1129.sid.rice.edu> wrote:

>cst...@theworld.com (Christopher C. Stacy) writes:
>
>> Anyway, as KMP will no doubt write, these are political questions
>> about different camps and self-identities.
>
>This just made me think of the Republican and Democratic parties in
>the US. They were originally the same party, which split some time in
>the mid 19th century or so, IIRC.
>
>--
>-> -/ - Rahul Jain -

aka A person stupid enough to advertise his ignorance of American
history by making false statements about it.

Thaddeus L Olczyk

unread,
Mar 13, 2002, 3:44:48 AM3/13/02
to
On Tue, 12 Mar 2002 12:00:23 -0800, g...@jpl.nasa.gov (Erann Gat)
wrote:

Use the simple and most basic test of whether or not Scheme is a Lisp.

Assume you take a standard text book ( say one of the following
ACL by Paul Graham, Dr. Touretsky's book, Successful Lisp
or David Coopers book ). Assuming you have no previous experience
in Lisp ( or Scheme). Instal a Scheme compiler and start writing for
it. How much do you have to thumb through a Scheme reference.
If it's significantly less than the amount a C programmer thumbs
through a Pascal reference when writing a Pascal program, then
Scheme is a Lisp. If not then Scheme is not a Lisp. ( BTW no
C programmer or Pascal programmer would claim C is a dialect of Pacal.
)

Kent M Pitman

unread,
Mar 13, 2002, 4:52:27 AM3/13/02
to

I'm worried that the same test, done in reverse, with a Scheme text and
a Lisp compiler would conclude that Lisp is a Scheme. That seems a bad
property of the test. It tests distance, not containment.

Also, when I first learned to program, it was with FORTRAN on punch cards on
an IBM 1130. Then our school bought a WANG 2200S minicomputer that
ran BASIC and I thumbed through a manual. I had no sense then of the
space of computer languages. I had seen only FORTRAN. My initial
assumption was that BASIC was just a FORTRAN variant. Had I used
your test, I might well have concluded that it confirmed my suspicions.

And also, I think both C and Pascal are members of the Algol family.
But your test seems to presuppose they are unrelated languages. Then
again, my purpose in relating these languages, when I do, is mostly to
make broad classifications of languages. This has almost no
operational meaning other than "they share the notion of block
stucture and infix notation". That's pretty weak and useless in most
cases. It's often useful to divide the world along certain axes for
momentary purposes of conversation; that's not the same as saying that
it's the right way to describe them.

Historically, as part of the civil rights struggles, people of various
races, and even women of any race, have fought not to be viewed as "objects".
Are they objects? Are you and I objects? Well, we're not abstracts.
If we were coding us up, we'd probably do
(defclass person (animal) ...)
(defclass animal (live-object) ...)
(defclass live-object (object) ...)
But that doesn't mean this is our best view. Referring to a person as an
object is to say "you can get away without understanding any of the more
specialized purposes that have come since" or "there are no new insights to
be had by considering a more specific type".

Sometimes it is good to ignore more specific types. For example, when we
refer to floats, we often ignore double-float vs single-float because most
of the time dealing in the abstract is less confusing. Sometimes when we
refer to error conditions, it suffices just to know an error has happened,
and the fact of the error kind is very much "in the noise".

The most often reason language families come up in conversation is to say
"are there legitimate new ideas between X and Y such that if I know X it's
still worth learning Y." I think Scheme has ideas Common Lisp doesn't.
I think Common Lisp has ideas Scheme doesn't. Both of these facts argue for
separation. (Even back to my C example, the same can be said for C and
Pascal, which is why I say they are part of the Algol family, which is more
just a statement of historical pedigree than a statement of now-truth.)

I'm comfortable with the analogy raised earlier by Erik about
Germanic. You can say English is a Germanic language. I don't know
what good it does, but you can say it. And yes, you can say Scheme is
part of the Lisp family of languages. But English is its own
language, not a dialect of German. To view English as a Germanic language
is to say "those changes that have happened since are minor" (which might be
true and useful to some linguists in a highly technical conversation on a
narrow and obscure technical point, but is not true of most people in most
practical situations).

Scheme is its own language, not a dialect of Lisp. There is a strong
separation of culture, direction, and practice. To assert it is not
its own language is to deny the importance of those differences and to
call into question all that Scheme has sought to build. It is, in simple
terms, an insult to Scheme.

Scheme and Lisp are fundamentally different way than British and American
are different. British and American are different in pronunciation and in
this and that choice of random word, but most of those differences are mere
nuissance more than an attempt to prove a point.

The separations of ISLISP, Emacs Lisp, and Common Lisp are more like English
and British, where the mere fact of differing points of authority makes for
some drift, but where the fundamental underlying theses of the language are
not really majorly different. These dialects are not intentionally different,
they are merely different because they had different target needs and because
their creators didn't want the administrative overhead of coordinating every
little change with each other's communities. But they didn't go out of their
way to cut ties with the past, they just wanted administrative streamlining.

Even Dylan can be called part of the Lisp language family, if you mean
it in the historical sense of Erik's "Germanic" analogy, though I
certainly again would not call it a dialect of Lisp. And, moreover,
in the case of German, the Dylan marketeers of the past not only chose
a new direction, but some of them actively worked to get a "divorce"
from the Lisp language family because they didn't like the baggage it
carried with it and didn't even want to claim access to their
pedigree. But Dylan is its own language because it sought to really
do something different than what came before. And it would be an
insult again to Dylan to suggest it is a mere dialect of Lisp.

- - - -

I started to tell a story the other day, and I don't recall sending the post,
so I'll risk repeating myself because it was a keen observation:

I took a course at MIT from the late Prof. Bill Martin, who made the following
observation about terminological overloading in type trees (paraphrased from
memory):

The world is divided into inert things and animals. Among animals, of course,
there are animals, vegetables, and minerals. Of those animals, though, there
are things like insects and then there are "real" animals. Among animals,
there are people and then there are animals. Among people, there are
civilized people, and then there are animals.

Maybe we should take a page from Bill's book and before we go much farther
in this conversation, acknowledge that linguistic overloading permitting us
to talk at crossed purposes uselessly, without even being sure we're all
talking about the same thing. We're more likely sparring over the relatively
useless question of "who gets to decide what 'language' means". Chris


Stacy was 100% right in a recent post when he wrote:

Anyway, as KMP will no doubt write, these are political questions

about different camps and self-identities. When the ensuing flame
war dies down to a smolder, there will still be no definitive answer.

The only way in which Chris failed in his prediction is that he should
have said "as KMP will no doubt write (in more detail than should be
really necessary)". I like his summary and should have just gone with it.

Unless I see something new of substance here, I'm going to stop posting
on this thread because, interesting/fun as sparring over this useless topic
is, Chris is right. It's got no hope of going anywhere, and so ultimately
we'll just have to decide we've said what is to be said and then stop.
For now, I've said what I have to say.

Juanma Barranquero

unread,
Mar 13, 2002, 9:39:24 AM3/13/02
to
On Tue, 12 Mar 2002 21:16:13 GMT, Barry Margolin <bar...@genuity.net>
wrote:

>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.

Hmm. No.

There are certainly lots of "languages" considered separate due to
nationalistic attitudes. Just here, in Spain, there are people who
consider as distinct languages català (catalonian), valencià and
mallorquí even if it is easy to prove that speakers are mutually
intelligible. Something similar happens with portuguese and gallego
(galician). But as a Spaniard who's lived in Brazil and visited
Portugal, and whose wife is Brazilian, I can assure you Portuguese and
Spanish are very different. Usually the Portuguese can understand
Spanish with a little effort, even if they aren't able to speak it;
but most Spaniards do *not* understand Portuguese, and even less yet
Brazilian Portuguese.

I'm not being nationalistic here. I like languages a lot and would
cause me no distress to accept Spanish and Portuguese as the same
language; but the fact is that after a full year on Brazil I
understood Portuguese reasonably well but was utterly unable to speak
more than a few stock idioms :)

It is obvious that all latin languages do share some vocabulary and
grammar; but we're talking of more than 1,000 years of separate
development. Just consider how different is Chaucer's English from the
modern language :)

/L/e/k/t/u

Dorai Sitaram

unread,
Mar 13, 2002, 9:43:20 AM3/13/02
to
In article <sfw7koh...@shell01.TheWorld.com>,

Kent M Pitman <pit...@world.std.com> wrote:

Sure, whatever flavor of insight is fine. It's just
that "political reality"-type arguments wouldn't need
explicit belaboring, as everyone would feel it in their
bones already. The reason I specified "technical" was
because it would be much easier both to offer and to
accept. If you could just toss in some convincing
insight amid the "politically plausible"
analogizing, I would have no problem being an
early convert to your view, well before it became
political reality.

--d

Wade Humeniuk

unread,
Mar 13, 2002, 11:08:56 AM3/13/02
to
"Erann Gat" <g...@jpl.nasa.gov> wrote in message
news:gat-120302...@eglaptop.jpl.nasa.gov...
>
> 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?

Both Scheme and CL have concrete specifications, they are specific languages
and by inspection you can tell one from the other. From your question there
seems to be an implication there is a "Lisp" which is independent of
specific implementations. A kind of abstract Lisp much like the idea of
thought-form of a tree as opposed to a specific tree (say a pine). This
Thought-Form-Lisp (TFL) has never existed but seems to be exerting a force
on the development of languages like Scheme and now maybe Arc. It may arise
because of intrinsic insights that the Lisps have into programming in
general (evidenced by how other programming languages start out small and
then start to implement Lisp features because they are necessary). I know
that I am certainly attracted to Lisp for some deeper reason. Maybe people
have been caught by the aesthetics of their TFL. It could explain why
people can be so attached to the language which expresses their TFL best and
some people's frustrations (because of reality constraints) of not being
able to manifest their TFL. This also may explain some people's anger at CL
because of its the gall it shows by "specifying" Lisp.

Wade


Will Hartung

unread,
Mar 13, 2002, 11:37:31 AM3/13/02
to
"Thaddeus L Olczyk" <olc...@interaccess.com> wrote in message
news:3c91101b...@nntp.interaccess.com...

Ok, I'll bite...put my tounge firmly in cheek here, and preface this with
"Be careful what you wish for ...".

I grabbed this off of Grahams site, it's his POV Ray Trace program from ACL.
Used without permission.

(defun sq (x) (* x x))

(defun mag (x y z)
(sqrt (+ (sq x) (sq y) (sq z))))

(defun unit-vector (x y z)
(let ((d (mag x y z)))
(values (/ x d) (/ y d) (/ z d))))

(defstruct (point (:conc-name nil))
x y z)

(defun distance (p1 p2)
(mag (- (x p1) (x p2))
(- (y p1) (y p2))
(- (z p1) (z p2))))

(defun minroot (a b c)
(if (zerop a)
(/ (- c) b)
(let ((disc (- (sq b) (* 4 a c))))
(unless (minusp disc)
(let ((discrt (sqrt disc)))
(min (/ (+ (- b) discrt) (* 2 a))
(/ (- (- b) discrt) (* 2 a))))))))


(defstruct surface color)

(defparameter *world* nil)
(defconstant eye (make-point :x 0 :y 0 :z 200))

(defun tracer (pathname &optional (res 1))
(with-open-file (p pathname :direction :output)
(format p "P2 ~A ~A 255" (* res 100) (* res 100))
(let ((inc (/ res)))
(do ((y -50 (+ y inc)))
((< (- 50 y) inc))
(do ((x -50 (+ x inc)))
((< (- 50 x) inc))
(print (color-at x y) p))))))

(defun color-at (x y)
(multiple-value-bind (xr yr zr)
(unit-vector (- x (x eye))
(- y (y eye))
(- 0 (z eye)))
(round (* (sendray eye xr yr zr) 255))))

(defun sendray (pt xr yr zr)
(multiple-value-bind (s int) (first-hit pt xr yr zr)
(if s
(* (lambert s int xr yr zr) (surface-color s))
0)))

(defun first-hit (pt xr yr zr)
(let (surface hit dist)
(dolist (s *world*)
(let ((h (intersect s pt xr yr zr)))
(when h
(let ((d (distance h pt)))
(when (or (null dist) (< d dist))
(setf surface s hit h dist d))))))
(values surface hit)))

(defun lambert (s int xr yr zr)
(multiple-value-bind (xn yn zn) (normal s int)
(max 0 (+ (* xr xn) (* yr yn) (* zr zn)))))


(defstruct (sphere (:include surface))
radius center)

(defun defsphere (x y z r c)
(let ((s (make-sphere
:radius r
:center (make-point :x x :y y :z z)
:color c)))
(push s *world*)
s))

(defun intersect (s pt xr yr zr)
(funcall (typecase s (sphere #'sphere-intersect))
s pt xr yr zr))

(defun sphere-intersect (s pt xr yr zr)
(let* ((c (sphere-center s))
(n (minroot (+ (sq xr) (sq yr) (sq zr))
(* 2 (+ (* (- (x pt) (x c)) xr)
(* (- (y pt) (y c)) yr)
(* (- (z pt) (z c)) zr)))
(+ (sq (- (x pt) (x c)))
(sq (- (y pt) (y c)))
(sq (- (z pt) (z c)))
(- (sq (sphere-radius s)))))))
(if n
(make-point :x (+ (x pt) (* n xr))
:y (+ (y pt) (* n yr))
:z (+ (z pt) (* n zr))))))

(defun normal (s pt)
(funcall (typecase s (sphere #'sphere-normal))
s pt))

(defun sphere-normal (s pt)
(let ((c (sphere-center s)))
(unit-vector (- (x c) (x pt))
(- (y c) (y pt))
(- (z c) (z pt)))))

(defun ray-test (&optional (res 1))
(setf *world* nil)
(defsphere 0 -300 -1200 200 .8)
(defsphere -80 -150 -1200 200 .7)
(defsphere 70 -100 -1200 200 .9)
(do ((x -2 (1+ x)))
((> x 2))
(do ((z 2 (1+ z)))
((> z 7))
(defsphere (* x 200) 300 (* z -400) 40 .75)))
(tracer (make-pathname :name "spheres.pgm") res))

To get this to work in Scheme I had to:

o Change all of the (defun ...) to (define). Same with (defconstant ...) and
(defparameter ...)

That mostly worked, except for tracer. Scheme didn't have any idea what to
make of that, and didn't seem to have a facility to handle the optional,
defaulted parameter. I guess I have to do it myself.

o Implement all of the defstructs

Scheme doesn't have defstruct, so I had to do all of that from scratch, I
happened to choose lists to do it. Also, I hade to manually perform the
:include in the (defstruct sphere).

o replace all of the (when...), (unless...) forms with appropriate if
statements. I'm sure I could have written (define-syntax ...) structures,
but using the ifs was much easier as I'm unfamiliar with (define-syntax
...).

o needed to define (zerop ..) and (minusp ...)

o I couldn't find an equivalent to (dolist ...), so I used (for-each ...)
and (lambda ...) instead, though the other (do...) forms seem to work.

o I had to write (1+ ...)

o I eleminated the (funcall ...) completely, as they're not necessary.

o I converted the (typecase ...) to a (case...), but I also had to go back
and "type" my lists-that-are-structures so I could test on something, but
since I already had to implement that, what's a little bit more at this
point. Of course, I had to remove the #' reader macros as well.

o The (with-open-file ...) to (with-output-to-file ...).
o No (format ...), so I had to make do with (write ...)
o Apparently Scheme doesn't know about (make-pathname ...) either, so I just
used a string.

Finally, all of the multi-value-bind stuff had to be converted to lists that
were constructed and deconstructed by hand. That was fun.

I think that's about it. Other than that, you're right, it was easy. Any
inexperienced Lisp/Scheme programmer would have had no problem.

Mind you, I used the R5RS reference as a guide for Scheme, not any
particular implementation. It was a thought exercise, and I may have missed
some things. I know there are more capable Schemes out there that would have
made this task easier (if not trivial).

For extra credit, I dumped the code into EMACS and hit M-x eval-buffer. It
complained about (defparameter ...) and (defconstant ...), other than that
it seemed to compile straight away, though I did not run it. Also, I don't
know if my EMACS has the "Common Lisp" package installed. It's a
pre-compiled binary for windoze that I downloaded, and I've never checked.

Now, going the other way around, from Scheme to Lisp would have probably
been MUCH easier (call/cc not withstanding). So, perhaps CL is a Scheme?

:-) ^ 100

Best Regards,

Will Hartung
(vft...@cox.net)


Matthias Blume

unread,
Mar 13, 2002, 10:48:54 AM3/13/02
to
On Tue, 12 Mar 2002 15:00:23 -0500, Erann Gat wrote:


> 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.

The following question is somewhat related:

Would the Lisp as McCarthy originally envisioned it be considered a Lisp?
Back then? Today?

IIRC, the S-expression form of Lisp was created (contrary to what
has been said here numerous items) "to prove a point". It was a
strictly-for-paper-and-eyeballs-only implementation of EVAL that someone
else (a student or coworker of McCarthy? -- I forget the details) then
took and implemented (to the initial disgust of McCarthy). McCarthy devised EVAL
as a proof-of-concept, showing how the Lisp he envisioned (with a rather
different, more Algolish-looking syntax) has its very own universal
function.

What McCarthy wanted Lisp to look like was called the "meta language" aka
M-expressions. (Is it pure coincidence that today there is another computer
language whose name is the acronym for "Meta Language"?)

Matthias

PS: To the person who said that ML was created to "prove a point": You
are absolutely right, literally. :-)

Doug Quale

unread,
Mar 13, 2002, 12:45:34 PM3/13/02
to
Kent M Pitman <pit...@world.std.com> writes:

> I'm worried that the same test, done in reverse, with a Scheme text and
> a Lisp compiler would conclude that Lisp is a Scheme. That seems a bad
> property of the test. It tests distance, not containment.

The essential problem with all these sorts of arguments is that you
repeatedly assume your own conclusion. What is a lisp compiler or a
lisp text? You always equate Lisp with Common Lisp. This is very
sly, but it doesn't make a sound argument. (Technically speaking,
this is begging the question.) The Lisp family is a family of
languages, not a single language.

Although you've banged hard on the community angle, an objective view
of language families needs to consider at least these factors:

- history
- community
- syntax
- semantics

The question has been raised repeatedly, what does it mean to say "X
is a Lisp", or what advantage does it give? "Scheme is a Lisp", or
more fully "Scheme is a member of the lisp language family" emphasizes
the substantial common ground in those four important areas with other
members of the lisp family. I think this is useful. Obviously some
Common Lisp fans do not.

An interesting comparison can be made with the Algol family of
languages. This family includes Algol 60 as the founding member and
has many members including Algol-W, PL/1, Pascal, C and Ada. The
Algol family includes members that are far more different that Common
Lisp and Scheme. No one would ever confuse Algol 60 and Ada, but they
are members of the Algol family all the same.

Kent has argued rationally that Scheme is not a Lisp, but most people
arguing in favor of that view have not been so dispassionate. The
interesting thing is that for some Common Lisp users, the question of
whether Scheme is a Lisp is a religious one rather than a technical
one. I can't even imagine that level of emotion in a discussion
between Pascal and C partisans about the common cultural and
historical origins of their languages, although they can disagree very
heatedly about the relative merits of their chosen languages. (By way
of contrast, I think from a Scheme or Common Lisp point of view, many
might say the differences between Pascal and C aren't very important.)

Despite what some Scheme haters in c.l.l say, I think very few Scheme
users have any strong intellectual or emotional investment in this
question. I think the initial inquiry was prompted more by a desire
to understand the venom displayed towards Scheme in c.l.l than a need
to prove anything. "Why do they hate us?" has gained a lot of
attention recently in areas much more important than computer
programming languages.

As a final thought, it's quite funny that someone can say that Common
Lisp is a lisp-2 and Scheme is a lisp-1, and then in the next breath
say Scheme is not a Lisp.


--
Doug Quale

Erik Naggum

unread,
Mar 13, 2002, 1:15:28 PM3/13/02
to
* tb+u...@becket.net (Thomas Bushnell, BSG)

| But Scheme does call itself a Lisp!
|
| The very beginning of the R5RS reads:
|
| "The report gives a defining description of the programming language
| Scheme. Scheme is a statically scoped and properly tail-recursive dialect
| of the Lisp programming language invented by Guy Lewis Steele Jr. and
| Gerald Jay Sussman."

But how can you trust a specification that says the Lisp programming
language was invented by Guy Lewis Steele, Jr., and Gerald Jay Sussman?

Nils Goesche

unread,
Mar 13, 2002, 1:29:33 PM3/13/02
to
In article <32250321...@naggum.net>, Erik Naggum wrote:
> * tb+u...@becket.net (Thomas Bushnell, BSG)
>| But Scheme does call itself a Lisp!
>|
>| The very beginning of the R5RS reads:
>|
>| "The report gives a defining description of the programming language
>| Scheme. Scheme is a statically scoped and properly tail-recursive dialect
>| of the Lisp programming language invented by Guy Lewis Steele Jr. and
>| Gerald Jay Sussman."
>
> But how can you trust a specification that says the Lisp programming
> language was invented by Guy Lewis Steele, Jr., and Gerald Jay Sussman?

Hehehe - one should submit a bug report asking them to put claims
like that in denotational semantics in the future :-)

Regards,
--
Nils Goesche PGP key ID 0x42B32FC9

"The sooner all the animals are dead, the sooner we'll find
their money." -- Ed Bluestone

Dorai Sitaram

unread,
Mar 13, 2002, 1:35:56 PM3/13/02
to
In article <a6noi8$gk6$1...@news.gte.com>, Dorai Sitaram <ds...@gte.com> wrote:
>In article <sfw7koh...@shell01.TheWorld.com>,
>Kent M Pitman <pit...@world.std.com> wrote:
>>
>>Are you wedded to the idea that the insight to be sought should be
>>technical? Most human language divisions are not drawn on technical
>>lines, or, if they are, it's only among researchers and not among the
>>general public. Ultimately, aren't the real issues things like "who
>>has the right to speak for it?" and "who has the right to change it?"
>>and things like that? Whatever you think of who that might be, surely
>>you don't think that's decided by some sort of technical criterion...?
>>Why is the choice of a name, something that has no material technical
>>implication on any program's execution, a technical matter?
>
>[my reply snipped]

Kent, I replied in good faith because I thought your
extensive set of questions specifically addressed
to me were in expectation of an answer.

I learned too late from another article of yours (to
someone else) that you had publicly announced
your withdrawal from the dicussion.

I am not a big fan of these staged withdrawals --
however it's your privilege. How about a little
email heads-up next time you adopt this approach?

Cheers,

--d

Erik Naggum

unread,
Mar 13, 2002, 1:55:20 PM3/13/02
to
* Erann Gat
| The introduction to R5RS says, "Scheme was the first major dialect of
| Lisp to [have certain distinguishing features]". So it does call itself
| a "dialect of Lisp."

* Erik Naggum
> When was this written?

* Erann Gat


| R5RS is dated 20 February 1998. It's the most recent Scheme standard.

OK, I see I have to be extremely explicit here. That bores the hell out
of me, so I am not going to repeat the effort.

When people write something, they do so in a particular context, even
though they are not necessarily consciously aware of this context. In
particular, the meaning of a word is contextual and the external
references refer to other things as they both exist and are understood by
the particular person at that particular time. In particular, a sentence
like the above might have been true once, but the common referent for
"Lisp" may change, so it has to be understood in its historical context.
The Bible works that way, and people have to assume (or "temporarily
adopt", since you have demonstrated problems understanding this word,
too) a special context to understand it properly. The same is true of
most non-fiction, actually, and the more specialized some area is, the
more context becomes explicit. In fact, the bibliographic references of
a scientific paper works to establish the context in which the paper is
written as well as its soundness. In particular, a scientific paper
makes its position in time very explicit through its bibliographic
references, and thus establish the time-dependent meaning of any term,
the time-dependent status of any theory, and the time-dependent referents
of a concept. The ability to understand that something changes in time,
that it is indeed a "fourth dimension" that we travel through, seems to
take some time for many people to develop, and the ability to understand
that some words (like "gay", "negro") may change dramatically in meaning
over a few years is usually resisted by some people who "liked" the old
meaning (like "hacker"). So, too, is the case with the meaning of "Lisp"
that Scheme freaks want to enforce, but they are dishonest, sloppy people
with little or no experience in writing scientific papers (or this is a
sloppiness done on purpose, which may be worse), because they have _not_
provided the particular time-dependent reference of "Lisp" as they have
used it.

Also note that I did not ask when the line was "published". I asked when
it was _written_, specifically in order to request the time-dependent
context of the particular sentence, since the sloppy writers somehow
managed to omit that information in the otherwise anal-retentively
detail-driven accuracy in that document. There is often a remarkable
difference between the time of writing and the time of publication that I
hope you will understand some day so I do not have to be extremely
explicit about that difference, too.

Sometimes I wonder if you are intentionally obtuse or if you cannot help
it. I keep hoping that you can do better, which is probably why it is so
annoying that you do not. Let me know if I should stop hoping.

> The two languages and their attendant communities have drifted so far
> apart that there is nothing of value in their intersection.

| What about the use of S-expressions to represent both code and data?

How about using characters to represent source code?

Erann Gat

unread,
Mar 13, 2002, 1:36:49 PM3/13/02
to

Thanks to all who responded to "Why is Scheme not a Lisp."

My own view, FWIW, is that the essence of Lisp is the use of S-expressions
to represent both code and data. On that view, both Common Lisp and
Scheme are Lisps, and Python and Dylan are not. (I realize that this view
is at odds with McCarthy's original idea, but this would not be the first
time that the person who came up with a great idea didn't immediately
recognize it for what it was.)

This is a view shared by many of my colleagues who are not computer
scientists or software engineers. In their mind, Lisp == S expressions.
If a function call is written (f x y z) instead of f(x,y,z) then it's
Lisp. (This view has been the source of a great deal of frustration for
me, because S-expressions are useful in contexts other than programming
languages, but the prejudice against Lisp extends to the use of
S-expressions in non-programming contexts. But that's another story.)

So I have another question directed to those who say Scheme is not a Lisp:
is the concept of "programming language with S-expression-based syntax"
not important enough to deserve its own less verbose term? If it is, what
should that term be if not "Lisp"? And if it isn't, what is it about Lisp
that you think is more important?

Remember, if you think Scheme is a Lisp then there's no need to respond.
I'm not interested in starting a debate. I just want to understand the
Scheme != Lisp pont of view.

Thanks,
E.

Julian Stecklina

unread,
Mar 13, 2002, 2:37:19 PM3/13/02
to
Rahul Jain <rj...@sid-1129.sid.rice.edu> writes:

> g...@jpl.nasa.gov (Erann Gat) writes:
>
> > I'm just interested in hearing from those people who already believe
> > that it isn't what their rationale is.
>

> Here's my rationale: If Scheme were a lisp, it would call itself a
> Lisp. Does Java call itself a C? No, because it's not a C.


This is a strange argument. E.g. Delphi is a PASCAL. Judging the name
is not really constructive.

Regards,
Julian
--
Meine Hompage: http://julian.re6.de

Um meinen oeffentlichen Schluessel zu erhalten:
To get my public key:
http://math-www.uni-paderborn.de/pgp/

Kent M Pitman

unread,
Mar 13, 2002, 2:41:45 PM3/13/02
to
ds...@goldshoe.gte.com (Dorai Sitaram) writes:

> In article <a6noi8$gk6$1...@news.gte.com>, Dorai Sitaram <ds...@gte.com> wrote:
> >In article <sfw7koh...@shell01.TheWorld.com>,
> >Kent M Pitman <pit...@world.std.com> wrote:
> >>
> >>Are you wedded to the idea that the insight to be sought should be
> >>technical? Most human language divisions are not drawn on technical
> >>lines, or, if they are, it's only among researchers and not among the
> >>general public. Ultimately, aren't the real issues things like "who
> >>has the right to speak for it?" and "who has the right to change it?"
> >>and things like that? Whatever you think of who that might be, surely
> >>you don't think that's decided by some sort of technical criterion...?
> >>Why is the choice of a name, something that has no material technical
> >>implication on any program's execution, a technical matter?
> >
> >[my reply snipped]
>
> Kent, I replied in good faith because I thought your
> extensive set of questions specifically addressed
> to me were in expectation of an answer.
>
> I learned too late from another article of yours (to
> someone else) that you had publicly announced
> your withdrawal from the dicussion.

Well I hadn't stopped reading. I just feel like people must be getting
bored with me just repeating the same old stuff over and over. So I
thought I'd step back awhile and see what people have to say.

> I am not a big fan of these staged withdrawals --
> however it's your privilege.

I do it mostly so that people feel more easy about ragging on me to shut
up if I persist after I said I was going to stop.

> How about a little email heads-up next time you adopt this approach?

It wasn't on any point of principle I withdrew, and I don't mind continuing
the discussion if there is something legitimately new to be said.
I didn't mean to create a problem for you here. I _did_ read your reply
where you said:

| Sure, whatever flavor of insight is fine. It's just that
| "political reality"-type arguments wouldn't need explicit
| belaboring, as everyone would feel it in their bones already. The
| reason I specified "technical" was because it would be much easier
| both to offer and to accept. If you could just toss in some
| convincing insight amid the "politically plausible" analogizing, I
| would have no problem being an early convert to your view, well
| before it became political reality.

but it wasn't clear to me that it had a question in it. Is it really
the case that I have not made myself clear (to the pont of sounding like
a broken record.

I think this question doesn't have much relevance except at one point:
when a new dialect comes along. Because then those loyal to the Lisp name
ask whether they should go on. I recall a conversation with Pat Winston
about his Lisp book back when Common Lisp came along, where he was asking
me whether he should upgrade to Common Lisp, because it wasn't clear at that
time that CL was the "heir apparent" to the Lisp name, or whether Maclisp
would continue to be the right target. We were in "wait and see" mode.
My recommendation to him at that time was that it was something of a
self-fulfilling prophecy and that if he, Pat Winston, head of the AI Lab at
MIT, said "this is what Lisp is", then this is what Lisp would be. But if
he looked at Common Lisp and chose not to use it in his book, that in a sense
that would vote against Lisp. Of course, he is not the only guy people look
to. But certain people are leaders, and certain people are followers, and
the followers are just looking at the name and saying "I want to program in
Lisp. What does Lisp mean today?" And as new dialects present themselves,
they ask, "Is this The Way?" They did this when Dylan came along, and there
was a time when Dylan still had Lispy syntax and had the marketing backing
of Apple where I think there was some chance that Dylan could have fragmented
or diverted the community. But when the syntax was revamped and Apple lost
interest, Dylan in that moment became something other than a next generation
Lisp but still showed the will to become a "new experiment".

Put another way, I think that you understand what Lisp is by going back in time
and following the community and asking "where did it go next"?

It is like the ship of Theseus (I think it is), where a worn out plank is
replaced, and then another, and so on until none of the original ship remains.
The question becomes (and you can check Google to see this issue comes up
in numerous other contexts periodically): is it still the same ship?
(And is your answer changed if I tell you I've been saving the old planks
and have reassembled the original ship elsewhere?) My answer is that it
depends on your purpose. For insurance purposes, the "maintained ship" is
probably the ship that is insured; for historical purposes, I'm sure the
"original (now reassembled) ship" is the real one. And the Lisp community
is a bit like this. We lose ourselves piece by piece from one community to
the next, but the real question is, "where is our mass". We could totally
split, but often we don't. In the case of CL, the Maclisp coalesced from
previously disparate encampments. That was a pretty strong statement.
Moreover, the Interlisp community, which was detached, has in some cases
reattached to us. That, too, is a strong statement of sorts. It's all
subjective abstracts and subjective aggregations, so I don't know that there
are definitive answers, but that's how I arrive at my thinking on this.

That's my answer to you. But it looks to me just like the answers I've
already given. That's why, to the extent possible, I'm still going to try
to stay out of this. But if there's something that really seems to call
for me to reply, I will. Please try to phrase your question in the form
of a question, though. That will help me know I am really being specifically
addressed and you are awaiting an answer.

Doug Quale

unread,
Mar 13, 2002, 2:47:43 PM3/13/02
to
At the 1980 Lisp Conference at Stanford, John McCarthy published an
article, "LISP---NOTES ON ITS PAST AND FUTURE---1980". In 1999 he
wrote that it almost entirely corresponds to his present opinions
(http://www-formal.stanford.edu/jmc/lisp20th.html).

McCarthy gave 15 characteristics of the LISP programming language
which I reproduce below. Examining the list, R5RS Scheme has all of
the listed characteristics except number 9. (RnRS for n < 5 also do
not meet number 12 since EVAL was not a standard part of Scheme at
that time.)

Are there any programming languages other than Scheme that have 13 or
14 of these 15 characteristics but are not a Lisp? (A yes answer is
evidence that Scheme is not a Lisp, a no answer is evidence that
Scheme is a Lisp.)

Are there any Lisps that do not have all 15 of these characteristics?
(A yes answer weakens the argument that Scheme is not a Lisp, a no
answer strengthens it.)

(One could argue that Common Lisp itself does not support number 7
very well since CL does not guarantee tail recursion optimization.)

John McCarthy wrote in "LISP---NOTES ON ITS PAST AND FUTURE---1980":

> As a programming language, LISP is characterized by the following ideas:
>
> 1. Computing with symbolic expressions rather than numbers.
>
> 2. Representation of symbolic expressions and other information by
> list structure in computer memory.
>
> 3. Representation of information on paper, from keyboards and in other
> external media mostly by multi-level lists and sometimes by
> S-expressions. It has been important that any kind of data can be
> represented by a single general type.
>
> 4. A small set of selector and constructor operations expressed as
> functions, i.e. car, cdr and cons.
>
> 5. Composition of functions as a tool for forming more complex functions.
>
> 6. The use of conditional expressions for getting branching into
> function definitions.
>
> 7. The recursive use of conditional expressions as a sufficient tool
> for building computable functions.
>
> 8. The use of lambda-expressions for naming functions.
>
> 9. The storage of information on the property lists of atoms.
>
> 10. The representation of LISP programs as LISP data that can be
> manipulated by object programs. This has prevented the separation
> between system programmers and application programmers. Everyone
> can ``improve'' his LISP, and many of these ``improvements'' have
> developed into improvements to the language.
>
> 11. The conditional expression interpretation of Boolean connectives.
>
> 12. The LISP function eval that serves both as a formal definition of
> the language and as an interpreter.
>
> 13. Garbage collection as the means of erasure.
>
> 14. Minimal requirements for declarations so that LISP statements can
> be executed in an on-line environment without preliminaries.
>
> 15. LISP statements as a command language in an on-line environment.
>
> Of course, the above doesn't mention features that LISP has in common
> with most programming languages in its ``program feature''.

Doug Quale

unread,
Mar 13, 2002, 3:01:05 PM3/13/02
to
Kent M Pitman <pit...@world.std.com> writes:

> Moreover, the Interlisp community, which was detached, has in some cases
> reattached to us. That, too, is a strong statement of sorts. It's all
> subjective abstracts and subjective aggregations, so I don't know that there
> are definitive answers, but that's how I arrive at my thinking on this.

This confuses me. Is Interlisp a Lisp? Despite your emphasis on
community over other issues like history, syntax and semantics, the
Scheme and Common Lisp communities have had and continue to have a
greater overlap with each other than the Interlisp community had with
Common Lisp before Interlisp became extinct.

Does the fact that the Interlisp community has today reattached itself
to the Common Lisp community somehow retroactively make Interlisp a
Lisp?


--
Doug Quale

Christopher Browne

unread,
Mar 13, 2002, 3:14:38 PM3/13/02
to
In the last exciting episode, Erik Naggum <er...@naggum.net> wrote::

> * tb+u...@becket.net (Thomas Bushnell, BSG)
> | But Scheme does call itself a Lisp!
> |
> | The very beginning of the R5RS reads:
> |
> | "The report gives a defining description of the programming language
> | Scheme. Scheme is a statically scoped and properly tail-recursive dialect
> | of the Lisp programming language invented by Guy Lewis Steele Jr. and
> | Gerald Jay Sussman."

> But how can you trust a specification that says the Lisp programming
> language was invented by Guy Lewis Steele, Jr., and Gerald Jay
> Sussman?

<flame on>
It doesn't say that except when you do a misleading, out-of-context
reading of the text.

The reading that seems more natural is that it indicates that Scheme
is a dialect of Lisp, and that this dialect was invented by a
particular group of people.

The notion that this _could_ be a claim that GLS/GJS "invented Lisp"
flies in the face of blatant obviousness. All of these people spent
"quality time" at MIT, where it's completely obvious who the initial
inventor was, namely John McCarthy.

Indeed, for you to claim your reading requires that Kent Pitman be
accused of complicity in the dishonesty you suggest, as he has been on
the review committee since at least 1991, and probably much earlier.
<flame off>

Go ahead and attack Scheme on technical grounds, but dredging up this
kind of nonsense does nobody any favors.
--
(reverse (concatenate 'string "ac.notelrac.teneerf@" "454aa"))
http://www3.sympatico.ca/cbbrowne/sgml.html

Rahul Jain

unread,
Mar 13, 2002, 3:14:02 PM3/13/02
to
Doug Quale <qua...@charter.net> writes:

Seems like this list is misleading and/or inaccurate. Probably because
it was published in 1980 and we're applying it to 2000's context.

> John McCarthy wrote in "LISP---NOTES ON ITS PAST AND FUTURE---1980":
>
> > As a programming language, LISP is characterized by the following ideas:
> >
> > 1. Computing with symbolic expressions rather than numbers.

"Rather than"? CL has an excellent numeric type system and set of
operators, as does scheme (but they are subtly different in ways I
don't quite understand).

> > 2. Representation of symbolic expressions and other information by
> > list structure in computer memory.

Fair enough.

> > 3. Representation of information on paper, from keyboards and in other
> > external media mostly by multi-level lists and sometimes by
> > S-expressions. It has been important that any kind of data can be
> > represented by a single general type.

That was added to scheme later, I though.

> > 4. A small set of selector and constructor operations expressed as
> > functions, i.e. car, cdr and cons.

That's true of scheme, not of CL.

> > 5. Composition of functions as a tool for forming more complex functions.

That's true of any language with functions as first-class objects.

> > 6. The use of conditional expressions for getting branching into
> > function definitions.

Same as 5 and for most other languages.

> > 7. The recursive use of conditional expressions as a sufficient tool
> > for building computable functions.

Same as 6.

> > 8. The use of lambda-expressions for naming functions.

Well, that's just the ability to have anonymous functions. Same as 5.

> > 9. The storage of information on the property lists of atoms.

That's more of a style issue these days in CL, and of course, doesn't
happen in Scheme at all.

> > 10. The representation of LISP programs as LISP data that can be
> > manipulated by object programs. This has prevented the separation
> > between system programmers and application programmers. Everyone
> > can ``improve'' his LISP, and many of these ``improvements'' have
> > developed into improvements to the language.

Again, I think (read) was a recent addition to Scheme, but it has it
now, so no point clinging onto the past.

> > 11. The conditional expression interpretation of Boolean connectives.

This is common to nearly all languages in use today.

> > 12. The LISP function eval that serves both as a formal definition of
> > the language and as an interpreter.

New to scheme, ok.

> > 13. Garbage collection as the means of erasure.

Well, this is not required in CL, but let's call this "non-explicit
memory management". C++ has it, too, if you use libgc.

> > 14. Minimal requirements for declarations so that LISP statements can
> > be executed in an on-line environment without preliminaries.

Scheme doesn't even have declarations, but I guess this is referring
to defaulting to dynamic typing? Lots of languages have this.

> > 15. LISP statements as a command language in an on-line environment.

I don't know if Scheme requires a REPL. Lots of other languages have
them, too, however.

> > Of course, the above doesn't mention features that LISP has in common
> > with most programming languages in its ``program feature''.

Which is why I consider this list to be useless to this discussion.

7 of the 15 critera are basically useless to comparing Lisp and
Scheme, specifically, because they are common to large classes of
languages.

Personally, I think the thing that defines Lisp is the symbol. Note
that I consider packages to be essential to symbols, and the previous
symbol types were incomplete. Therefore, I consider pre-CL Lisps to be
proto-Lisps, and that's where Scheme came from. Not that it matters.

Scheme doesn't have the same symbolic manipulation capabilities as
Common Lisp, and since that's one of the most unique features of CL,
and one that explains how it can be so flexible, I don't consider
Scheme to be close enough to CL to consider them to be dialects of the
same language. In a sense, it wasn't Scheme that broke from Lisp, it
was CL that broke from it and made it a mature language.

Oh well, this is a pretty useless post.

--

Dorai Sitaram

unread,
Mar 13, 2002, 3:27:23 PM3/13/02
to
In article <sfwlmcw...@shell01.TheWorld.com>,

Kent M Pitman <pit...@world.std.com> wrote:
>
>but it wasn't clear to me that it had a question in it. Is it really
>the case that I have not made myself clear (to the pont of sounding like
>a broken record.
>
> [...]

>
>That's my answer to you. But it looks to me just like the answers I've
>already given. That's why, to the extent possible, I'm still going to try
>to stay out of this. But if there's something that really seems to call
>for me to reply, I will. Please try to phrase your question in the form
>of a question, though. That will help me know I am really being specifically
>addressed and you are awaiting an answer.

Oh no, I didn't ask a question -- I was answering yours
with some diligence. I just felt I could have avoided
that effort if the questions you posed were to be
considered de facto withdrawn.

It does not serve a person well to be induced to drone
on unilaterally when the other has magisterially left
the scene. :-)

Thanks.

--d

Christopher Browne

unread,
Mar 13, 2002, 3:30:36 PM3/13/02
to
The world rejoiced as Lieven Marchand <m...@wyrd.be> wrote:

> g...@jpl.nasa.gov (Erann Gat) writes:
>
> > 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?
>
> Scheme is not a Lisp IMO because of two types of reasons: first,
> technical, which have been argued on this group ad nauseam (the
> deepest difference there to me is that a scheme program is defined as
> a string of characters whereas a CL program is defined as a sequence
> of lists of Lisp objects. This may seem pedantic or trivial but a lot
> of different design decisions follow from this. It makes Scheme an
> infix member of the Algol language family.); but more important,
> philosophically. The Scheme community has evolved a set of values at
> odds with the spirit of Lisp: the goal for simplicity at the expense
> of convenience (compare the concept of CL's $item designators with the
> design of convert stuff explicitly like Scheme's exact->inexact), the
> goal of only giving basic blocks and letting you assemble stuff
> yourself (call/cc isn't a replacement for a worked out exception
> system).
>
> 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.

This also begs the question:

If these criteria for "Lispness" were applied to Emacs Lisp and ILisp,
what result falls out?

- I would think that an evaluation criteria that would indicate that
they _weren't_ Lisps would be severely flawed.

- I would expect Dylan to be considered "not Lisp;" while it bears
some resemblances, I don't think it's anywhere near enough. (It's
near enough that there may be some meaning discussions to have about
the similarities and differences; calling it Lisp would seem to be
going too far...)

- I would find it surprising for a set of evaluation criteria that
would exclude Scheme from being considered "a Lisp" to NOT similarly
exclude ELisp/ILisp.

I would be _fascinated_ to see a set of "Lispness criteria" that would
be inclusive of ELisp/ILisp and simultanously exclude Scheme.

My expectations are that such a set of criteria would more likely than
not be designed in a manner that was politically motivated with a
conscious view to exclude Scheme, which doesn't strike me as "fair
cricket."

It seems a shabby thing to make up a definition with the conscious
_political_ goal of excluding something.


--
(reverse (concatenate 'string "ac.notelrac.teneerf@" "454aa"))

http://www3.sympatico.ca/cbbrowne/lisp.html

Kent M Pitman

unread,
Mar 13, 2002, 3:32:16 PM3/13/02
to
Doug Quale <qua...@charter.net> writes:

> Kent M Pitman <pit...@world.std.com> writes:
>
> > Moreover, the Interlisp community, which was detached, has in some
> > cases reattached to us. That, too, is a strong statement of
> > sorts. It's all subjective abstracts and subjective aggregations,
> > so I don't know that there are definitive answers, but that's how
> > I arrive at my thinking on this.
>
> This confuses me. Is Interlisp a Lisp? Despite your emphasis on
> community over other issues like history, syntax and semantics, the
> Scheme and Common Lisp communities have had and continue to have a
> greater overlap with each other than the Interlisp community had with
> Common Lisp before Interlisp became extinct.

I certainly think Interlisp is a lisp. I think so because it descends
from the same cultural parentage as does Maclisp. That a split
occurred doesn't mean one or the other half has to lose its identity.
Emacs Lisp is a Lisp, too, and is split off. Zetalisp also split.
But none of these splits were made over ideology, as far as I can
tell, but rather were made over simple administrative need to
gradually control evolution in a way that suited a local user base.

I don't see that as what Sussman did. Sussman had a locally
administered Lisp but wasn't satisfied with it. He specifically took
control and designed something else because it didn't suit his way of
thinking. He had some concepts he wanted to teach, and he needed a
different vehicle for that teaching. That's a great thing to do, but
it's not torchbearing to me. It's being a revolutionary. And
revolutionaries build new things, they do not maintain a status quo.

Incidentally, I think Stallman thought CL was being revolutionary, not
evolutionary, because of its choice of lexical scope (and perhaps for
other reasons). I think he thought he was keeping Lisp on the straight
and narrow. If I were examining only the outcome, I might agree with him.
But because it was a "community consensus process" that led to CL, and
not just an individual striking out for change, I take CL's changes as
evolutionary even though some of them, at a technical level, might be
argued not to be.

> Does the fact that the Interlisp community has today reattached itself
> to the Common Lisp community somehow retroactively make Interlisp a
> Lisp?

No. At least, I don't think so. Interlisp was always a Lisp.

Christopher Browne

unread,
Mar 13, 2002, 3:42:36 PM3/13/02
to
Erik Naggum <er...@naggum.net> wrote:
> * Erann Gat
> | The introduction to R5RS says, "Scheme was the first major dialect of
> | Lisp to [have certain distinguishing features]". So it does call itself
> | a "dialect of Lisp."
>
> When was this written?

At least as far back as 1991, which is the earliest R*RS that I can
easily locate online.

I suspect that it may have been adopted from MIT AI Memo 452 or 848,
which were earlier definitions of Scheme. I can't verify that,
unfortunately.

R0RS is available at <http://www.sonic.net/~bear/scheme/R0RS.ps>; I
currently can't view PS, so others will have to verify whether the
intro changed significantly between R0RS and R3RS. I'd guess not.


--
(reverse (concatenate 'string "ac.notelrac.teneerf@" "454aa"))

http://www3.sympatico.ca/cbbrowne/sgml.html

Erik Naggum

unread,
Mar 13, 2002, 4:03:47 PM3/13/02
to
* Doug Quale <qua...@charter.net>

| The Lisp family is a family of languages, not a single language.

So _say_ "The language Scheme is a member of the Lisp language family"
instead of saying "Scheme is a dialect of Lisp". Emphasize language, not
dialect. Emphasize language family. A standards-like document that is
so lacking in precision does both its audience and its subject matter a
disservice.

| "Scheme is a Lisp", or more fully "Scheme is a member of the lisp
| language family" emphasizes the substantial common ground in those four
| important areas with other members of the lisp family.

It does not mean that because Common Lisp is most likely the only "Lisp"
they will see, and your interpretation of "is a lisp" as "member of the
Lisp language family" assumes facts not in evidence, namely that "Lisp"
is a language family, as seen by those who read it. Scheme is not a
"dialect" of Common Lisp, and there are no other large _families_ of
programming languages around that people talk about. Pascal is not a
member of the Algol family, although Delphi might be a dialect of Pascal,
but there is no Pascal family of languages, of which Ada is a member. So
the notion of a language family cannot be assumed to exist in the readers
and certainly not in students who go into the world and would like to
study Common Lisp.

Had you schmucks actually been able to achieve clarity of expression and
thought and communicate your intent, which you have rewritten "Scheme is
a Lisp" to mean, just _imagine_ how much less hostility would have
ensued. I repeat my suggestion: say "the language Scheme is a member of
the Lisp language family" if that is what you mean, do not weasel out of
your responsibility for the weak expression.

| An interesting comparison can be made with the Algol family of languages.
| This family includes Algol 60 as the founding member and has many members
| including Algol-W, PL/1, Pascal, C and Ada. The Algol family includes
| members that are far more different that Common Lisp and Scheme. No one
| would ever confuse Algol 60 and Ada, but they are members of the Algol
| family all the same.

But who talks about the Algol family? None. Would a C programmer be
anywhere close to comfortable with this classification? No.

| Kent has argued rationally that Scheme is not a Lisp, but most people
| arguing in favor of that view have not been so dispassionate. The
| interesting thing is that for some Common Lisp users, the question of
| whether Scheme is a Lisp is a religious one rather than a technical one.

It is a feeble-minded, stupid, inflammatory way to say "Scheme is a
member of the Lisp family" if that is what you read it to mean "more
fully".

| I can't even imagine that level of emotion in a discussion between Pascal
| and C partisans about the common cultural and historical origins of their
| languages, although they can disagree very heatedly about the relative
| merits of their chosen languages.

But nobody says "C is an Algol".

| (By way of contrast, I think from a Scheme or Common Lisp point of view,
| many might say the differences between Pascal and C aren't very
| important.)

Then try answering a C question with a Pascal answer in comp.lang.c.
Suggest that somebody who wants to learn C "begin with Pascal", or offer
people who do not like feature X of C or just have a problem using it, to
use Pascal, instead. This is what the annoying Scheme freaks do in
comp.lang.lisp. Also, people do not discuss Ada in comp.lang.algol.

| Despite what some Scheme haters in c.l.l say, I think very few Scheme
| users have any strong intellectual or emotional investment in this
| question.

Every single person who has ever answered a Common Lisp question with a
Scheme answer has at least at that time had serious emotional investment
in a competition between Scheme and Common Lisp.

| I think the initial inquiry was prompted more by a desire to understand
| the venom displayed towards Scheme in c.l.l than a need to prove
| anything.

There is no venom towards Scheme per se. There is venom towards all the
obnoxious, persistent Scheme crap in comp.lang.lisp. If you spend your
time on a date talking about computers, chances are you will bore your
date to death and not score. Computer science did not get dissed, but
your choice of topic to talk about in that setting did. So, too, with
all the irrelevant Scheme crap in comp.lang.lisp.

| "Why do they hate us?" has gained a lot of attention recently in areas
| much more important than computer programming languages.

Reasonbly intelligent people manage to figure out the difference between
"why do they hate what we do" and "why do they hate us". If Scheme
freaks could please figure out that when somebody has a problem in Common
Lisp, answering with a Scheme solution is bad form, and simply refrain
from being such obnoxious retards, there would be no "hatred" at all.
People who are told to shut up and go away, but do neither are not hated
for their _person_, they are hated for their obnoxious behavior.

When you accuse people of hating you because of your behavior, you have
actually attacked him in an inexcusable way. Some people never figure
out that false accusation trip people and can seriously piss them off,
but feel free to accuse others of things they do not like simply because
_they_ do not like the person. I consider such behavior to be clear
evidence of a very serious coping problem.

| As a final thought, it's quite funny that someone can say that Common
| Lisp is a lisp-2 and Scheme is a lisp-1, and then in the next breath say
| Scheme is not a Lisp.

Context, dude.

Erann Gat

unread,
Mar 13, 2002, 3:51:32 PM3/13/02