Why is Scheme not a Lisp?
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.)
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
> 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
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
> 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
> 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
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
> 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
> 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
>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
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
> 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
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
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
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
> 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
| 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
> ... 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
| 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
> 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
"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
<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
> 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
| 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
> 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
> * 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
> 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
"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
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
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
> 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
> 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
> 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
> 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
> 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