Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss

Why is Scheme not a Lisp?

3,808 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?