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
Thaddeus L Olczyk
<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
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
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
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
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
> 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.)
>
> 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
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
> 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
> 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
| But Scheme does call itself a Lisp!
|
| The very beginning of the R5RS reads:
|
| "The report gives a defining description of the programming language
| Scheme. Scheme is a statically scoped and properly tail-recursive dialect
| of the Lisp programming language invented by Guy Lewis Steele Jr. and
| Gerald Jay Sussman."
But how can you trust a specification that says the Lisp programming
language was invented by Guy Lewis Steele, Jr., and Gerald Jay Sussman?
Nils Goesche
> * tb+u...@becket.net (Thomas Bushnell, BSG)
>| But Scheme does call itself a Lisp!
>|
>| The very beginning of the R5RS reads:
>|
>| "The report gives a defining description of the programming language
>| Scheme. Scheme is a statically scoped and properly tail-recursive dialect
>| of the Lisp programming language invented by Guy Lewis Steele Jr. and
>| Gerald Jay Sussman."
>
> But how can you trust a specification that says the Lisp programming
> language was invented by Guy Lewis Steele, Jr., and Gerald Jay Sussman?
Hehehe - one should submit a bug report asking them to put claims
like that in denotational semantics in the future :-)
Regards,
--
Nils Goesche PGP key ID 0x42B32FC9
"The sooner all the animals are dead, the sooner we'll find
their money." -- Ed Bluestone
Dorai Sitaram
>In article <sfw7koh...@shell01.TheWorld.com>,
>Kent M Pitman <pit...@world.std.com> wrote:
>>
>>Are you wedded to the idea that the insight to be sought should be
>>technical? Most human language divisions are not drawn on technical
>>lines, or, if they are, it's only among researchers and not among the
>>general public. Ultimately, aren't the real issues things like "who
>>has the right to speak for it?" and "who has the right to change it?"
>>and things like that? Whatever you think of who that might be, surely
>>you don't think that's decided by some sort of technical criterion...?
>>Why is the choice of a name, something that has no material technical
>>implication on any program's execution, a technical matter?
>
Kent, I replied in good faith because I thought your
extensive set of questions specifically addressed
to me were in expectation of an answer.
I learned too late from another article of yours (to
someone else) that you had publicly announced
your withdrawal from the dicussion.
I am not a big fan of these staged withdrawals --
however it's your privilege. How about a little
email heads-up next time you adopt this approach?
Cheers,
--d
Erik Naggum
| The introduction to R5RS says, "Scheme was the first major dialect of
| Lisp to [have certain distinguishing features]". So it does call itself
| a "dialect of Lisp."
* Erik Naggum
> When was this written?
* Erann Gat
| R5RS is dated 20 February 1998. It's the most recent Scheme standard.
OK, I see I have to be extremely explicit here. That bores the hell out
of me, so I am not going to repeat the effort.
When people write something, they do so in a particular context, even
though they are not necessarily consciously aware of this context. In
particular, the meaning of a word is contextual and the external
references refer to other things as they both exist and are understood by
the particular person at that particular time. In particular, a sentence
like the above might have been true once, but the common referent for
"Lisp" may change, so it has to be understood in its historical context.
The Bible works that way, and people have to assume (or "temporarily
adopt", since you have demonstrated problems understanding this word,
too) a special context to understand it properly. The same is true of
most non-fiction, actually, and the more specialized some area is, the
more context becomes explicit. In fact, the bibliographic references of
a scientific paper works to establish the context in which the paper is
written as well as its soundness. In particular, a scientific paper
makes its position in time very explicit through its bibliographic
references, and thus establish the time-dependent meaning of any term,
the time-dependent status of any theory, and the time-dependent referents
of a concept. The ability to understand that something changes in time,
that it is indeed a "fourth dimension" that we travel through, seems to
take some time for many people to develop, and the ability to understand
that some words (like "gay", "negro") may change dramatically in meaning
over a few years is usually resisted by some people who "liked" the old
meaning (like "hacker"). So, too, is the case with the meaning of "Lisp"
that Scheme freaks want to enforce, but they are dishonest, sloppy people
with little or no experience in writing scientific papers (or this is a
sloppiness done on purpose, which may be worse), because they have _not_
provided the particular time-dependent reference of "Lisp" as they have
used it.
Also note that I did not ask when the line was "published". I asked when
it was _written_, specifically in order to request the time-dependent
context of the particular sentence, since the sloppy writers somehow
managed to omit that information in the otherwise anal-retentively
detail-driven accuracy in that document. There is often a remarkable
difference between the time of writing and the time of publication that I
hope you will understand some day so I do not have to be extremely
explicit about that difference, too.
Sometimes I wonder if you are intentionally obtuse or if you cannot help
it. I keep hoping that you can do better, which is probably why it is so
annoying that you do not. Let me know if I should stop hoping.
> The two languages and their attendant communities have drifted so far
> apart that there is nothing of value in their intersection.
| What about the use of S-expressions to represent both code and data?
How about using characters to represent source code?
Erann Gat
Thanks to all who responded to "Why is Scheme not a Lisp."
My own view, FWIW, is that the essence of Lisp is the use of S-expressions
to represent both code and data. On that view, both Common Lisp and
Scheme are Lisps, and Python and Dylan are not. (I realize that this view
is at odds with McCarthy's original idea, but this would not be the first
time that the person who came up with a great idea didn't immediately
recognize it for what it was.)
This is a view shared by many of my colleagues who are not computer
scientists or software engineers. In their mind, Lisp == S expressions.
If a function call is written (f x y z) instead of f(x,y,z) then it's
Lisp. (This view has been the source of a great deal of frustration for
me, because S-expressions are useful in contexts other than programming
languages, but the prejudice against Lisp extends to the use of
S-expressions in non-programming contexts. But that's another story.)
So I have another question directed to those who say Scheme is not a Lisp:
is the concept of "programming language with S-expression-based syntax"
not important enough to deserve its own less verbose term? If it is, what
should that term be if not "Lisp"? And if it isn't, what is it about Lisp
that you think is more important?
Remember, if you think Scheme is a Lisp then there's no need to respond.
I'm not interested in starting a debate. I just want to understand the
Scheme != Lisp pont of view.
Thanks,
E.
Julian Stecklina
> g...@jpl.nasa.gov (Erann Gat) writes:
>
> > I'm just interested in hearing from those people who already believe
> > that it isn't what their rationale is.
>
> Here's my rationale: If Scheme were a lisp, it would call itself a
> Lisp. Does Java call itself a C? No, because it's not a C.
This is a strange argument. E.g. Delphi is a PASCAL. Judging the name
is not really constructive.
Regards,
Julian
--
Meine Hompage: http://julian.re6.de
Um meinen oeffentlichen Schluessel zu erhalten:
To get my public key:
http://math-www.uni-paderborn.de/pgp/
Kent M Pitman
> In article <a6noi8$gk6$1...@news.gte.com>, Dorai Sitaram <ds...@gte.com> wrote:
> >In article <sfw7koh...@shell01.TheWorld.com>,
> >Kent M Pitman <pit...@world.std.com> wrote:
> >>
> >>Are you wedded to the idea that the insight to be sought should be
> >>technical? Most human language divisions are not drawn on technical
> >>lines, or, if they are, it's only among researchers and not among the
> >>general public. Ultimately, aren't the real issues things like "who
> >>has the right to speak for it?" and "who has the right to change it?"
> >>and things like that? Whatever you think of who that might be, surely
> >>you don't think that's decided by some sort of technical criterion...?
> >>Why is the choice of a name, something that has no material technical
> >>implication on any program's execution, a technical matter?
> >
> >[my reply snipped]
>
> Kent, I replied in good faith because I thought your
> extensive set of questions specifically addressed
> to me were in expectation of an answer.
>
> I learned too late from another article of yours (to
> someone else) that you had publicly announced
> your withdrawal from the dicussion.
Well I hadn't stopped reading. I just feel like people must be getting
bored with me just repeating the same old stuff over and over. So I
thought I'd step back awhile and see what people have to say.
> I am not a big fan of these staged withdrawals --
> however it's your privilege.
I do it mostly so that people feel more easy about ragging on me to shut
up if I persist after I said I was going to stop.
> How about a little email heads-up next time you adopt this approach?
It wasn't on any point of principle I withdrew, and I don't mind continuing
the discussion if there is something legitimately new to be said.
I didn't mean to create a problem for you here. I _did_ read your reply
where you said:
| Sure, whatever flavor of insight is fine. It's just that
| "political reality"-type arguments wouldn't need explicit
| belaboring, as everyone would feel it in their bones already. The
| reason I specified "technical" was because it would be much easier
| both to offer and to accept. If you could just toss in some
| convincing insight amid the "politically plausible" analogizing, I
| would have no problem being an early convert to your view, well
| before it became political reality.
but it wasn't clear to me that it had a question in it. Is it really
the case that I have not made myself clear (to the pont of sounding like
a broken record.
I think this question doesn't have much relevance except at one point:
when a new dialect comes along. Because then those loyal to the Lisp name
ask whether they should go on. I recall a conversation with Pat Winston
about his Lisp book back when Common Lisp came along, where he was asking
me whether he should upgrade to Common Lisp, because it wasn't clear at that
time that CL was the "heir apparent" to the Lisp name, or whether Maclisp
would continue to be the right target. We were in "wait and see" mode.
My recommendation to him at that time was that it was something of a
self-fulfilling prophecy and that if he, Pat Winston, head of the AI Lab at
MIT, said "this is what Lisp is", then this is what Lisp would be. But if
he looked at Common Lisp and chose not to use it in his book, that in a sense
that would vote against Lisp. Of course, he is not the only guy people look
to. But certain people are leaders, and certain people are followers, and
the followers are just looking at the name and saying "I want to program in
Lisp. What does Lisp mean today?" And as new dialects present themselves,
they ask, "Is this The Way?" They did this when Dylan came along, and there
was a time when Dylan still had Lispy syntax and had the marketing backing
of Apple where I think there was some chance that Dylan could have fragmented
or diverted the community. But when the syntax was revamped and Apple lost
interest, Dylan in that moment became something other than a next generation
Lisp but still showed the will to become a "new experiment".
Put another way, I think that you understand what Lisp is by going back in time
and following the community and asking "where did it go next"?
It is like the ship of Theseus (I think it is), where a worn out plank is
replaced, and then another, and so on until none of the original ship remains.
The question becomes (and you can check Google to see this issue comes up
in numerous other contexts periodically): is it still the same ship?
(And is your answer changed if I tell you I've been saving the old planks
and have reassembled the original ship elsewhere?) My answer is that it
depends on your purpose. For insurance purposes, the "maintained ship" is
probably the ship that is insured; for historical purposes, I'm sure the
"original (now reassembled) ship" is the real one. And the Lisp community
is a bit like this. We lose ourselves piece by piece from one community to
the next, but the real question is, "where is our mass". We could totally
split, but often we don't. In the case of CL, the Maclisp coalesced from
previously disparate encampments. That was a pretty strong statement.
Moreover, the Interlisp community, which was detached, has in some cases
reattached to us. That, too, is a strong statement of sorts. It's all
subjective abstracts and subjective aggregations, so I don't know that there
are definitive answers, but that's how I arrive at my thinking on this.
That's my answer to you. But it looks to me just like the answers I've
already given. That's why, to the extent possible, I'm still going to try
to stay out of this. But if there's something that really seems to call
for me to reply, I will. Please try to phrase your question in the form
of a question, though. That will help me know I am really being specifically
addressed and you are awaiting an answer.
Doug Quale
article, "LISP---NOTES ON ITS PAST AND FUTURE---1980". In 1999 he
wrote that it almost entirely corresponds to his present opinions
(http://www-formal.stanford.edu/jmc/lisp20th.html).
McCarthy gave 15 characteristics of the LISP programming language
which I reproduce below. Examining the list, R5RS Scheme has all of
the listed characteristics except number 9. (RnRS for n < 5 also do
not meet number 12 since EVAL was not a standard part of Scheme at
that time.)
Are there any programming languages other than Scheme that have 13 or
14 of these 15 characteristics but are not a Lisp? (A yes answer is
evidence that Scheme is not a Lisp, a no answer is evidence that
Scheme is a Lisp.)
Are there any Lisps that do not have all 15 of these characteristics?
(A yes answer weakens the argument that Scheme is not a Lisp, a no
answer strengthens it.)
(One could argue that Common Lisp itself does not support number 7
very well since CL does not guarantee tail recursion optimization.)
John McCarthy wrote in "LISP---NOTES ON ITS PAST AND FUTURE---1980":
> As a programming language, LISP is characterized by the following ideas:
>
> 1. Computing with symbolic expressions rather than numbers.
>
> 2. Representation of symbolic expressions and other information by
> list structure in computer memory.
>
> 3. Representation of information on paper, from keyboards and in other
> external media mostly by multi-level lists and sometimes by
> S-expressions. It has been important that any kind of data can be
> represented by a single general type.
>
> 4. A small set of selector and constructor operations expressed as
> functions, i.e. car, cdr and cons.
>
> 5. Composition of functions as a tool for forming more complex functions.
>
> 6. The use of conditional expressions for getting branching into
> function definitions.
>
> 7. The recursive use of conditional expressions as a sufficient tool
> for building computable functions.
>
> 8. The use of lambda-expressions for naming functions.
>
> 9. The storage of information on the property lists of atoms.
>
> 10. The representation of LISP programs as LISP data that can be
> manipulated by object programs. This has prevented the separation
> between system programmers and application programmers. Everyone
> can ``improve'' his LISP, and many of these ``improvements'' have
> developed into improvements to the language.
>
> 11. The conditional expression interpretation of Boolean connectives.
>
> 12. The LISP function eval that serves both as a formal definition of
> the language and as an interpreter.
>
> 13. Garbage collection as the means of erasure.
>
> 14. Minimal requirements for declarations so that LISP statements can
> be executed in an on-line environment without preliminaries.
>
> 15. LISP statements as a command language in an on-line environment.
>
> Of course, the above doesn't mention features that LISP has in common
> with most programming languages in its ``program feature''.
Doug Quale
> Moreover, the Interlisp community, which was detached, has in some cases
> reattached to us. That, too, is a strong statement of sorts. It's all
> subjective abstracts and subjective aggregations, so I don't know that there
> are definitive answers, but that's how I arrive at my thinking on this.
This confuses me. Is Interlisp a Lisp? Despite your emphasis on
community over other issues like history, syntax and semantics, the
Scheme and Common Lisp communities have had and continue to have a
greater overlap with each other than the Interlisp community had with
Common Lisp before Interlisp became extinct.
Does the fact that the Interlisp community has today reattached itself
to the Common Lisp community somehow retroactively make Interlisp a
Lisp?
--
Doug Quale
Christopher Browne
> * tb+u...@becket.net (Thomas Bushnell, BSG)
> | But Scheme does call itself a Lisp!
> |
> | The very beginning of the R5RS reads:
> |
> | "The report gives a defining description of the programming language
> | Scheme. Scheme is a statically scoped and properly tail-recursive dialect
> | of the Lisp programming language invented by Guy Lewis Steele Jr. and
> | Gerald Jay Sussman."
> But how can you trust a specification that says the Lisp programming
> language was invented by Guy Lewis Steele, Jr., and Gerald Jay
> Sussman?
<flame on>
It doesn't say that except when you do a misleading, out-of-context
reading of the text.
The reading that seems more natural is that it indicates that Scheme
is a dialect of Lisp, and that this dialect was invented by a
particular group of people.
The notion that this _could_ be a claim that GLS/GJS "invented Lisp"
flies in the face of blatant obviousness. All of these people spent
"quality time" at MIT, where it's completely obvious who the initial
inventor was, namely John McCarthy.
Indeed, for you to claim your reading requires that Kent Pitman be
accused of complicity in the dishonesty you suggest, as he has been on
the review committee since at least 1991, and probably much earlier.
<flame off>
Go ahead and attack Scheme on technical grounds, but dredging up this
kind of nonsense does nobody any favors.
--
(reverse (concatenate 'string "ac.notelrac.teneerf@" "454aa"))
http://www3.sympatico.ca/cbbrowne/sgml.html
Rahul Jain
Seems like this list is misleading and/or inaccurate. Probably because
it was published in 1980 and we're applying it to 2000's context.
> John McCarthy wrote in "LISP---NOTES ON ITS PAST AND FUTURE---1980":
>
> > As a programming language, LISP is characterized by the following ideas:
> >
> > 1. Computing with symbolic expressions rather than numbers.
"Rather than"? CL has an excellent numeric type system and set of
operators, as does scheme (but they are subtly different in ways I
don't quite understand).
> > 2. Representation of symbolic expressions and other information by
> > list structure in computer memory.
Fair enough.
> > 3. Representation of information on paper, from keyboards and in other
> > external media mostly by multi-level lists and sometimes by
> > S-expressions. It has been important that any kind of data can be
> > represented by a single general type.
That was added to scheme later, I though.
> > 4. A small set of selector and constructor operations expressed as
> > functions, i.e. car, cdr and cons.
That's true of scheme, not of CL.
> > 5. Composition of functions as a tool for forming more complex functions.
That's true of any language with functions as first-class objects.
> > 6. The use of conditional expressions for getting branching into
> > function definitions.
Same as 5 and for most other languages.
> > 7. The recursive use of conditional expressions as a sufficient tool
> > for building computable functions.
Same as 6.
> > 8. The use of lambda-expressions for naming functions.
Well, that's just the ability to have anonymous functions. Same as 5.
> > 9. The storage of information on the property lists of atoms.
That's more of a style issue these days in CL, and of course, doesn't
happen in Scheme at all.
> > 10. The representation of LISP programs as LISP data that can be
> > manipulated by object programs. This has prevented the separation
> > between system programmers and application programmers. Everyone
> > can ``improve'' his LISP, and many of these ``improvements'' have
> > developed into improvements to the language.
Again, I think (read) was a recent addition to Scheme, but it has it
now, so no point clinging onto the past.
> > 11. The conditional expression interpretation of Boolean connectives.
This is common to nearly all languages in use today.
> > 12. The LISP function eval that serves both as a formal definition of
> > the language and as an interpreter.
New to scheme, ok.
> > 13. Garbage collection as the means of erasure.
Well, this is not required in CL, but let's call this "non-explicit
memory management". C++ has it, too, if you use libgc.
> > 14. Minimal requirements for declarations so that LISP statements can
> > be executed in an on-line environment without preliminaries.
Scheme doesn't even have declarations, but I guess this is referring
to defaulting to dynamic typing? Lots of languages have this.
> > 15. LISP statements as a command language in an on-line environment.
I don't know if Scheme requires a REPL. Lots of other languages have
them, too, however.
> > Of course, the above doesn't mention features that LISP has in common
> > with most programming languages in its ``program feature''.
Which is why I consider this list to be useless to this discussion.
7 of the 15 critera are basically useless to comparing Lisp and
Scheme, specifically, because they are common to large classes of
languages.
Personally, I think the thing that defines Lisp is the symbol. Note
that I consider packages to be essential to symbols, and the previous
symbol types were incomplete. Therefore, I consider pre-CL Lisps to be
proto-Lisps, and that's where Scheme came from. Not that it matters.
Scheme doesn't have the same symbolic manipulation capabilities as
Common Lisp, and since that's one of the most unique features of CL,
and one that explains how it can be so flexible, I don't consider
Scheme to be close enough to CL to consider them to be dialects of the
same language. In a sense, it wasn't Scheme that broke from Lisp, it
was CL that broke from it and made it a mature language.
Oh well, this is a pretty useless post.
--
Dorai Sitaram
Kent M Pitman <pit...@world.std.com> wrote:
>
>but it wasn't clear to me that it had a question in it. Is it really
>the case that I have not made myself clear (to the pont of sounding like
>a broken record.
>
>
>That's my answer to you. But it looks to me just like the answers I've
>already given. That's why, to the extent possible, I'm still going to try
>to stay out of this. But if there's something that really seems to call
>for me to reply, I will. Please try to phrase your question in the form
>of a question, though. That will help me know I am really being specifically
>addressed and you are awaiting an answer.
Oh no, I didn't ask a question -- I was answering yours
with some diligence. I just felt I could have avoided
that effort if the questions you posed were to be
considered de facto withdrawn.
It does not serve a person well to be induced to drone
on unilaterally when the other has magisterially left
the scene. :-)
Thanks.
--d
Christopher Browne
> 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?
>
> technical, which have been argued on this group ad nauseam (the
> deepest difference there to me is that a scheme program is defined as
> a string of characters whereas a CL program is defined as a sequence
> of lists of Lisp objects. This may seem pedantic or trivial but a lot
> of different design decisions follow from this. It makes Scheme an
> infix member of the Algol language family.); but more important,
> philosophically. The Scheme community has evolved a set of values at
> odds with the spirit of Lisp: the goal for simplicity at the expense
> of convenience (compare the concept of CL's $item designators with the
> design of convert stuff explicitly like Scheme's exact->inexact), the
> goal of only giving basic blocks and letting you assemble stuff
> yourself (call/cc isn't a replacement for a worked out exception
> system).
>
> To sum it up with a Ritchie quote: "Some languages were meant to get
> work done, some were meant to prove a point." I put Lisp in the first
> category and Scheme and ML in the second. (See also the reliance on
> tail call elimination to be able to prove the point that a looping
> construct isn't necessary.)
>
> I don't know enough about Lisp 1.5 to answer your last question.
This also begs the question:
If these criteria for "Lispness" were applied to Emacs Lisp and ILisp,
what result falls out?
- I would think that an evaluation criteria that would indicate that
they _weren't_ Lisps would be severely flawed.
- I would expect Dylan to be considered "not Lisp;" while it bears
some resemblances, I don't think it's anywhere near enough. (It's
near enough that there may be some meaning discussions to have about
the similarities and differences; calling it Lisp would seem to be
going too far...)
- I would find it surprising for a set of evaluation criteria that
would exclude Scheme from being considered "a Lisp" to NOT similarly
exclude ELisp/ILisp.
I would be _fascinated_ to see a set of "Lispness criteria" that would
be inclusive of ELisp/ILisp and simultanously exclude Scheme.
My expectations are that such a set of criteria would more likely than
not be designed in a manner that was politically motivated with a
conscious view to exclude Scheme, which doesn't strike me as "fair
cricket."
It seems a shabby thing to make up a definition with the conscious
_political_ goal of excluding something.
--
(reverse (concatenate 'string "ac.notelrac.teneerf@" "454aa"))
Kent M Pitman
> Kent M Pitman <pit...@world.std.com> writes:
>
> > Moreover, the Interlisp community, which was detached, has in some
> > cases reattached to us. That, too, is a strong statement of
> > sorts. It's all subjective abstracts and subjective aggregations,
> > so I don't know that there are definitive answers, but that's how
> > I arrive at my thinking on this.
>
> This confuses me. Is Interlisp a Lisp? Despite your emphasis on
> community over other issues like history, syntax and semantics, the
> Scheme and Common Lisp communities have had and continue to have a
> greater overlap with each other than the Interlisp community had with
> Common Lisp before Interlisp became extinct.
I certainly think Interlisp is a lisp. I think so because it descends
from the same cultural parentage as does Maclisp. That a split
occurred doesn't mean one or the other half has to lose its identity.
Emacs Lisp is a Lisp, too, and is split off. Zetalisp also split.
But none of these splits were made over ideology, as far as I can
tell, but rather were made over simple administrative need to
gradually control evolution in a way that suited a local user base.
I don't see that as what Sussman did. Sussman had a locally
administered Lisp but wasn't satisfied with it. He specifically took
control and designed something else because it didn't suit his way of
thinking. He had some concepts he wanted to teach, and he needed a
different vehicle for that teaching. That's a great thing to do, but
it's not torchbearing to me. It's being a revolutionary. And
revolutionaries build new things, they do not maintain a status quo.
Incidentally, I think Stallman thought CL was being revolutionary, not
evolutionary, because of its choice of lexical scope (and perhaps for
other reasons). I think he thought he was keeping Lisp on the straight
and narrow. If I were examining only the outcome, I might agree with him.
But because it was a "community consensus process" that led to CL, and
not just an individual striking out for change, I take CL's changes as
evolutionary even though some of them, at a technical level, might be
argued not to be.
> Does the fact that the Interlisp community has today reattached itself
> to the Common Lisp community somehow retroactively make Interlisp a
> Lisp?
No. At least, I don't think so. Interlisp was always a Lisp.
Christopher Browne
> * 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."
>
At least as far back as 1991, which is the earliest R*RS that I can
easily locate online.
I suspect that it may have been adopted from MIT AI Memo 452 or 848,
which were earlier definitions of Scheme. I can't verify that,
unfortunately.
R0RS is available at <http://www.sonic.net/~bear/scheme/R0RS.ps>; I
currently can't view PS, so others will have to verify whether the
intro changed significantly between R0RS and R3RS. I'd guess not.
--
(reverse (concatenate 'string "ac.notelrac.teneerf@" "454aa"))
Erik Naggum
| The Lisp family is a family of languages, not a single language.
So _say_ "The language Scheme is a member of the Lisp language family"
instead of saying "Scheme is a dialect of Lisp". Emphasize language, not
dialect. Emphasize language family. A standards-like document that is
so lacking in precision does both its audience and its subject matter a
disservice.
| "Scheme is a Lisp", or more fully "Scheme is a member of the lisp
| language family" emphasizes the substantial common ground in those four
| important areas with other members of the lisp family.
It does not mean that because Common Lisp is most likely the only "Lisp"
they will see, and your interpretation of "is a lisp" as "member of the
Lisp language family" assumes facts not in evidence, namely that "Lisp"
is a language family, as seen by those who read it. Scheme is not a
"dialect" of Common Lisp, and there are no other large _families_ of
programming languages around that people talk about. Pascal is not a
member of the Algol family, although Delphi might be a dialect of Pascal,
but there is no Pascal family of languages, of which Ada is a member. So
the notion of a language family cannot be assumed to exist in the readers
and certainly not in students who go into the world and would like to
study Common Lisp.
Had you schmucks actually been able to achieve clarity of expression and
thought and communicate your intent, which you have rewritten "Scheme is
a Lisp" to mean, just _imagine_ how much less hostility would have
ensued. I repeat my suggestion: say "the language Scheme is a member of
the Lisp language family" if that is what you mean, do not weasel out of
your responsibility for the weak expression.
| An interesting comparison can be made with the Algol family of languages.
| This family includes Algol 60 as the founding member and has many members
| including Algol-W, PL/1, Pascal, C and Ada. The Algol family includes
| members that are far more different that Common Lisp and Scheme. No one
| would ever confuse Algol 60 and Ada, but they are members of the Algol
| family all the same.
But who talks about the Algol family? None. Would a C programmer be
anywhere close to comfortable with this classification? No.
| Kent has argued rationally that Scheme is not a Lisp, but most people
| arguing in favor of that view have not been so dispassionate. The
| interesting thing is that for some Common Lisp users, the question of
| whether Scheme is a Lisp is a religious one rather than a technical one.
It is a feeble-minded, stupid, inflammatory way to say "Scheme is a
member of the Lisp family" if that is what you read it to mean "more
fully".
| I can't even imagine that level of emotion in a discussion between Pascal
| and C partisans about the common cultural and historical origins of their
| languages, although they can disagree very heatedly about the relative
| merits of their chosen languages.
But nobody says "C is an Algol".
| (By way of contrast, I think from a Scheme or Common Lisp point of view,
| many might say the differences between Pascal and C aren't very
| important.)
Then try answering a C question with a Pascal answer in comp.lang.c.
Suggest that somebody who wants to learn C "begin with Pascal", or offer
people who do not like feature X of C or just have a problem using it, to
use Pascal, instead. This is what the annoying Scheme freaks do in
comp.lang.lisp. Also, people do not discuss Ada in comp.lang.algol.
| Despite what some Scheme haters in c.l.l say, I think very few Scheme
| users have any strong intellectual or emotional investment in this
| question.
Every single person who has ever answered a Common Lisp question with a
Scheme answer has at least at that time had serious emotional investment
in a competition between Scheme and Common Lisp.
| I think the initial inquiry was prompted more by a desire to understand
| the venom displayed towards Scheme in c.l.l than a need to prove
| anything.
There is no venom towards Scheme per se. There is venom towards all the
obnoxious, persistent Scheme crap in comp.lang.lisp. If you spend your
time on a date talking about computers, chances are you will bore your
date to death and not score. Computer science did not get dissed, but
your choice of topic to talk about in that setting did. So, too, with
all the irrelevant Scheme crap in comp.lang.lisp.
| "Why do they hate us?" has gained a lot of attention recently in areas
| much more important than computer programming languages.
Reasonbly intelligent people manage to figure out the difference between
"why do they hate what we do" and "why do they hate us". If Scheme
freaks could please figure out that when somebody has a problem in Common
Lisp, answering with a Scheme solution is bad form, and simply refrain
from being such obnoxious retards, there would be no "hatred" at all.
People who are told to shut up and go away, but do neither are not hated
for their _person_, they are hated for their obnoxious behavior.
When you accuse people of hating you because of your behavior, you have
actually attacked him in an inexcusable way. Some people never figure
out that false accusation trip people and can seriously piss them off,
but feel free to accuse others of things they do not like simply because
_they_ do not like the person. I consider such behavior to be clear
evidence of a very serious coping problem.
| As a final thought, it's quite funny that someone can say that Common
| Lisp is a lisp-2 and Scheme is a lisp-1, and then in the next breath say
| Scheme is not a Lisp.
Context, dude.
Erann Gat
> * Erann Gat
> | The introduction to R5RS says, "Scheme was the first major dialect of
> | Lisp to [have certain distinguishing features]". So it does call itself
> | a "dialect of Lisp."
>
> * Erik Naggum
> > When was this written?
>
> * Erann Gat
> | R5RS is dated 20 February 1998. It's the most recent Scheme standard.
[Snip]
> Also note that I did not ask when the line was "published".
Yes. Note that I didn't actually answer when the passage was written. I
don't know when it was actually written, I just know the date given in the
document.
> Sometimes I wonder if you are intentionally obtuse or if you cannot help
> it. I keep hoping that you can do better, which is probably why it is so
> annoying that you do not. Let me know if I should stop hoping.
Sometimes I wonder if you are intentionally obnoxious or if you cannot
help it. I keep hoping that you can do better, which is probably why it
is so annoying that you do not. Let me know if I should stop hoping.
> > The two languages and their attendant communities have drifted so far
> > apart that there is nothing of value in their intersection.
>
> | What about the use of S-expressions to represent both code and data?
>
> How about using characters to represent source code?
Yes, how about that? We take it for granted nowadays that characters are
used to represent source code, but it wasn't always that way. Time was,
programs were represented by the positions of toggle switches, or the
physical layout of wires on plugboards. The idea that programs could be
represented using characters was considered revolutionary a mere 50 years
ago. (Grace Hopper told a story about trying to convince people to use
the A-0 "compiler", which today we would call an assembler. She says: "I
had a running compiler and nobody would touch it because, they carefully
told me, computers could only do arithmetic; they could not do programs."
This was 1952.)
There actually *are* programming "languages" that don't use characters.
My favorite example is LabView, which if you haven't seen it is actually
very cool. It's a graphical programming language with very Lispy
semantics. Some of these graphical programming systems even call
themselves "languages", like UML.
<tangent>
Personally, I don't think UML is a language. I think an essential
characteristic of a language is that it have fundamentally a
one-dimensional structure, whereas the fundamental structure of UML is
two-dimensional. But that's just my opinion.
</tangent>
Programming systems that use characters to represent source code seem to
me to fall into two major categories: those that use S-expressions and
those that do not. The reason I think that this is a useful division is
that S-expressions are a universal syntax that can represent both code and
data. Non-S-expression syntaxes can represent only code. (Note: this is
not inherently true. There's no reason why you couldn't design some
syntax other than S-expressions that could represent both code and data.
It's just that no one has.)
This has important practical consequences. For example, people who
program in non-S-expression syntaxes spend a lot of time and effort
designing and writing parsers for syntaxes for representing data. People
who use S-expressions spend very little time writing parsers because they
just use the built-in parser provided by their programming language
(a.k.a. READ). People who use S-expression-based languages tend to
embrace the idea of *extending* a programming langauge as a useful
programming technique because extending an S-expression-based language is
easy. People who use non-S-expression-based languages tend not to even
consider extending the language because doing so is all but impossible
(with Dylan perhaps being a notable exception).
So: you said that there is nothing of value in the intersection of Common
Lisp and Scheme. So do you think that S-expressions are not in the
intersection, or that they have no value?
E.
Erik Naggum
| So I have another question directed to those who say Scheme is not a
| Lisp: is the concept of "programming language with S-expression-based
| syntax" not important enough to deserve its own less verbose term? If it
| is, what should that term be if not "Lisp"?
How hard is it to say "Lisp family"?
Geoff Summerhayes
"Christopher Browne" <cbbr...@acm.org> wrote in message
news:m3sn74t...@salesman.cbbrowne.com...
> In the last exciting episode, Erik Naggum <er...@naggum.net> wrote::
> > * tb+u...@becket.net (Thomas Bushnell, BSG)
> > | But Scheme does call itself a Lisp!
> > |
> > | The very beginning of the R5RS reads:
> > |
> > | "The report gives a defining description of the programming language
> > | Scheme. Scheme is a statically scoped and properly tail-recursive dialect
> > | of the Lisp programming language invented by Guy Lewis Steele Jr. and
> > | Gerald Jay Sussman."
>
> > But how can you trust a specification that says the Lisp programming
> > language was invented by Guy Lewis Steele, Jr., and Gerald Jay
> > Sussman?
>
> <flame on>
> It doesn't say that except when you do a misleading, out-of-context
> reading of the text.
*snip*
>
> Go ahead and attack Scheme on technical grounds, but dredging up this
> kind of nonsense does nobody any favors.
> --
I don't know, personally I enjoy seeing the occasional bit of
levity in this NG. To borrow from Steele, I doubt that very
many users have complained to him that a misreading of that
sentence has cramped their programming style.
-----------------
Geoff
Erik Naggum
| Go ahead and attack Scheme on technical grounds, but dredging up this
| kind of nonsense does nobody any favors.
Anyone wonder why I get pissed off at the fucking morons who find faults
with every goddamn thing I do? TRY LIGHTENING UP, DICKWEED! It was an
attempt at light-hearted humor, although it was certainly at the expense
of some of the most anal-retentive bunch of stuck-ups I know, who quote
chapter and verse at people who argue about their inflammatory, useless
desire to included in the Lisp family ever after they left, voluntarily,
and who cannot even write well enough to communicate what they mean in
simple, unambiguous English.
Doug Quale
> I certainly think Interlisp is a lisp. I think so because it descends
> from the same cultural parentage as does Maclisp. That a split
> occurred doesn't mean one or the other half has to lose its identity.
You have explained this very carefully and clearly, but I am surprised
to see you emphasize at times the separateness of the Interlisp and
Maclisp communities, and at other times (especially when the question
of Scheme comes up) say that they are close enough to make Interlisp a
Lisp. Isn't it true that the Interlisp and Maclisp communities had no
significant mixing (when Interlisp was still alive)? My impression is
that the communities were almost totally separate, and that many in
the Maclisp community had the same kind of disdain for Interlisp then
that some in the Common Lisp community show for Scheme now.
> Incidentally, I think Stallman thought CL was being revolutionary, not
> evolutionary, because of its choice of lexical scope (and perhaps for
> other reasons). I think he thought he was keeping Lisp on the straight
> and narrow. If I were examining only the outcome, I might agree with him.
> But because it was a "community consensus process" that led to CL, and
> not just an individual striking out for change, I take CL's changes as
> evolutionary even though some of them, at a technical level, might be
> argued not to be.
Well, the "community consensus process" essentially included only the
Maclisp community (and its immediate offspring). History is written
by the victors. That answers a question, but I'm not certain if it's
the question that was asked. Basically we've arrived at "Scheme is
not a Lisp because Common Lisp people say it isn't." There is a nice
finality to this, if Common Lisp users have the ability to decree what
is and isn't a Lisp.
> > Does the fact that the Interlisp community has today reattached itself
> > to the Common Lisp community somehow retroactively make Interlisp a
> > Lisp?
>
> No. At least, I don't think so. Interlisp was always a Lisp.
I agree, but the community argument seems to be becoming more
tortured. The Maclisp and Interlisp communities were more isolated
from each other than the Common Lisp and Scheme communities were in
the past or are today, but apparently you argue that Interlisp is a
Lisp and Scheme is not because the Interlisp community division was
not ideologically motivated and the Scheme community division was.
The great thing about this argument is that it doesn't require any
comparison between Scheme and any other Lisp. Only the intent of
Sussman and Steele matters; their background, the process they used
and the result they obtained is irrelevant.
In thinking about this some more, the community argument is starting
to feel more and more like tracing royal bloodlines. I don't think
this is a very effective way to classify computer programming
languages, but maybe it gives some in the Common Lisp community a
feeling of Divine Right.
--
Doug Quale
Erik Naggum
You read "Scheme is a (dialect of) Lisp" to mean "Scheme is a member of
the Lisp family", and argue as if someone has denied that Scheme is a
member of the Lisp family. You have completely missed the point. If the
meaning you have inferred from the statement that has caused so much
hostility could have been stated plainly, nothing would have happened,
because the way it is written is so often _misunderstood_ (relative to
your understanding, at least), and it is the possible, even reasonable,
interpretation of that stupidly phrased relationshpi that is under attack.
You are barking up the wrong tree. Even eloquent barking does not change
the tree.
Thomas Bushnell, BSG
> (Grace Hopper told a story about trying to convince people to use
> the A-0 "compiler", which today we would call an assembler. She says: "I
> had a running compiler and nobody would touch it because, they carefully
> told me, computers could only do arithmetic; they could not do programs."
> This was 1952.)
You know, she is just stunningly amazing. I never hear a Grace
Hopper story that doesn't make me nearly swoon in admiration.
Thomas Bushnell, BSG
> Incidentally, I think Stallman thought CL was being revolutionary, not
> evolutionary, because of its choice of lexical scope (and perhaps for
> other reasons).
Do you mean "Sussman" here?
Bruce Hoult
"Geoffrey Summerhayes" <sumNOS...@hotmail.com> wrote:
> "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?
I don't know Shakespear from Rushdie, but that seems a perfectly clear
reference to a Foehn wind and the effect of its hot, dry, electrically
charged air on some people.
-- Bruce
Bruce Hoult
wrote:
> * 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.
Dylan and Common Lisp have *far* more in common with each other than
either has with Scheme!
-- Bruce
Doug Quale
> * Doug Quale <qua...@charter.net>
> | The Lisp family is a family of languages, not a single language.
>
> So _say_ "The language Scheme is a member of the Lisp language family"
> instead of saying "Scheme is a dialect of Lisp". Emphasize language, not
> dialect. Emphasize language family. A standards-like document that is
> so lacking in precision does both its audience and its subject matter a
> disservice.
Take any complaints about R5RS to Kent M Pitman. His name is on it,
not mine.
> | "Scheme is a Lisp", or more fully "Scheme is a member of the lisp
> | language family" emphasizes the substantial common ground in those four
> | important areas with other members of the lisp family.
>
> It does not mean that because Common Lisp is most likely the only "Lisp"
> they will see, and your interpretation of "is a lisp" as "member of the
> Lisp language family" assumes facts not in evidence, namely that "Lisp"
> is a language family, as seen by those who read it. Scheme is not a
> "dialect" of Common Lisp, and there are no other large _families_ of
> programming languages around that people talk about. Pascal is not a
> member of the Algol family, although Delphi might be a dialect of Pascal,
> but there is no Pascal family of languages, of which Ada is a member. So
> the notion of a language family cannot be assumed to exist in the readers
> and certainly not in students who go into the world and would like to
> study Common Lisp.
Common Lisp is likely to be the only "Lisp" they see, only if "Lisp"
does not include Scheme. This is begging the question. Actually I
think it might be a false statement anyway, since a significant number
of Lisp users may see Emacs lisp.
About the rest, Pascal and Ada are members of the Algol family of
languages, and people who study computer programming languages do talk
about it that way.
> | An interesting comparison can be made with the Algol family of languages.
> | This family includes Algol 60 as the founding member and has many members
> | including Algol-W, PL/1, Pascal, C and Ada. The Algol family includes
> | members that are far more different that Common Lisp and Scheme. No one
> | would ever confuse Algol 60 and Ada, but they are members of the Algol
> | family all the same.
>
> But who talks about the Algol family? None. Would a C programmer be
> anywhere close to comfortable with this classification? No.
People who study programming languages talk about the Algol family,
and a C programmer who knew Algol would be comfortable with this
classification. Anyway, there's no reason to classify programming
languages if your only goal is to make programmers comfortable.
> | I can't even imagine that level of emotion in a discussion between Pascal
> | and C partisans about the common cultural and historical origins of their
> | languages, although they can disagree very heatedly about the relative
> | merits of their chosen languages.
>
> But nobody says "C is an Algol".
True. "Is an Algol" doesn't parse, so it wouldn't make any sense.
--
Doug Quale
Rahul Jain
> You have explained this very carefully and clearly, but I am
> surprised to see you emphasize at times the separateness of the
> Interlisp and Maclisp communities, and at other times (especially
> when the question of Scheme comes up) say that they are close enough
> to make Interlisp a Lisp.
Then you have missed the whole point of the bulk of the discussion in
this thread.
Please go back and read the posts by Erik and Kent and others more
carefully. The English/German/Germanic analogy is very apropos to
this idea.
Rahul Jain
> True. "Is an Algol" doesn't parse, so it wouldn't make any sense.
And yet "is a Lisp" does?
Carl Shapiro
Isn't it true that the Interlisp and Maclisp communities had no
> significant mixing (when Interlisp was still alive)?
This is most certainly not true. There are a number of significant
ideas that were shared between Maclisp and the BBN-Lisp, SDS Lisp,
(and later) Interlisp, family. For example, the Interlisp NLAMBDA is
extremely similar to the Maclisp FEXPR.
Doug Quale
> Doug Quale <qua...@charter.net> writes:
>
> > True. "Is an Algol" doesn't parse, so it wouldn't make any sense.
>
> And yet "is a Lisp" does?
You must think it does.
If it doesn't, would you explain to me again what your complaint is?
--
Doug Quale
Kent M Pitman
> ... Isn't it true that the Interlisp and Maclisp communities had no
> significant mixing (when Interlisp was still alive)? My impression is
> that the communities were almost totally separate, and that many in
> the Maclisp community had the same kind of disdain for Interlisp then
> that some in the Common Lisp community show for Scheme now.
You mean like British and American?
> Well, the "community consensus process" essentially included only the
> Maclisp community (and its immediate offspring).
Yes, that's probably fair. But the point is that it didn't seek to shun
that community. It wanted to court that community, and for that community
to become its community. Scheme, by contrast, had no such aspirations
that I could detect.
But remember, I'm not saying Scheme is not part of the Lisp language family.
And there are days on which I'll describe Scheme as a Lisp. But they are
just massively outnumbered by the days when I won't. It's not an absolute.
There are days recently where people have pronounced that there is no
difference between Democrats and Republicans here in the US, too, and that
we are all just Americans. But those days are not as many as the days in
which they usefully separate themselves from each other to keep from scraping
each others' eyes out over issues that simply don't require addressing if
everyone stays in their respective right living rooms...
And I should also note that McCarthy has asked that no member of the Lisp
family claim the unadorned name "Lisp". That is, that it be reserved to
the family. It almost caused a huge problem when we submitted the
international standard for ISLISP to ISO and they "helpfully" renamed it to
the international standard for LISP (I guess figuring "IS" stood for
International Standard). By informal agreement among the members, "IS"
doesn't stand for that, nor does it stand for "is LISP". Though those things
were no doubt on someone's mind when they pushed the name originally. We just
need a gensym prefix so it wouldn't be just "LISP", and that was as good as
any. But ISO almost undid it. We got them to fix the problem with the cover
as a typo, fortunately, and the standards work proceeded.
But I mention this because we sometimes refer to "dialect of Lisp" yet the
term "dialect of xxx" usually refers to a language, and there really is no
language that is Lisp, so we're really saying "dialectal variants of
languages in the Lisp family", and then that makes the the question more
vague: what is in the question.
I have said many times that a major cause of strife in the world is that
people tend to assume that being fluent in a language implies total
understanding of it. I think often people don't take into account the full
breadth of vaguery that languages really carry with them, and they act as
if their speaking precisely means others will understand them precisely.
This is sometimes helpful when you want to get agreement on certain words
because it allows people to stretch to agree with things they might not agree
with if better specified. And it is very unhelpful when the word that is able
to stretch has negative connotation and one is trying to create a degree of
separation. I think the latter is what's happening here. We're using fuzzy
language. We wish we were doing otherwise. But tough. We have no way of
legislating how language is used. We have to endure that others will use
the words differently than we. The best we can do is just to explain our
own points of views and tolerate those of others.
> History is written
> by the victors. That answers a question, but I'm not certain if it's
> the question that was asked. Basically we've arrived at "Scheme is
> not a Lisp because Common Lisp people say it isn't." There is a nice
> finality to this, if Common Lisp users have the ability to decree what
> is and isn't a Lisp.
For myself, the issue isn't to "define away" or "marginalize" another
language. It is merely to restrict the meaning of an otherwise
useless word to a point where it can have meaning. In the US, in some
schools, we practically define everyone to have a passing grade in
school because somewhere along the way we have decided it's a
subjective judgment to fail someone, and no one should really be
singled out. Teachers get sued for failing students, and back down.
But in our attempt to embrace such "tolerance" of those who are
slower, we have made mockery of what it means to have "graduated". It
is not an attempt to exclude someone to make the term "pass" have
meaning. It is an attempt to say that there is no point to saying
someone passed if everyone passes. Narrowing the term does have the
effect of failing some students, but the _intent_ of narrowing the
term is not to fail some students, it is to say something specific
about those who did not fail. I have the same problem with the animal
rights movement babbling away with statements like "Animals are
people, too." Sigh.
Certainly McCarthy is entitled to say what he thinks is criterial to Lisp,
but I would make a different list. And I don't know how I feel about him
retaining the right to say what Lisp is. I don't generally accord to the
author of a book or director of a movie the right to dictate what the
significance of that book or movie is. Sometimes I'm not sure they even
know. I'm not saying McCarthy is an idiot by any means, nor even that he's
not entitled to his opinion. But I think we who have invested in the
community have a right to determine it too.
This issue came up in the design of CLTL and was a learning experience
for me. We who had been involved in the production of Steele's 1984
specification showed up in 1986 in a meeting in Monterrey, pre-ANSI,
to talk about what changes were needed. About twice the number of
people we expected showed up. Those new people said "we want a vote".
I was inclined at the time to say "you aren't entitled. if you like
it, fine. but if you don't, go make your own standard. we invested
in this standard and its ours to define." But their position was "No,
we have invested in this language, too, by having implemented and used
it. We are as much a part of the community as those who created the
community." I didn't like that position, but it seemed to be the
consensus of others older and wiser than myself at that meeting that
this was a reasonable position. And it's why we went to ANSI--because
we didn't have a good way of defining how to resolve who should have
how much power any more, but ANSI came with prefab rules on such
issues. And in retrospect, while I sometimes doubt the wisdom of
going with as sluggish an organization as ANSI, I think "we" (meaning
the people around me who were smarter and more politically powerful
than I, and has the wisdom to see better what to do) were right to
have included those newcomers as equals.
So now, having learned this lesson, I invoke the same claim that I once
eschewed--that I've settled in the Lisp community and have as much right
as anyone to claim an opinion as to what Lisp is. And no, we don't all
agree. That's ok. I addressed that above.
> The great thing about [the political] argument is that it doesn't
> require any comparison between Scheme and any other Lisp. Only the
> intent of Sussman and Steele matters; their background, the process
> they used and the result they obtained is irrelevant.
Well, I defend this position as one would a "thesis". I find it an
interesting point of view and I think it is both internally consistent
and conversationally useful. But I don't mean to suggest it's the only
possible view.
> In thinking about this some more, the community argument is starting
> to feel more and more like tracing royal bloodlines. I don't think
> this is a very effective way to classify computer programming
> languages, but maybe it gives some in the Common Lisp community a
> feeling of Divine Right.
I can see how it would seem that way if what you seek is to come up with
an answer to this question "what's a lisp?" in a context-independent way.
I don't think it has a single answer that transcends context, and so
the more you try to make it be wholly general, the more it requires weird
patching and I suppose Divine Right is as good a patch as any.
I usually use the political argument in particular contexts that seem
already political. People pop up here and say "Should I use Lisp or
Scheme?" and my immediate thought is "this is a political question"
because what I really hear is "I'm going to want certain things, and
when they are not there, I'm going to want to be in the community most
sympathetic to my needs and most likely to cater to me". Like it or not,
you don't get to an understanding of why a community is what it is, or
why it caters to one or another person or idea, without looking at
history.
But if you look at the set of partitions
In my Slashdot interview, I created a lot of divisions among languages
that are "technically" rather than "politically" derived. But those
are just overlays. They are no more Right than any other view.
They just suited the context, which was to suggest some different kinds
of languages that people should know in order to broaden their horizons.
- A block-structured language, such as Algol or Pascal or Scheme.
- A line-oriented language, such as Fortran or BASIC.
- A rule-based logic language, such as Prolog or EMYCIN.
- An Englishy language such as HyperTalk or Cobol.
- A "stack" language such as PostScript.
- A "line noise" language (heavy emphasis on one-letter operators)
like APL or Teco.
- A dynamic object-oriented language, such as Common Lisp or Smalltalk.
- A strongly-typed, statically analyzed language such as ML or Haskell.
- A dynamically-typed functional programming language, such as Scheme.
- A string or macro processing language, such as Perl or m4 or TeX or Teco.
- A database access language, such as SQL.
- An abstract high-level, assembly language, such as Java.
- A concrete high-level, assembly language, such as C.
- A low-level, traditional assembly language.
- A scripting language, such as Javascript.
- An interface-definition language such as Visual Basic, HyperTalk,
or Javascript.
- A document-structuring language such as XSL or TeX.
- A language with a modern error system, such as Common Lisp or Dylan.
- A reflective/introspective language such as Common Lisp or Java.
- A symbolic programming language, such as Common Lisp or Scheme.
- A security-oriented language, such as Java or MOO.
- A language where both programs and data are fully persistent,
such as MOO or HyperTalk.
You'll note that none of these categories was called Lisp. You'll also
note that there are categories that only include Scheme or only include
Common Lisp. And there is a category (which I called here "symbolic
programming languages") that includes both. This was a fairly ad hoc
list, so don't read too much into my choice of categories.
Some of the category names are deliberately provocative, in order to
encourage people to reconsider some of their assumptions. I guess
that's the thing that bugs me most about considering Scheme and Common
Lisp to both be Lisps. It just seems too easy to just say "hey,
they've got parens. they must be the same". It doesn't require much
thought, and I don't think it yields much conceptual leverage. I
think it makes the world think harder and learn more to say these are
not the same, and to force people to examine the differences. So if
you see me being stubborn on this, it's probably more about that and less
any intent to be gratuitously exclusionary.
(If I'm repeating myself uselessly, I'm relying on someone to hold me to
my promise to just shut up.)
Erik Naggum
| Take any complaints about R5RS to Kent M Pitman. His name is on it, not
| mine.
Please divert your energy to _thinking_, away from moronic hostilties.
Kent M Pitman
No, I meant Stallman. I was talking about how the split with Emacs
Lisp happened, since at the time Stallman set out to make it, we
pestered him to make it CL-compatible. But I recall at least one of
his major objections being the scoping. He insisted that dynamic
binding was essential to easy customization he sought in his work, but
in any case was the way Lisp was supposed to be. I think this was a
principled position, even if I didn't agree with it. I can't remember
if he had other objections as well. I felt he was abandoning Common Lisp,
but I think he felt the reverse, that it was abandoning him.
Maybe you were confused because you see the term "revolutionary" as a
term of admiration. I meant it only literally, and not as a term of
either good or bad; that is, "going against the inertial flow".
Kent M Pitman
> Erik Naggum <er...@naggum.net> writes:
>
> > But nobody says "C is an Algol".
>
> True. "Is an Algol" doesn't parse, so it wouldn't make any sense.
Besides, Scheme aspires to be an Algol.
Thomas Bushnell, BSG
> tb+u...@becket.net (Thomas Bushnell, BSG) writes:
>
> > Kent M Pitman <pit...@world.std.com> writes:
> >
> > > Incidentally, I think Stallman thought CL was being revolutionary, not
> > > evolutionary, because of its choice of lexical scope (and perhaps for
> > > other reasons).
> >
> > Do you mean "Sussman" here?
>
> No, I meant Stallman. I was talking about how the split with Emacs
> Lisp happened, since at the time Stallman set out to make it, we
> pestered him to make it CL-compatible.
Ah, ok, that's why I was asking. I was unsure of the history, and it
seemed to me it could make sense both ways. :) I mean, Stallman and
Sussman are *still* only paces away from eachother most of the time. :)
> But I recall at least one of his major objections being the scoping.
> He insisted that dynamic binding was essential to easy customization
> he sought in his work, but in any case was the way Lisp was supposed
> to be.
Hrm, curious.
One irony is that the thrust of GNU Emacs development in this regard
today is to ultimately transition the extension language to
Guile--lexically scoped as all bingo! It will have dynamic variables
too, of course; emacs really does seem to need them.
I think one difference in retrospect is that Common Lisp is very, um,
non-lightweight. Even the 1984 spec is *very* rich. While that
richness is one of the great strengths of Common Lisp, and one of the
things that accounts for its popularity, it is also a detriment to
using it as an extension language for something like Emacs.
People already complain about Emacs being too huge; adding in the
entire library of Common Lisp would be, um, painful.
Thomas
Thomas Bushnell, BSG
> We have to endure that others will use the words differently than
> we. The best we can do is just to explain our own points of views
> and tolerate those of others.
I think this is surely right. It seems to me that a necessary
corollary is that we ought not insist that the thing named
"comp.lang.lisp" is only for Common Lisp, and nothing else.
Erann Gat
> * Erann Gat
> | So I have another question directed to those who say Scheme is not a
> | Lisp: is the concept of "programming language with S-expression-based
> | syntax" not important enough to deserve its own less verbose term? If it
> | is, what should that term be if not "Lisp"?
>
> How hard is it to say "Lisp family"?
That's fine, but given the vehemence with which "Scheme is a Lisp" is
opposed it is not self-evident that "Scheme is a member of the Lisp family
of languages" would be any less objectionable. In fact, to me both
sentences seem to mean precisely the same thing.
E.
Doug Quale
Are you sure about this? NLAMBDA is extremely similar to FEXPR, but
Wasn't FEXPR in Lisp 1.5, a common ancestor to both Maclisp and
Interlisp? MIT AI Memo 57 mentions FEXPR in 1963, the year I was
born. (Timothy P. Hart, "Macro Definitions for LISP", AI Memo 57,
October 1963.)
Steele and Gabriel talk about the Maclisp and Interlisp communities in
"The Evolution of Lisp" (Guy L. Steele, Jr. and Richard P. Gabriel,
ACM SIGPLAN Notices, 28(3), p231-270, 1993). They say this about a
1974 meeting between Maclisp and Interlisp implementors:
"In 1974 about a dozen persons attended a meeting at MIT between the
MacLisp and Interlisp implementors, including Warren Teitelman, Alice
Hartley, Jon L White, Jeff Golden, and Steele. There was some hope of
finding substantial common ground, but the meeting actually served to
illustrate the great chasm separating the two groups, in everything
from implementation details to overall design philosophy.... In the
end only a trivial exchange of features resulted from "the great
MacLisp/Interlisp summit": MacLisp adapted from Interlisp the behavior
(CAR NIL) -> NIL and (CDR NIL) -> NIL, and Interlisp adopted the
concept of a read table."
--
Doug Quale
Paul Wallich
(Erann Gat) wrote:
Nah. It's a matter both of precedence and of the fact that "A Lisp"
has pretty much come to mean Common Lisp, at least in this
newsgroup. (All of the remnants and descendants of older-style
lisps and little lisps seem pretty strongly deprecated -- not that
that's necessarily a bad approach).
But whoever was trying to use the analogy to saying that English
is a dialect of German vs saying that English is a member of the
germanic family of languages had it about right, I think. One
fomulation makes it clear that the family name is just a name,
the other implies which language the speaker considers first-class.
paul
Christopher Browne
> People already complain about Emacs being too huge; adding in the
> entire library of Common Lisp would be, um, painful.
I really can't imagine why this should be considered so "painful."
The source code for CLISP, a CL in C, represents a download of about
10.8MB of code.
The equivalent download for Guile and Goops is 7.3MB. There's a
difference in size, but not a particularly immense difference. Add in
a bytecompiler for Guile, which _isn't_ there now, and I'd be
completely unsurprised to see the source tree for Guile get downright
bigger than that.
Similar is true for DrScheme/MzScheme, which has a footprint of about
12MB of sources. That probably includes the GUI, but it's hardly
"tiny."
--
(reverse (concatenate 'string "gro.gultn@" "enworbbc"))
http://www.ntlug.org/~cbbrowne/internet.html
Rules of the Evil Overlord #46. If an advisor says to me "My liege, he
is but one man. What can one man possibly do?", I will reply "This."
and kill the advisor. <http://www.eviloverlord.com/>
Erik Naggum
| I think this is surely right. It seems to me that a necessary corollary
| is that we ought not insist that the thing named "comp.lang.lisp" is only
| for Common Lisp, and nothing else.
But nobody "insist" on that at all -- nobody even thinks so. All I
insist is that you take your Scheme stuff to comp.lang.scheme and your
Dylan stuff to comp.lang.dylan and your Ada stuff to comp.lang.ada,
because so little information come out of polluting discussions with
these other languages. This is both because these languages have their
own fan clubs/newsgroups and because that only the differences between
Common Lisp and these other languages are discussed here. People do in
fact not discuss their commonality here. It is that simple and easy.
I actually completely fail to understand what you Scheme freaks and Dylan
users want to take over comp.lang.lisp for. Why are you posting here?
Better audience, smarter people, fewer anal-retentive readers, _what_?
Why _do_ you want to post comp.lang.lisp when it annoys people so much?
I conclude that you do it in _order_ to annoy people and that you have
_no_ constructive element to your obnoxiousness.
Erik Naggum
| I think one difference in retrospect is that Common Lisp is very, um,
| non-lightweight. Even the 1984 spec is *very* rich. While that richness
| is one of the great strengths of Common Lisp, and one of the things that
| accounts for its popularity, it is also a detriment to using it as an
| extension language for something like Emacs.
I disagree. Emacs Lisp would have been a lot simpler if it were based on
Common Lisp. A lot. Object-orientation Common Lisp style would have
made Emacs a lot more customizable and much friendlier to Emacs hackers
(old sense).
| People already complain about Emacs being too huge; adding in the entire
| library of Common Lisp would be, um, painful.
Not so. Trust me on this, I spent a year or so working on a design for
CLEMACS, until it became clear to me that I would have to maintain
_continued_ source-level compatibility with Emacs Lisp, and that caused
me to rethink the whole idea and its desirability, because I had worked
too long on Emacs Lisp to regard this as a simple, solvable problem.
Erik Naggum
> True. "Is an Algol" doesn't parse, so it wouldn't make any sense.
* Rahul Jain
> And yet "is a Lisp" does?
* Doug Quale <qua...@charter.net>
| You must think it does.
|
| If it doesn't, would you explain to me again what your complaint is?
So we have yet another stupid troll on our hands. Go away, OK?
Erik Naggum
| That's fine, but given the vehemence with which "Scheme is a Lisp" is
| opposed it is not self-evident that "Scheme is a member of the Lisp
| family of languages" would be any less objectionable. In fact, to me
| both sentences seem to mean precisely the same thing.
That is because you do not listen to other people, Erann. If they mean
the same thing to you, say the latter, and see how people react. If you
only _think_ they would react the same because you think the two are the
same, which they are not, you make the age-old mistake of prejudice. Not
that this surprises me, but it is still something you can do better than.
Rahul Jain
> Rahul Jain <rj...@sid-1129.sid.rice.edu> writes:
> > Doug Quale <qua...@charter.net> writes:
> > > True. "Is an Algol" doesn't parse, so it wouldn't make any sense.
> > And yet "is a Lisp" does?
> You must think it does.
Why must I think it does?
> If it doesn't, would you explain to me again what your complaint is?
That you are claiming that a statement that doesn't exist is true, I
guess.
Pierre R. Mai
I don't think so.
Regs, Pierre.
--
Pierre R. Mai <pm...@acm.org> http://www.pmsf.de/pmai/
The most likely way for the world to be destroyed, most experts agree,
is by accident. That's where we come in; we're computer professionals.
We cause accidents. -- Nathaniel Borenstein
Kent M Pitman
> Kent M Pitman <pit...@world.std.com> writes:
> > But I recall at least one of [RMS'] major objections being the scoping.
> > He insisted that dynamic binding was essential to easy customization
> > he sought in his work, but in any case was the way Lisp was supposed
> > to be.
>
> Hrm, curious.
>
> One irony is that the thrust of GNU Emacs development in this regard
> today is to ultimately transition the extension language to
> Guile--lexically scoped as all bingo! It will have dynamic variables
> too, of course; emacs really does seem to need them.
Yes, I've noticed this, too. But I find I'm wrong sometimes, or that I
change. And so I like not to rub it in. I remember when I was in grade
school having my mom say that one day some food she was trying to foist
upon me that day would be something I would like. But I had the presence
of mind to came back with: Yes, but right now I'm a child, and I haven't
made that transition yet, and I don't like it. (Which is not to say that
RMS was then a child. Just that people take things at their own pace.)
> I think one difference in retrospect is that Common Lisp is very, um,
> non-lightweight.
Sure. But all I wanted him to do was to be CL-compatible on the obvious
syntactic stuff, to avoid _gratuitous_ divergence. Purposeful divergence
is another matter.
> Even the 1984 spec is *very* rich. While that
> richness is one of the great strengths of Common Lisp, and one of the
> things that accounts for its popularity, it is also a detriment to
> using it as an extension language for something like Emacs.
I disagree, only since I didn't ever suggest this. Subsetting would have
been adequate. I'm quite sure he wasn't confused about my desire on
this point.
> People already complain about Emacs being too huge; adding in the
> entire library of Common Lisp would be, um, painful.
And needless. I certainly would never have suggested it.
Kent M Pitman
> Carl Shapiro <cshapi...@panix.com> writes:
>
> > Doug Quale <qua...@charter.net> writes:
> >
> > Isn't it true that the Interlisp and Maclisp communities had no
> > > significant mixing (when Interlisp was still alive)?
> >
> > This is most certainly not true. There are a number of significant
> > ideas that were shared between Maclisp and the BBN-Lisp, SDS Lisp,
> > (and later) Interlisp, family. For example, the Interlisp NLAMBDA is
> > extremely similar to the Maclisp FEXPR.
>
> Are you sure about this? NLAMBDA is extremely similar to FEXPR, but
> Wasn't FEXPR in Lisp 1.5, a common ancestor to both Maclisp and
> Interlisp? MIT AI Memo 57 mentions FEXPR in 1963, the year I was
> born. (Timothy P. Hart, "Macro Definitions for LISP", AI Memo 57,
> October 1963.)
The difference was that NLAMBDA had an anonymous form.
((NLAMBDA (A B) (LIST B A)) X Y) => (Y X)
A FEXPR was a property upon which you put an ordinary LAMBDA and it caused
the symbol having that property to have special meaning.
(DEFPROP FOO (LAMBDA (ARGS) (LIST (CADR ARGS) (CAR ARGS))) FEXPR)
(FOO X Y) => (Y X)
Note, though, that when such a DEFPROP was compiled, it secretly put
a compiled function on the FSUBR property instead of putting a list
on the FEXPR property. Maclisp was full of strangeness like that.
NLAMBDA was more akin to the Zetalisp "E.
(NLAMBDA (X Y) (LIST X Y)) == (LAMBDA ("E X Y) (LIST X Y))
NLAMBDA had no way to express &EVAL, which would undo the "E effect.
These ideas were important to bootstrapping systems, but were bad in users'
hands and went away when macros came into big popularity. See my Special
Forms paper at
http://world.std.com/~pitman/Papers/Special-Forms.html
Kent M Pitman
It doesn't have to be a member of the Lisp family to use Lisp notation.
I'd just say it uses Lisp-like notation, just as I'd say Java uses C-like
notation.
No need to pull in the full baggage of language families, which implies
a lot more than syntax, if all you're talking about is notation.
Bruce Hoult
Larry Clapp <la...@theclapp.org> wrote:
> 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]
Your a) and b) are just special cases of d).
I don't think any of these need to be true in a precise, character for
character way, in order for both to be "Lisps".
I'd look for things more like ability to translate typical textbook
programs from one language to another without excessive blowout in
program size. I'd allow non-task specific libraries to be added without
counting towards the program size e.g. hash tables or OO libraries for
Scheme.
What proportion of code from SICP can be easily translated to Common
Lisp or Dylan? Just about anything that doesn't use call/cc (and much
that does).
What proportion of "On Lisp" can be easily translated into Dylan or
Scheme? Well, I'm in the process of finding out but the answer, at
least in the case of Dylan, is "more than you might think".
-- Bruce
Daniel Barlow
> People already complain about Emacs being too huge; adding in the
> entire library of Common Lisp would be, um, painful.
In 1984, maybe. Today, I doubt anyone would notice. The emacs I'm
writing this in is 50Mb or so in RSS: adding gnu clisp to this would
make for another 2Mb, at a guess. Maybe the extra stuff in the Common
Lisp library would even bring this size down through code reuse.
Greenspun's Rule, etc.
The emacs I'm writing this in is not usually even the biggest process
on this machine either: that position is reserved for some kind of
glorified help file viewer with a socket interface stuck on (netscape,
mozilla, galeon, depending on whim)
-dan
--
http://ww.telent.net/cliki/ - Link farm for free CL-on-Unix resources
Thomas Bushnell, BSG
> Yes, I've noticed this, too. But I find I'm wrong sometimes, or that I
> change. And so I like not to rub it in.
I remember asking RMS why Emacs didn't use lexical scoping; this was
back in the early 90s. He said that if he had it over to do, it would
use lexical scoping. I had no idea that it was such a hot-button
issue for him back when he was doing the design
Bruce Hoult
Kent M Pitman <pit...@world.std.com> wrote:
> olc...@interaccess.com (Thaddeus L Olczyk) writes:
>
> > 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.
> > )
>
> 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.
I think that is in fact the appropriate test.
> 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.
I'd agree that BASIC is a dialect of FORTRAN. Most programs in one can
be painlessly restated in the other.
This is not true of either language and C or Pascal or Lisp.
> And also, I think both C and Pascal are members of the Algol family.
> But your test seems to presuppose they are unrelated languages.
I agree that C and Pascal are members of the Algol family (as are Scheme
and Dylan), but they've diverged too far to be considered to be dialects
of each other.
Even beginning Pascal texts make heavy use of lexically nested
functions, which can not be readily translated into C. And beginning C
texts make heavy use of pointer/array conversion and pointer arithmetic,
which can not be readily translated into Pascal.
The same argument applies to, say, Scheme and ML. There is a lot in
common, but ML texts make heavy use of implicit currying and pattern
matching, while Scheme texts make heavy use of runtime polymorphism.
> Scheme is its own language, not a dialect of Lisp.
Change that to "not a dialect of *Common* Lisp and I'd agree with you.
Certainly it is its own language, but saying it's a Lisp is not
insulting it.
> 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.
Not only in the historical sense. Most idiomatic Dylan and CL code that
I have seen can very easily be translated to the other language and
still be idiomatic.
-- Bruce
Thomas Bushnell, BSG
> What proportion of code from SICP can be easily translated to Common
> Lisp or Dylan? Just about anything that doesn't use call/cc (and much
> that does).
SICP never mentions call/cc, so that part is easy!
However, SICP frequently uses variables to hold functions without
wanting extra hair. For example, on p. 58 (of the 2nd edition), is
the following example for a "sigma" summation function:
(define (sum term a next b)
(if (> a b)
0
(+ (term a)
(sum term (next a) next b))))
People have barely begun the course when they get to this. In CL,
you'd do the same thing if you wanted, by passing in functions and
using APPLY to call them.
So in one sense, it's trivial to translate. However, it would totally
defeat the pedagogic purpose to have to talk about APPLY at such an
early stage.
Similarly, functions are returned as values on pp. 72ff.
Any language with first class procedures can do this, of course, and
it's easy to add calls to APPLY (and friends) wherever necessary to
translate into Lisp. In once sense, then, you can translate
everything easily. In another sense, you would defeat the pedagogic
purpose of SICP if you had to.
SICP doesn't mention hygenic macros either, and it might be hard to
automatically translate them to CL macros; however, a human who looked
at and understood a Scheme macro definition, could surely produce the
equivalent Common Lisp with no trouble.
Thomas
Doug Quale
> Doug Quale <qua...@charter.net> writes:
>
> > ... Isn't it true that the Interlisp and Maclisp communities had no
> > significant mixing (when Interlisp was still alive)? My impression is
> > that the communities were almost totally separate, and that many in
> > the Maclisp community had the same kind of disdain for Interlisp then
> > that some in the Common Lisp community show for Scheme now.
>
> You mean like British and American?
Yes, and we speak a common language don't we? American English is
English, isn't it? How does this support the idea that the Interlisp
community belongs to the Lisp community and Scheme doesn't?
> And I should also note that McCarthy has asked that no member of the Lisp
> family claim the unadorned name "Lisp". That is, that it be reserved to
> the family.
I hope Erik Naggum is reading this, because he maintains that "Lisp"
is not understood to mean the Lisp family.
Also, you frequently seem to use Lisp yourself when you are in fact
assuming CL.
> But I mention this because we sometimes refer to "dialect of Lisp" yet the
> term "dialect of xxx" usually refers to a language, and there really is no
> language that is Lisp, so we're really saying "dialectal variants of
> languages in the Lisp family", and then that makes the the question more
> vague: what is in the question.
This is an interesting point. Clearly "Scheme is a dialect of Lisp"
should have the same interpretation as "Interlisp is a dialect of
lisp", although they may have different truth values. If it is
sensible to call Common Lisp a dialect of Lisp, then the question "Is
Scheme a dialect of Lisp" has meaning.
> > History is written
> > by the victors. That answers a question, but I'm not certain if it's
> > the question that was asked. Basically we've arrived at "Scheme is
> > not a Lisp because Common Lisp people say it isn't." There is a nice
> > finality to this, if Common Lisp users have the ability to decree what
> > is and isn't a Lisp.
>
> For myself, the issue isn't to "define away" or "marginalize" another
> language. It is merely to restrict the meaning of an otherwise
> useless word to a point where it can have meaning.
Do you mean that saying "Scheme is a member of the lisp family" would
make the word "lisp" useless? I don't agree, but clearly that is a
matter of opinion.
> Certainly McCarthy is entitled to say what he thinks is criterial to Lisp,
> but I would make a different list.
As is your right. The original question that spawned this thread
boils down to, "What is your list that makes Scheme not a Lisp?" Some
people have had difficulty imagining what the list might be, since the
list should include Lisp 1.5, Maclisp, Interlisp, NIL, ZetaLisp,
Common Lisp and others and exclude Scheme. I'm not sure whether your
list would include PSL or MuLisp as Lisps, since they had essentially
no cultural connection with Maclisp at all. Presumably the list would
also not include T even though you yourself were responsible for some
nice parts of that language design. Since I don't have your list, I
can't tell.
> And I don't know how I feel about him
> retaining the right to say what Lisp is. I don't generally accord to the
> author of a book or director of a movie the right to dictate what the
> significance of that book or movie is. Sometimes I'm not sure they even
> know. I'm not saying McCarthy is an idiot by any means, nor even that he's
> not entitled to his opinion. But I think we who have invested in the
> community have a right to determine it too.
I'm not granting him that right a priori, and in actual fact I don't
know if McCarthy considers Scheme to be a Lisp. One of the things
that I can say in favor of McCarthy is that he has provided some
characteristics that could actually be used to determine whether or
not a programming language is a member of the lisp family in a fairly
objective and non-arbitrary fashion. I can't really say that about
the community argument you have offered.
> So now, having learned this lesson, I invoke the same claim that I once
> eschewed--that I've settled in the Lisp community and have as much right
> as anyone to claim an opinion as to what Lisp is. And no, we don't all
> agree. That's ok. I addressed that above.
It's OK with you, it's OK with me, but it's obviously not OK with
everyone. Another round of name-calling will ensue from some
ill-behaved members of the CL crowd. You're certainly not responsible
for it, but it's a shame.
> > The great thing about [the political] argument is that it doesn't
> > require any comparison between Scheme and any other Lisp. Only the
> > intent of Sussman and Steele matters; their background, the process
> > they used and the result they obtained is irrelevant.
>
> Well, I defend this position as one would a "thesis". I find it an
> interesting point of view and I think it is both internally consistent
> and conversationally useful. But I don't mean to suggest it's the only
> possible view.
There's no doubt it's consistent, but it has some unusual properties.
It basically hinges on your opinion that the Scheme community
deliberately broke away from the Lisp community. In other words,
Common Lisp didn't force Scheme out, Scheme left on its own (before
Common Lisp was born). This relies on your insight into the motives
of Sussman and Steele when they created Scheme. Anyone lacking that
insight may have trouble with your argument without some additional
supporting evidence. You have an advantage here, since you know
Sussman and Steele personally and I don't.
> I usually use the political argument in particular contexts that seem
> already political.
Why is the question "Is Scheme a Lisp?" political to you? That really
gets to the heart of it. It may explain why some Common Lisper's
react so emotionally the this question, and why that emotion surprises
Schemer's who expect that the answer might be based on syntax,
semantics or problem domain rather than politics.
> People pop up here and say "Should I use Lisp or
> Scheme?" and my immediate thought is "this is a political question"
> because what I really hear is "I'm going to want certain things, and
> when they are not there, I'm going to want to be in the community most
> sympathetic to my needs and most likely to cater to me". Like it or not,
> you don't get to an understanding of why a community is what it is, or
> why it caters to one or another person or idea, without looking at
> history.
That question certainly is often political, but it wasn't the question
that was asked this time. Even so, the full history of Lisp doesn't
seem to be well understood even in c.l.l. I don't place you in this
group, but many people have strong opinions that Scheme is not a Lisp,
but don't know the circumstances in which McCarthy created Lisp around
1958 or 1959, or how Sussman and Steele came to create Scheme in 1977
and 1978. Naturally you are far more familiar with much of that
history than I am since you experienced important parts of it first
hand. It is certainly possible that what I have read is not true or
that I have misinterpreted it -- that's one of the reasons why I am
here.
I know you don't want to get drawn into an extended discussion of this
list, but which category includes Scheme that wouldn't include Common
Lisp? I don't see how Scheme is any more block-structured than CL
except in superficial ways, even if you didn't list Common Lisp in
that category.
> I guess
> that's the thing that bugs me most about considering Scheme and Common
> Lisp to both be Lisps. It just seems too easy to just say "hey,
> they've got parens. they must be the same". It doesn't require much
> thought, and I don't think it yields much conceptual leverage. I
> think it makes the world think harder and learn more to say these are
> not the same, and to force people to examine the differences. So if
> you see me being stubborn on this, it's probably more about that and less
> any intent to be gratuitously exclusionary.
I know the "hey they've got parens, they must be the same" worry has a
lot of traction in this newgroup, but please forgive me if I say that
it sounds silly to me. I can see that it is very important for the
Common Lisp community to emphasize its differences with Scheme, but I
can't understand why. It's certainly your perogative, but if that's
your best argument, you can probably see why it might look like an
intent to be gratuituously exclusionary.
> (If I'm repeating myself uselessly, I'm relying on someone to hold me to
> my promise to just shut up.)
No, I always find what you have to say interesting even if I disagree.
I think others do too.
--
Doug Quale
Doug Quale
> Seems like this list is misleading and/or inaccurate. Probably because
> it was published in 1980 and we're applying it to 2000's context.
You overlooked that I pointed out the fact that McCarthy explicitly
wrote in 1999 that the paper still accurately reflected his opinions.
Also, I don't mean to be insulting, but you do know that John McCarthy
invented LISP in 1958 or 1959, right? If you haven't read "Recursive
Functions of Symbolic Expressions and Their Computation by Machine,
Part I" by McCarthy from Commications of ACM, 1960, you should before
you continue. (You can find it on line at
http://www-formal.stanford.edu/jmc/recursive.html).
Most of the rest of your comments are historically or technically
inaccurate.
--
Doug Quale