Here are Larry Wall's musings on the future of Perl, in case you're
interested in this kind of thing:
······································@perl.org/msg00409.html
It looks like Perl 6 is going to have dynamic and static types like Common
Lisp.
glauber
----- Posted via NewsOne.Net: Free (anonymous) Usenet News via the Web -----
http://newsone.net/ -- Free reading and anonymous posting to 60,000+ groups
NewsOne.Net prohibits users from posting spam. If this or other posts
made through NewsOne.Net violate posting guidelines, email ·····@newsone.net
··········@my-deja.com writes:
> Here are Larry Wall's musings on the future of Perl, in case you're
> interested in this kind of thing:
> ······································@perl.org/msg00409.html
>
> It looks like Perl 6 is going to have dynamic and static types like Common
> Lisp.
>
Just to quote out of context.
I think ugly can be beautiful, and that beautiful can get ugly real
quick. I think in particular of Lisp, which is the most beautiful
language in the world, and every program in Lisp is real ugly.
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
Like DNA, such a language [Lisp] does not go out of style.
Paul Graham, ANSI Common Lisp
>>>>> "Marco" == Marco Antoniotti <·······@cs.nyu.edu> writes:
Marco> ··········@my-deja.com writes:
>> Here are Larry Wall's musings on the future of Perl, in case you're
Marco> Just to quote out of context.
Marco> I think ugly can be beautiful, and that beautiful can get ugly real
Marco> quick. I think in particular of Lisp, which is the most beautiful
Marco> language in the world, and every program in Lisp is real ugly.
A former colleague, knowing my fancy for Lisp, used to cite the
following Larry Wall quote (this is from memory, with the usual bunch
of disclaimers):
Lisp programs has all the appeal of toe-nail clippings in
a bowl of soup.
Somehow it seems that Larry has a real problem with Lisp syntax.
------------------------+-----------------------------------------------------
Christian Lynbech | Ericsson Telebit, Skanderborgvej 232, DK-8260 Viby J
Phone: +45 8938 5244 | email: ·················@ted.ericsson.dk
Fax: +45 8938 5101 | web: www.ericsson.com
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
Christian Lynbech <···@tbit.dk> wrote:
> A former colleague, knowing my fancy for Lisp, used to cite the
> following Larry Wall quote (this is from memory, with the usual bunch
> of disclaimers):
> Lisp programs has all the appeal of toe-nail clippings in
> a bowl of soup.
The actual quote was:
Lisp has all the visual appeal of oatmeal with fingernail clippings
mixed in.
--Larry Wall in <······················@netlabs.com>
In article <·············@vermin.dsl.snfc21.pacbell.net>,
Aaron Kushner <····@netcom.com> wrote:
>Christian Lynbech <···@tbit.dk> wrote:
>> A former colleague, knowing my fancy for Lisp, used to cite the
>> following Larry Wall quote (this is from memory, with the usual bunch
>> of disclaimers):
>
>> Lisp programs has all the appeal of toe-nail clippings in
>> a bowl of soup.
>
>The actual quote was:
>
> Lisp has all the visual appeal of oatmeal with fingernail clippings
> mixed in.
> --Larry Wall in <······················@netlabs.com>
Does anybody have a reason why I should pay any attention to a Perl
designer and implementor about language or program aesthetics? It's
like a COBOL fanatic complaining about keyword bloat in a language.
--
David H. Thornley | If you want my opinion, ask.
·····@thornley.net | If you don't, flee.
http://www.thornley.net/~thornley/david/ | O-
Erik Naggum <····@naggum.net> writes:
> * David Thornley
> > Does anybody have a reason why I should pay any attention to a
> > Perl designer and implementor about language or program
> > aesthetics?
>
> You should pay attention and remember it because it says so much
> about both Larry Wall and Perl that virtually nothing else needs
> to be said about either of them.
I don't know if I would transfer the stupidity of Wall's statement
onto all of Perl. It is a language with a mission, and it has
successfully helped programmers solve that mission. Wall's ignorance
with respect to _Common_ Lisp might be based on seeing Scheme code, in
which case I would actually agree with his statement. [I have reason
to believe this because, after reading the recent transcription of
Wall on the next Perl, he clumps Lisp and Scheme, and probably doesn't
know the difference.] It's also a relative statement (relative to
what he's seen, and his personal tastes). Lastly, it's not wise to
label Wall based on something he said once, out of context.
This whole thing about attributing (or blaming) one guy (Wall) for
Perl reminds me of the American obsession with the MVP concept -- that
there's always one person behind it all, and we make that person into
a god (or scapegoat or whatever). Perl is a major effort by tons of
people who work towards making it useful and functional. They do seem
to spend more time on libraries rather than fixing the syntax of the
language, but remember that these are hackers who are developing a
language mostly for hacking solutions. If you accept it as that, then
it's not nearly as bad. If you program in Perl and constrain yourself
to certain coding standards and rules, then it becomes a useful tool
for creating maintainable code.
Now, at the same time, despite my comfort with Perl's syntax, I do
believe that making any derogatory statement about Common Lisp syntax
is absurd. Consider that part of Perl's code parser is a
disambiguator. As bad as, say, the LOOP macro might be, Perl is worse
both on a character _and_ token basis.
dave
>>>>> On Wed, 21 Feb 2001 07:18:07 GMT, David Bakhash ("David") writes:
David> but remember that these are hackers who are developing a
David> language mostly for hacking solutions. If you accept it as that, then
David> it's not nearly as bad.
I remember when "hackers" and "hacking" did not connote negative qualities.
It sounds like you're trying to say something about the problem domain
that most Perl library programmers are addressing, but I am not sure what.
Christopher C Stacy <······@world.std.com> writes:
> >>>>> On Wed, 21 Feb 2001 07:18:07 GMT, David Bakhash ("David") writes:
> David> but remember that these are hackers who are developing a
> David> language mostly for hacking solutions. If you accept it as that, then
> David> it's not nearly as bad.
>
> I remember when "hackers" and "hacking" did not connote negative qualities.
> It sounds like you're trying to say something about the problem domain
> that most Perl library programmers are addressing, but I am not sure what.
Ah, I read "hacking" as a verb, not an adjective. Perl is used by
pragmatic solution-oriented people - it lays much value on solving the
problem at hand, and less on "elegance" or "cleanliness". "The right
way to do it is whichever way gets your job done"
The example that comes first to mind is CGI.pm
-dan
--
http://ww.telent.net/cliki/ - Link farm for free CL-on-Unix resources
Daniel Barlow, like a lot of people, you are really a moron. But lucky you,
that in this thread i'm getting tired of playing a dramatist, so in this
message i'll smash your brain with cold logic instead. (I usually don't
address morons.)
Daniel Barlow <···@noetbook.telent.net> wrote:
> Ah, I read "hacking" as a verb, not an adjective. Perl is used by
> pragmatic solution-oriented people - it lays much value on solving the
> problem at hand, and less on "elegance" or "cleanliness". "The right
> way to do it is whichever way gets your job done"
>
> The example that comes first to mind is CGI.pm
It is hard to pinpoint the exact meaning in your plebeian babbling. Suppose
you meant to say:
* There are lots of useful codes in Perl.
This I agree, and really, nobody here needs you to tell us a fact that every
3 years-old knows. Suppose you meant to say:
* People who code in Perl prefer quick solutions and do solve problems
quickly.
This I agree also. As you must know, "quick solution" implies temporary, ad
hoc, badly designed, non maintainable, incorrect at lots of cases, non
extensible. As well, any 3 years old in computer science knows that. Thanks
for your golden mouth. But you also said:
* "The right way to do it is whichever way gets your job done"
This is getting interesting. Suppose you are hungry. You have many choices
to solve that problem. You can, for example: (1) cook a wholesome meal. (2)
Grab some junk food at a burger joint. (3) inject dextrose into your blood
stream. (4) take a beer enema.
Now, according to your sound philosophy, The right way to do it is whichever
way gets your job done. Now being a lazy, impatient, hubris ridden
worry-later moron like you are, you'd probably pick numero four all the
time. See what i mean? No? Think!
Lastly, you said
> The example that comes first to mind is CGI.pm
Oh yess, the infamous CGI.pm by Lincoln Stein. The single most reason for
the vast majority of dynamic web pages being non-HTML compliant. Fucking
fuck fuck ass fuck Lincoln Stein for that one.
(and suppose if Larry Wall and Lincoln Stein dropped dead before they are
born, then ecommerce would wail and refuse to be born too.)
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Daniel Barlow <···@noetbook.telent.net>
> Organization: blueyonder (post doesn't reflect views of blueyonder)
> Newsgroups: comp.lang.lisp
> Date: Wed, 21 Feb 2001 19:21:46 GMT
> Subject: Re: Perl becoming Lispier
Xah Lee <···@xahlee.org> writes:
> Daniel Barlow, like a lot of people, you are really a moron. But lucky you,
> that in this thread i'm getting tired of playing a dramatist, so in this
> message i'll smash your brain with cold logic instead. (I usually don't
> address morons.)
You usually talk about yourself too much.
--
Janis Dzerins
If million people say a stupid thing it's still a stupid thing.
> You usually talk about yourself too much.
loneliness takes toll on both baboons and the brainy.
Why do human beings write poetry?
Why do altruists announce their deeds?
I, Xah Lee, is the epitome of the lonely genius. Sad, but true.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Janis Dzerins <·····@latnet.lv>
> Organization: SIA Latnet Serviss
> Newsgroups: comp.lang.lisp
> Date: 22 Feb 2001 13:23:50 +0200
> Subject: Re: Perl becoming Lispier
Daniel Barlow <···@noetbook.telent.net> writes:
> Christopher C Stacy <······@world.std.com> writes:
>
> > >>>>> On Wed, 21 Feb 2001 07:18:07 GMT, David Bakhash ("David") writes:
> > David> but remember that these are hackers who are developing a
> > David> language mostly for hacking solutions. If you accept it
> > David> as that, then it's not nearly as bad.
> >
> > I remember when "hackers" and "hacking" did not connote negative
> > qualities. It sounds like you're trying to say something about
> > the problem domain that most Perl library programmers are
> > addressing, but I am not sure what.
>
> Ah, I read "hacking" as a verb, not an adjective. Perl is used by
> pragmatic solution-oriented people - it lays much value on solving
> the problem at hand, and less on "elegance" or "cleanliness". "The
> right way to do it is whichever way gets your job done"
That's nothing new (as we all know):
The superior man understands what is right; the inferior man
understands what will sell. -- Confucius
--
Janis Dzerins
If million people say a stupid thing it's still a stupid thing.
From: David Bakhash <·····@alum.mit.edu>
> I don't know if I would transfer the stupidity of Wall's statement
> onto all of Perl. It is a language with a mission, and it has
> successfully helped programmers solve that mission.
You mean the mission to fuck up education, right?
Yes, i admit it's fairly successful.
> This whole thing about attributing (or blaming) one guy (Wall) for
> Perl reminds me of the American obsession with the MVP concept -- that
> there's always one person behind it all, and we make that person into
> a god (or scapegoat or whatever).
Like, Adolf Hitler being blamed for World War II and other things, right? I
agree. We should blame the German soldiers, and actually, German people.
Also, in particular, the Jews, the root of the problem. If US would have
started a programme to exterminate both Germans and Jews, we'd have less
population problems, to say nothing but the least.
> Perl is a major effort by tons of
> people who work towards making it useful and functional. They do seem
> to spend more time on libraries rather than fixing the syntax of the
> language, but remember that these are hackers who are developing a
> language mostly for hacking solutions.
uhh... WHAT is your point or relevance anyway???
(and, i thought we are talking about WW II and Silence of the Lamb...)
> If you accept it as that, then
> it's not nearly as bad. If you program in Perl and constrain yourself
> to certain coding standards and rules, then it becomes a useful tool
> for creating maintainable code.
ah, YES! If you cultivate your shit like Larry Wall does, it'll become
useful too. I'd say we start a bonsai shit fad, where you shit into shaped
boxes and let dry and appreciate the art of shaping shit.
> Now, at the same time, despite my comfort with Perl's syntax, I do
> believe that making any derogatory statement about Common Lisp syntax
> is absurd.
what a sage you are, humbly endowing us with pearls of wisdom.
> Consider that part of Perl's code parser is a
> disambiguator. As bad as, say, the LOOP macro might be, Perl is worse
> both on a character _and_ token basis.
You ingested tooo much of Wall's shit, pal. If you don't plan to become a
social scholar, i suggest you spent your time on computing text books
instead. Say, perhaps study and write a paper on parsers, and maybe then
critics will appreciate.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: David Bakhash <·····@alum.mit.edu>
> Organization: EarthLink Inc. -- http://www.EarthLink.net
> Newsgroups: comp.lang.lisp
> Date: Wed, 21 Feb 2001 07:18:07 GMT
> Subject: Re: Perl becoming Lispier
>>>>> "Xah" == Xah Lee <···@xahlee.org> writes:
Xah> uhh... WHAT is your point or relevance anyway??? (and, i
Xah> thought we are talking about WW II and Silence of the Lamb...)
I grow weary of your pathetic diatribes.
Throughout this whole thread, you have yet to write anything the least
bit productive. You exist but to rag on Perl, Larry, Lincoln, and
others. If indeed Common Lisp is so darned useful and superior to
Perl, why don't you prove it by writing Common Lisp code that will
help people get their jobs done quickly?
The fact of the matter is that the Common Lisp community can learn
quite a bit from the Perl community. For all of our squealing about
the ugliness of Perl, we don't have anything remotely like CPAN. We
spend a lot of time writing and maintaining things that have been
written Once And For All in Perl, letting Perl programmers get real
work done without having to think about RFC 821 every time they want
to send a piece of email from a program. You don't have to like it,
but refusing to admit it is only going to make you look like a nitwit.
You succeed in changing no one's opinion, convincing anyone that he's
better off writing things in Common Lisp than Perl, or helping anyone
become a happy and productive Lisp programmer. You succeed only in
winding up in my killfile.
Congratulations.
*plonk*
--
Matt Curtin, Founder Interhack Corporation http://www.interhack.net/
"Building the Internet, Securely." research | development | consulting
>>>>> "Xah" == Xah Lee <···@xahlee.org> writes:
Xah> uhh... WHAT is your point or relevance anyway??? (and, i
Xah> thought we are talking about WW II and Silence of the Lamb...)
I grow weary of your pathetic diatribes.
Throughout this whole thread, you have yet to write anything the least
bit productive. You exist but to rag on Perl, Larry, Lincoln, and
others. If indeed Common Lisp is so darned useful and superior to
Perl, why don't you prove it by writing Common Lisp code that will
help people get their jobs done quickly?
The fact of the matter is that the Common Lisp community can learn
quite a bit from the Perl community. For all of our squealing about
the ugliness of Perl, we don't have anything remotely like CPAN. We
spend a lot of time writing and maintaining things that have been
written Once And For All in Perl, letting Perl programmers get real
work done without having to think about RFC 821 every time they want
to send a piece of email from a program. You don't have to like it,
but refusing to admit it is only going to make you look like a nitwit.
You succeed in changing no one's opinion, convincing no one that he's
better off writing things in Common Lisp than Perl, and helping no one
become a happy and productive Lisp programmer. You succeed only in
winding up in my killfile.
Congratulations.
*plonk*
--
Matt Curtin, Founder Interhack Corporation http://www.interhack.net/
"Building the Internet, Securely." research | development | consulting
Dear Matt Curtin,
I thought you are another absolute moron popping out of the
populace. I, being an attentive person, went to google.com and found
your website (feeling lucky). It turns out, that you are a college teacher
teaching computer programing. Education is a good thing. So, I decided to
spend some of my time here to show you the errors of your ways in some
detail, hoping that you can do a better job of thinking, and in turn
teaching.
You wrote:
> I grow weary of your pathetic diatribes.
> Throughout this whole thread, you have yet to
>write anything the least bit productive.
>You exist but to rag on Perl, Larry, Lincoln, and
> others.
If you want to complain, criticize, or ridicule me, you should do a
good job. You should explain what you mean by _my writings are not
productive_, and the ways you believe how my writings are not
productive.
> If indeed Common Lisp is so darned useful and superior to
> Perl, why don't you prove it by writing Common Lisp code that will
> help people get their jobs done quickly?
So you believe my writings are not productive because i ridiculed Perl but
have not given any Common Lisp codes?
Also, we are assuming that newsgroups posts must be "productive", is that
right?
Or, you complain that my writing suggested that i'm doing productive things
but in fact not?
In any case, is your post productive by your own judgement?
Perhaps, you are simply here to ridicule me because you violently disagree
with me. That's ok, because that's part of being a human, and what human
beings do. in English we have quite a lot words for such activity, lampoon,
satire, parody, mockery, spoof, farce, caricature, burlesque... etc and etc.
See britanica.com for a detailed explanation on the history, development,
genre, context, classification, etc of these activities. However, when these
things are done cheaply, as by a bozo from the street, we have also lots of
terms to describe it: drivel, slobber, potshot, blather, bilge, claptrap,
blarney, rubbish, humbug etc.
> The fact of the matter is that the Common Lisp community can learn
> quite a bit from the Perl community. For all of our squealing about
> the ugliness of Perl, we don't have anything remotely like CPAN. We
> spend a lot of time writing and maintaining things that have been
> written Once And For All in Perl, letting Perl programmers get real
> work done without having to think about RFC 821 every time they want
> to send a piece of email from a program. You don't have to like it,
> but refusing to admit it is only going to make you look like a nitwit.
Matt, when you want to make a fool of someone, you need to focus and be
clear. You want to address one specific thing at a time,
and make your ridicule convincing, if not funny.
In your paragraph above, you ramble and touch on lots of
things. A fusillade of potshots, both at Common Lisp community
and at Xah Lee. (you know the definition of potshot, do you? dictionary.com)
Would you like to rewrite your complaint, so that there is one or two
main points that i or other people can agree or refute?
Based on your paragraph, i think you are saying one or more of the
following:
* Common Lisp community has a lot to learn from Perl community.
* Common Lisp community do not have a centralized archive of codes
comparable to Perl community's CPAN. (CPAN = "Comprehensive Perl Archive
Network")
* Perl community's code archive (CPAN) is immensely useful, in quantity and
quality, far beyond programs one can find in Common Lisp community.
* It is hard for Common Lispers to be productive in comparison to Perlers
because lack of big library archive like Perl does.
or,
* If you (Xah Lee) refuse to admit Perl and CPAN's usefulness, then you are
really a fool.
You need to refine and make you proposal definitive, and then give your
support. Once you have decided what exactly you like to say, i shall proceed
to show in great detail what a lackluster hacker you are.
> You succeed in changing no one's opinion, convincing anyone that he's
> better off writing things in Common Lisp than Perl, or helping anyone
> become a happy and productive Lisp programmer. You succeed only in
> winding up in my killfile.
>
> Congratulations.
>
> *plonk*
My dear readers, the above is one of the most irresponsible behavior in
newsgroups. It's like dropping off some serious gas in a city, then heading
towards airport to some remote island. If Xah is such a big inane puffer,
why would he provoke Xah and leave? Has he not compassion for his fellow
beings who will be suffering from the ensuring diatribe?
I have written an account on the harm of killfilers.
Since it's not on google.com's archive now, i'm pasting it below my sig.
By the way, Matt Curtin is a Perl and Bible advocate. Apparently, his big
toe has been stepped on, no wonder the incoherent cries. However, my readers
please understand, it is not my intention to ridicule morons to death.
Everyone do or say stupid thing in areas they are not familiar with. Life
and learning are pitifully finite, and one can only know so narrow and so
little things in the sea of human affairs. A mathematician, for instance,
may write utterly stupid code. A. Einstein, may make false comments about
world history. A computer programing teacher, for instance, may make stupid
observations in social aspects of programing languages and culture. And,
Common Lisp programers, will indeed make lots of utterly stupid commentaries
in social sciences, linguistics, English, logic, Scheme, ... so on and so
forth. The smart thing to do is to reserve your opinions in proportion to
what you really know well. Matt Curtin's error, is he didn't shut his beer
hole when he should.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Matt Curtin <········@interhack.net>
> Organization: Interhack Corporation
> Newsgroups: comp.lang.lisp
> Date: 03 Mar 2001 16:58:27 -0500
> Subject: Re: Perl becoming Lispier
--------------------------------------------------------
Date: Sat, 26 Feb 2000 03:49:09 -0800
Subject: Re: Erik Naggum fan club
From: Xah <···@xahlee.org>
Newsgroups: comp.lang.lisp
Message-ID: <·················@xahlee.org>
...
*** Killfile Considered Harmful ***
In newsgroups, killfile is a playful word meaning that the poster has placed
someone in a blacklist of authors, where their postings will be
automatically hidden from view in their newsreader. Such functionality of
newsreaders originated in unix. In the early 90s or before, it used to be
referred to as "sending someone into /dev/null", because '/dev/null' can be
used as a way for deleting email program outputs.
The killfile behavior, is simply put: "sweep-under-the-rug",
"bury-head-in-sand" kind of behavior. Imagine that in a gathering where if
everyone totally ignores other's voices except their own kind, then what
cacophony would result? Similarly, if we ignore the problem of crime by
simply using larger locks for our own doors, what consequence would result?
We are all human beings. Our surroundings are our organs and affects us
dearly. In newsgroups, inevitably there will be certain individuals with
foul breath at times. Killfile mechanism is a very good feature to battle
such annoyances. This is not a reason for falling for the convenience of
blocking your ears from dissenting voices or the nonconformists.
The worst thing i hate about it, is the broadcasting of someone being
killfiled. Oftentimes the sole content of a message is "You've been
killfiled". WHAT GOOD DOES IT DO TO THE COMMUNITY BY SUCH ANNOUNCEMENT? Is
it a warning system for fellow readers to prepare to follow suit? Or is it a
stupid self-righteous act? In the course of an unpleasant encountering, the
killfilers feel the other party being unworthy of further response but they
don't want to be seen as chickening out so they had to announce it as if
saying: "Hello world: you don't see a returning 'fuck you' from me because
_I_ am _smarter_ and took a step ahead of my antagonist and covered my ears,
not because he is correct or anything like that.". Pride is a human nature,
but unqualified conceit is despicable.
A second motivation for announcing killfile is more explicitly juvenile.
Killfile has several variant names:
"You've been killfiled." (etymology anyone?)
"plonk" (sound of falling object)
"I've send you to /dev/null" (unixism)
and creativity does not seems to cease there, e.g. in comp.lang.lisp:
> (plonk 'xah)
or signatures that reads
"in /dev/null, they can't hear you scream."
The reason of these playful variations is precisely literary folly. The
utterer delights in its use since most are wanting of genuine literary
artistry. This adds to the fashion of killfile and its broadcasting.
Killfile behavior and broadcasting have another curious trait: No burden of
commitment. One cannot really tell if the person really did the killfile.
The decision to make a killfile cry in public does not carry any weight of
responsibility as compared to making a claim, stating a "fact", or
expression an opinion. It is simply a variation of "fuck you". This too,
contributed to its uncontrolled popularity.
...
>>>>> "Xah" == Xah Lee <···@xahlee.org> writes:
Xah> In any case, is your post productive by your own judgement?
No. Which is why I'm not devoting any more of my energy to this
thread.
(It might be interesting that I used "killfile" in a very loose sense;
I actually use scoring and not killing, which generally means that
I'll see followups to my posts from someone who has a very negative
score.)
--
Matt Curtin, Founder Interhack Corporation http://www.interhack.net/
"Building the Internet, Securely." research | development | consulting
Matt Curtin <········@interhack.net> writes:
> The fact of the matter is that the Common Lisp community can learn
> quite a bit from the Perl community.
Probably true, but not in the way you think.
> We spend a lot of time writing and maintaining things that have been
> written Once And For All in Perl, letting Perl programmers get real
> work done without having to think about RFC 821 every time they want
> to send a piece of email from a program.
I have seen RFC 821 handling written Once and For All in Perl so many
times that I think Perl hackers know it by heart. It also seems that
most perl scripts that attempt to manipulate mail have put no thought
whatsoever into RFC 821.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall <···@content-integrity.com> wrote:
> Matt Curtin <········@interhack.net> writes:
> ...
>
>> We spend a lot of time writing and maintaining things that have been
>> written Once And For All in Perl, letting Perl programmers get real
>> work done without having to think about RFC 821 every time they want
>> to send a piece of email from a program.
>
> I have seen RFC 821 handling written Once and For All in Perl so many
> times that I think Perl hackers know it by heart. It also seems that
> most perl scripts that attempt to manipulate mail have put no thought
> whatsoever into RFC 821.
Good point Joe. Allow me to clarify a few things for the Common Reader.
The title for Really Fucking Common, number 821 is: SIMPLE MAIL TRANSFER
PROTOCOL. In other words, it's the hodgepodge specification that describes a
pop email protocol. Unix folks love RFCs and love to chant RFCs. Their
slobbering mouth couldn't simply say mail protocol, hypertext protocol, etc,
but had to say Really Fucking Common Number X. They let RFCs dribble from
their tongue as if it's the sweetest poem. Don't believe me? Mark your
calendar: "Verify Xah's claim about RFC as Unixers' drivel" and observe. Go
read newsgroup archives. You'll notice there is a correlation between the
love of reciting the term and being a unix fan. It would take a full post or
a book to justify an exposition of it in front of an unix crowd, but i can
give you a synopsis below.
The unix loving folks, are often puerile and incapable of great
accomplishments. They love and dabble in literature and computing, but lack
the muse and brain. They love obfuscation, not the abstruse and recondite
types in mathematics or literature, but the confounding and incomprehensible
types in labyrinth and disaster. Saying Mail Protocol would be _so_ not hip.
Saying "RFC 821", would be so educated and sophisticated. The unix folks
couldn't care less about those formal, child-proof, real arcane stuff like
lambda calculus, set theory, graph theory, algorithms etc. Larry Wall, is a
good example of the unix fanatic.
Sorry i digressed. I meant to talk about Perl mail modules. I _personally_
know of three:
* Mail::Mailer. Mentioned in most Perl books. Written or maintained by
Graham Barr.
* Mail::Send, maintained by Graham Barr <·····@pobox.com>, originally
written by Tim Bunce.
* Mail::Sendmail by Milivoj Ivkovic.
The first two has glaring problems. I'm sorry i forgot what they are. I
think Mail::Mailer has a bug on the from field. i.e. it ignores what you
gave. I'm currently using Mail::Sendmail, and according to a ex-colleague,
it has problems with some DNS mail exchange entries. (i don't know what that
is...)
for some discussion of the plethora of Perl mail modules and their
short-cummings, see http://alma.ch/perl/mail.htm.
--
Commoners often have problems appreciating the greatest art, just like empty
headed people will often say Xah's writings' empty of content. I like to
help them out. In this very message, there are two verifiable claims. The
lousy state of email modules in Perl is easily verified by anyone who knows
Perl and Email protocol a bit. The other claim, on the correlation of unixer
and the love to chant RFC, can be verified by statistics. Failing short of
that, observation. Besides verifiable claims of facts, there is beauty. I'll
leave that to your eyes.
PS here's bonus: RFC 1149:
http://src.doc.ic.ac.uk/computing/internet/rfc/rfc1149.txt
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Joe Marshall <···@content-integrity.com>
> Organization: Newsfeeds.com
> Newsgroups: comp.lang.lisp
> Date: 05 Mar 2001 10:09:31 -0500
> Subject: Re: Perl becoming Lispier
Xah Lee <···@xahlee.org> writes:
> The title for Really Fucking Common, number 821 is: SIMPLE MAIL
> TRANSFER PROTOCOL. In other words, it's the hodgepodge specification
> that describes a pop email protocol.
Your translation is flawed. Again.
--
Janis Dzerins
If million people say a stupid thing it's still a stupid thing.
On Wed, 21 Feb 2001 07:18:07 GMT, David Bakhash <·····@alum.mit.edu> wrote:
> This whole thing about attributing (or blaming) one guy (Wall) for
> Perl reminds me of the American obsession with the MVP concept -- that
> there's always one person behind it all, and we make that person into
> a god (or scapegoat or whatever). Perl is a major effort by tons of
> people who work towards making it useful and functional. They do seem
> to spend more time on libraries rather than fixing the syntax of the
> language,
And that's the point. Larry Wall wrote Perl "The Language" himself as part
of a distributed configuration management project he was tasked with. At
the time he said he "knew just enough Lisp to be dangerous". The Perl
libraries have been written by many people since then. So I think you can
pin the Perl language on him if you want to.
Personally, I occasionally find Perl a useful amalgam, but wish it had a
better foundation.
__Jason
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
> honor. But perhaps it helps to remind people that Scheme is not Lisp.
What is an appropriate definition of "Lisp"? For the less experienced, Lisp
is a family of languages that use a simple syntax of nested parenthetic
expressions. But syntax is probably not the most essential characteristic
to look at when classifying a language as a Lisp. So what qualities does
Scheme lack to exclude if from the label of a "Lisp"?
In article <·····················@newsread2.prod.itd.earthlink.net>,
news.earthlink.net <········@earthlink.net> wrote:
>
>What is an appropriate definition of "Lisp"? For the less experienced, Lisp
>is a family of languages that use a simple syntax of nested parenthetic
>expressions. But syntax is probably not the most essential characteristic
>to look at when classifying a language as a Lisp. So what qualities does
>Scheme lack to exclude if from the label of a "Lisp"?
Nothing. As Kent Pitman et al say in the R5RS,
Scheme is a dialect of Lisp.
····@goldshoe.gte.com (Dorai Sitaram) writes:
> >What is an appropriate definition of "Lisp"? For the less experienced, Lisp
> >is a family of languages that use a simple syntax of nested parenthetic
> >expressions. But syntax is probably not the most essential characteristic
> >to look at when classifying a language as a Lisp. So what qualities does
> >Scheme lack to exclude if from the label of a "Lisp"?
>
> Nothing. As Kent Pitman et al say in the R5RS,
> Scheme is a dialect of Lisp.
It's not important. Who cares? it's just a definition; a
classification, if you will.
Common Lisp is what it is, and Scheme is what it is. How similar
people find them to be to each other is their business. I find them
to be vastly different, and don't care so much that some people would
consider Scheme to be Lisp and others not; it *is* upsetting that
people who see Scheme might clump Common Lisp with it. That, to me,
is a shame, as Scheme is an annoying pestilence, Lisp dialect or not.
dave
From: David Bakhash <·····@alum.mit.edu>
> It's not important. Who cares? it's just a definition; a
> classification, if you will.
>
> Common Lisp is what it is, and Scheme is what it is. How similar
> people find them to be to each other is their business. I find them
> to be vastly different, and don't care so much that some people would
> consider Scheme to be Lisp and others not; it *is* upsetting that
> people who see Scheme might clump Common Lisp with it. That, to me,
> is a shame, as Scheme is an annoying pestilence, Lisp dialect or not.
Dear Dumb person,
please understand the question at hand is whether Scheme is a lisp, not
people's views and attitudes and your fucking moronic opinion of them.
when's Scheme not lisp? When our community admits that Perl is not a
computer language, and when pigs fly.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: David Bakhash <·····@alum.mit.edu>
> Organization: EarthLink Inc. -- http://www.EarthLink.net
> Newsgroups: comp.lang.lisp
> Date: Wed, 21 Feb 2001 23:01:48 GMT
> Subject: Re: Perl becoming Lispier
"David Bakhash" <·····@alum.mit.edu> wrote in message
···················@cadet.dsl.speakeasy.net...
> ····@goldshoe.gte.com (Dorai Sitaram) writes:
> It's not important. Who cares? it's just a definition; a
> classification, if you will.
You sound like you think definitions don't matter. They do. A
definition helps solve several important problems, one being that a
definition will help clarify the boundaries of a concept. If Scheme
is not a Lisp, I thought, then what is a Lisp, am I missing something
here?
If I were to tell you that the extension language of some new text
editor is a Lisp, what could you conclude about that extension
language? If you've formed the concept properly using induction, then
you'll know that the language does list processing, that the syntax is
expressed as lists, and that the language doesn't require
declarations. You'll also know characteristics unessential to the
concept are unspecified--omitted--so you'd know further investigation
was required to know about them. The language may have dynamic
scoping or lexical scoping. There might be one namespace or several.
It may use normal-order evaluation or applicative order evaluation. It
may even have a few overall design flaws that make it useless for many
tasks. These and other characteristics are unessential to the concept
because the purpose of the concept is to differentiate programming
languages based on their syntax. If McCarthy would have stuck with
M-expressions, which were intended to resemble FORTRAN as much as
possible, I think there would be no general concept of Lisp. The term
"Lisp" would be a proper noun that refers to another dead list
processing language like FLPL ... FORTRAN List Processing Language.
"news.earthlink.net" <········@earthlink.net> writes:
> If I were to tell you that the extension language of some new text
> editor is a Lisp, what could you conclude about that extension
> language? If you've formed the concept properly using induction, then
> you'll know that the language does list processing, that the syntax is
> expressed as lists, and that the language doesn't require
> declarations.
Just to be bloody minded: list processing is obviously a
characteristic of Lisp but hardly a unique one any more. The syntax
of scheme is actually *not* defined in terms of lists, or at least was
not last time I looked. Common Lisp has at least one declaration
(special) which makes a semantic difference to the code.
--tim
"Tim Bradshaw" <···@tfeb.org> wrote in message
····················@tfeb.org...
>
> Just to be bloody minded: list processing is obviously a
> characteristic of Lisp but hardly a unique one any more. The syntax
> of scheme is actually *not* defined in terms of lists, or at least was
> not last time I looked. Common Lisp has at least one declaration
> (special) which makes a semantic difference to the code.
>
> --tim
I'm not sure I understand what you mean when you say scheme
syntax is *not* defined in terms of lists. Isn't '(+ 1 2 3) a list?
Is there, or will there ever be, a language that is a Lisp that can't
readily express something like the following? Or is there a programming
language that is not a Lisp that can readily express this idea?
(define (my-eval expr env)
(if (eq? (car expr) 'if*)
(eval (if*-transform expr) env)
(eval expr env)))
(define (if*-transform expr)
(list 'if (cadr expr)
(caddr expr)
(cons 'begin (cdddr expr))))
(my-eval '(if* #f
nil
(newline)
(display "way")
(newline)
(display "to")
(newline)
(display "go"))
(the-environment))
"news.earthlink.net" <········@earthlink.net> writes:
> "Tim Bradshaw" <···@tfeb.org> wrote in message
> ····················@tfeb.org...
> >
> > Just to be bloody minded: list processing is obviously a
> > characteristic of Lisp but hardly a unique one any more. The syntax
> > of scheme is actually *not* defined in terms of lists, or at least was
> > not last time I looked. Common Lisp has at least one declaration
> > (special) which makes a semantic difference to the code.
> >
> > --tim
>
> I'm not sure I understand what you mean when you say scheme
> syntax is *not* defined in terms of lists. Isn't '(+ 1 2 3) a list?
Yes. So is (+ 1 2 . (3)), which is not valid as code in Scheme[1].
Christophe
[1] According to RnRS, anyway. Many implementations seem to let it
pass, so it's in the "unportable, but probably OK" category. I believe
that the view in the Scheme community is that this is probably a bug
in the spec.
--
Jesus College, Cambridge, CB5 8BL +44 1223 524 842
(FORMAT T "(·@{~w ········@{~w~^ ~})" 'FORMAT T "(·@{~w ········@{~w~^ ~})")
Christophe Rhodes <·····@cam.ac.uk> writes:
>
> Yes. So is (+ 1 2 . (3)), which is not valid as code in Scheme[1].
>
This is precisely my point! This *is* valid in CL because CL is
defined in terms or using READ to read things and then evaluationg
them whereas scheme is not defined like that. That same thing lets
#{_ "~{~A~^ ~}" '(x y z)}
be legal CL syntax with a suitably mutant readtable.
--tim
Tim Bradshaw <···@tfeb.org> writes:
> #{_ "~{~A~^ ~}" '(x y z)}
>
> be legal CL syntax with a suitably mutant readtable.
You mean you were serious about that format suggestion?!
Ah, yes. Must construct a new ~/.signature. This one's pass�. Is there
any other language feature that I can abuse in four lines of code
quite as badly?
Christophe
--
Jesus College, Cambridge, CB5 8BL +44 1223 524 842
(FORMAT T "(·@{~w ········@{~w~^ ~})" 'FORMAT T "(·@{~w ········@{~w~^ ~})")
Christophe Rhodes <·····@cam.ac.uk> writes:
> You mean you were serious about that format suggestion?!
>
An implementation exists, yes. I like to use it with the
`message-passing' CL syntax, so you can write:
[[['(1 2 3) x]] let
["about to print something" print]
{^ "~{~A~^ ~}" x}]
I find this much clearer than ordinary CL syntax, which is completely
unreadable as everyone knows. The message-passing syntax is
particularly good with LOOP:
[for loop x from 1 to 10
do [x print]]
--tim, for the language impurity society
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
> * <········@earthlink.net>
> > I'm not sure I understand what you mean when you say scheme
> > syntax is *not* defined in terms of lists. Isn't '(+ 1 2 3) a list?
>
> NO! (+ 1 2 3) is a sequence of characters, which, when read by the Lisp
> function read, produces a list. The Scheme syntax is defined on the
> sequence of characters, while other Lisps are defined on the results of
> applying read to the sequence of characters, i.e., Lisp objects -- an
> important difference with far-reaching consequences. A Scheme compiler
> may be built with Algol-style parsers and expression trees and all that
> stuff without ever having seen any Lisp objects. This is why it is an
> Algol derivative, and not a Lisp. A Lisp is a language whose programs
> are represented _in_ the language. Yes, this is syntax. Happy, now?
Pardon me if I am being too dense here. It seems to me that (+ 1 2 3) is
also a sequence of character which, when read by the _Scheme_ function read,
produces a list. And while the formal syntax in RnRS allows a compiler to be
written that never looks at Lisp objects, it also allows a compiler to be
written which deals with "the results of applying read to the sequence of
characters". So if a language with Scheme's semantics is written in this
way, is it then a Scheme which is a member of the Lisp family? Or am I
missing something?
Thank you,
Joe
"Joseph Dale" <········@home.com> writes:
> "Erik Naggum" <····@naggum.net> wrote in message
> ·····················@naggum.net...
> > * <········@earthlink.net>
> > > I'm not sure I understand what you mean when you say scheme
> > > syntax is *not* defined in terms of lists. Isn't '(+ 1 2 3) a list?
> >
> > NO! (+ 1 2 3) is a sequence of characters, which, when read by the Lisp
> > function read, produces a list. The Scheme syntax is defined on the
> > sequence of characters, while other Lisps are defined on the results of
> > applying read to the sequence of characters, i.e., Lisp objects -- an
> > important difference with far-reaching consequences. A Scheme compiler
> > may be built with Algol-style parsers and expression trees and all that
> > stuff without ever having seen any Lisp objects. This is why it is an
> > Algol derivative, and not a Lisp. A Lisp is a language whose programs
> > are represented _in_ the language. Yes, this is syntax. Happy, now?
>
> Pardon me if I am being too dense here. It seems to me that (+ 1 2 3) is
> also a sequence of character which, when read by the _Scheme_ function read,
> produces a list. And while the formal syntax in RnRS allows a compiler to be
> written that never looks at Lisp objects, it also allows a compiler to be
> written which deals with "the results of applying read to the sequence of
> characters". So if a language with Scheme's semantics is written in this
> way, is it then a Scheme which is a member of the Lisp family? Or am I
> missing something?
Yes, you're missing the fact that since the formal syntax is in terms of
text objects, it does not allow the compiler to compile conses/lists.
If I do (list '+ '1 '2 '3) I get an object which has no semantics in the
Scheme spec.
This is particularly important when it comes to the treatment of gensyms,
since the notion of a gensym is that it looks like another symbol but is
not equal. So even if you allowed for print to print something back out
in order to compile it, the semantics doesn't accomodate the printing out
of gensyms in a meaningful way that would preserve their would-be semantics
according to the intuitive but wholly imagined model that you probably have.
Erik's point is quite legitimate here. Incidentally, I have complained
about this at Scheme design meetings in the distant past, when we used to
have them. This is not an oversight but quite a deliberate decision.
Kent M Pitman <······@world.std.com> writes:
> "Joseph Dale" <········@home.com> writes:
>
> > "Erik Naggum" <····@naggum.net> wrote in message
> > ·····················@naggum.net...
> > > * <········@earthlink.net>
> > > > I'm not sure I understand what you mean when you say scheme
> > > > syntax is *not* defined in terms of lists. Isn't '(+ 1 2 3) a list?
> > >
> > > NO! (+ 1 2 3) is a sequence of characters, which, when read by the Lisp
> > > function read, produces a list.
> >
> > Pardon me if I am being too dense here. It seems to me that (+ 1 2 3) is
> > also a sequence of character which, when read by the _Scheme_ function read,
> > produces a list. Or am I missing something?
>
> Yes, you're missing the fact that since the formal syntax is in terms of
> text objects, it does not allow the compiler to compile conses/lists.
> If I do (list '+ '1 '2 '3) I get an object which has no semantics in the
> Scheme spec.
This isn't true.
Aside from the fact that lists do have meaning as lists, section 1.2
states:
``the EVAL procedure evaluates a Scheme program expressed as data.''
this provides the semantic mapping from structured data to
expressions. (Obviously, if you don't use EVAL, you can assign
whatever semantics you wish to that list of four elements, but I think
it is understood that we're talking about the sematics provided by
EVAL.)
Since RnRS doesn't say anything about the compiler, it also doesn't
prohibit the compiler to compile conses/lists.
R5RS says in section 3.3
``Scheme's syntax ... facilitates writing programs such as
interpreters and compilers that treat programs as data (or vice
versa).''
in section 1.2
``The grammer of Scheme generates a sublanguage of the language used
for data. An important consequence of this ... is the susceptibility
of Scheme programs and data to uniform treatment by other Scheme
programs.''
These quotes clearly indicate that it is intended that the list of
four elements (+ 1 2 3) may be treated as an expression.
Note this as well: All of section 4.3 (how macros work) is defined in
terms of manipulation of list structure. Macros accept <datum>
(lists) and output subforms of that <datum>. Therefore, a Scheme
compiler or interpreter *must* be able to map conses and lists to the
obvious expressions they stand for (otherwise, the Scheme compiler
could not compile derived expressions, and therefore would not be
Scheme.)
All scheme programs have a printed representation. For some reason,
this leads people to the bizarre conclusion that scheme semantics are
defined solely upon this printed representation.
Scheme doesn't explicitly *require* that an implementation use READ in
order to convert source files into an executable format. Many people
seem to think that this *prohibits* using READ to read code. This is
not true. Everywhere in the Scheme report is the *implicit*
requirement that whatever method is used to parse source code, it must
produce a result equivalent to calling READ upon that source code.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
"David Bakhash" <·····@alum.mit.edu> wrote in message
···················@cadet.dsl.speakeasy.net...
> ····@goldshoe.gte.com (Dorai Sitaram) writes:
>
> It's not important. Who cares? it's just a definition; a
> classification, if you will.
>
You sound like you think definitions don't matter. They do. A
definition helps solve several important problems, one being that a
definition will help clarify the boundaries of a concept. "If Scheme
is not a Lisp," I thought, "then what is a Lisp, am I missing something
here?"
If I were to tell you that the extension language of some new text
editor is a Lisp, what could you conclude about that extension
language? If you've formed the concept properly using induction, then
you'll know that the language does list processing, that the syntax is
expressed as lists, and that the language doesn't require
declarations. You'll also know characteristics unessential to the
concept are unspecified--omitted--so you'd know further investigation
was required to know about them. The language may have dynamic
scoping or lexical scoping. There might be one namespace or several.
It may use normal-order evaluation or applicative order evaluation. It
may even have a few overall design flaws that make it useless for many
tasks. These and other characteristics are unessential to the concept
because the purpose of the concept is to differentiate programming
languages based on their syntax. If McCarthy would have stuck with
M-expressions, which were intended to resemble FORTRAN as much as
possible, I think there would be no general concept of Lisp. The term
"Lisp" would be a proper noun that refers to another dead list
processing language like FLPL--FORTRAN List Processing Language.
> What is an appropriate definition of "Lisp"? For the less experienced, Lisp
> is a family of languages that use a simple syntax of nested parenthetic
> expressions. But syntax is probably not the most essential characteristic
> to look at when classifying a language as a Lisp. So what qualities does
> Scheme lack to exclude if from the label of a "Lisp"?
Syntax is important. It's so important that a language is nothing but syntax
_alone_.
Think of it this way: all programing languages are pretty much so called
Tuning equivalent. i.e. you can program anything in any generic languages.
So, what's the diff? The diff then lies purely in how the program looks.
And, that's syntax. This is a simple observation, but i guffaw that the vast
majority of monkey coders cannot see this, and never will.
If you have studied the history of math notations, you'll know that the
significance of notation is not merely in their prettiness or convenience,
but have in fact catapult the speed of progress in math, and launched new
ideas, methodologies, and philosophies in core mathematics _caused_ by
syntaxes. (e.g. matrixes, formalism.)
"Erik Naggum" <····@naggum.net> wrote:
>But perhaps it helps to remind people that Scheme is not Lisp.
Yeah, we all know Erik got problems with Scheme. We can ignore him on this
one.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: "news.earthlink.net" <········@earthlink.net>
> Organization: EarthLink Inc. -- http://www.EarthLink.net
> Newsgroups: comp.lang.lisp
> Date: Wed, 21 Feb 2001 16:37:46 GMT
> Subject: Re: Perl becoming Lispier
>>>>"XL" == Xah Lee schrieb am Thu, 22 Feb 2001 00:47:40 GMT:
XL> Think of it this way: all programing languages are pretty much so
XL> called Tuning equivalent. i.e. you can program anything in any
XL> generic languages. So, what's the diff? The diff then lies
XL> purely in how the program looks. And, that's syntax.
I disagree. It is not *only* syntax. A language does not only consist
of a EBNF specification. The difference you encounter between a Scheme
and a CL programm are mostly _not_ due to syntax, but to the
language-constructs that are _specified for the language_. This, of
course, does not touch the issue of turing equivalence, but the issue
of how complex your programs will look because of what kind of
constructs the language offers or doesn't.
Whether the constructs in CL are superior to Scheme may be a matter of
debate, at least outside of c.l.l.
[Pointless rumbling deleted]
Holger
--
--- http://www.coling.uni-freiburg.de/~schauer/ ---
"I mean, the bazaar I don't mind, but the bizarre I have problems with."
-- Russell Marks in comp.os.linux.announce
Holger Schauer,
Your brain is not good enough for me to converse with. How do I know? Look
at this:
you wrote:
> [Pointless rumbling deleted]
which points to the following paragraph i wrote:
> If you have studied the history of math notations, you'll know that the
> significance of notation is not merely in their prettiness or convenience,
> but have in fact catapult the speed of progress in math, and launched new
> ideas, methodologies, and philosophies in core mathematics _caused_ by
> syntaxes. (e.g. matrixes, formalism.)
Run to your library, and check out:
_Mathematical thought from ancient to modern times_ by Morris Kline, V.2,
Ch.33 Determinants and Matrices, p.795. And, Howard Eves, _An introduction
to the history of mathematics_, 6th ed., Chapter 15-8 Philosophies of
Mathematics, middle: Formalism. As examples.
Without understanding what i'm talking about here, there's no hope for you
to understand deeply the issues of syntax and semantics.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Holger Schauer <··············@gmx.de>
> Organization: Organization ? What Organization ?
> Newsgroups: comp.lang.lisp
> Date: 22 Feb 2001 09:28:54 +0100
> Subject: Re: Perl becoming Lispier
>
>>>>> "XL" == Xah Lee schrieb am Thu, 22 Feb 2001 00:47:40 GMT:
>
> XL> Think of it this way: all programing languages are pretty much so
> XL> called Tuning equivalent. i.e. you can program anything in any
> XL> generic languages. So, what's the diff? The diff then lies
> XL> purely in how the program looks. And, that's syntax.
>
> I disagree. It is not *only* syntax. A language does not only consist
> of a EBNF specification. The difference you encounter between a Scheme
> and a CL programm are mostly _not_ due to syntax, but to the
> language-constructs that are _specified for the language_. This, of
> course, does not touch the issue of turing equivalence, but the issue
> of how complex your programs will look because of what kind of
> constructs the language offers or doesn't.
>
> Whether the constructs in CL are superior to Scheme may be a matter of
> debate, at least outside of c.l.l.
>
> [Pointless rumbling deleted]
>
> Holger
>
> --
> --- http://www.coling.uni-freiburg.de/~schauer/ ---
> "I mean, the bazaar I don't mind, but the bizarre I have problems with."
> -- Russell Marks in comp.os.linux.announce
Dear Holger Schauer,
i'll elaborate my point of view for your benefit. (since i noted that you
are a graduate student in AI.)
Here's the excerpt of the Morris Kline book I cited
---
<begin quote>
33 Determinants and Matrices
Such is the advantage of a well-constructed language that its simplified
notation often becomes the source of profound theories. --P. S. Laplace
1. Introduction
Though determinants and matrices received a great deal of attention in the
nineteenth century and thousands of papers were written on these subjects
they do not constitute great innovation in mathematics. The concept of a
vector, which from the mathematical standpoint is no more than a collection
of ordered triples, nevertheless has a direct physical significance as a
force or velocity, and with it one can write down at once mathematically
what the physics states. The same applies with all the more cogency to
gradient, divergence, and curl. Likewise though mathematically dy/dx is no
more than a symbol for a lengthy expression involving the limit of �y/�x,
the derivative is in itself a powerful concept that enables us to think
directly and creatively about physical happenings. Thus though mathematics
superficially regarded is no more than a language or a shorthand, its most
vital concepts are those that supply keys to new realms of thought. By
contrast, determinants and matrices are solely innovations in language. They
are shorthand expressions for ideas which already exist in more expanded
form. In themselves they say nothing directly that is not already said by
equations or transformations albeit in lengthier fashion. Neither
determinants nor matrices have influenced deeply the course of mathematics
despite their utility as compact expressions of general theorems of group
theory. Nevertheless, both concepts have proved to be highly useful tools
and are now part of the apparatus of mathematics.
<end quote>
---
The language (i.e. notations) used in math, have significant sway in how
math grows. When math notation becomes mature enough to take the form of
symbol and formula manipulation circa 1800s (like in your highschool algebra
classes), it lead to the formalism school of thought that math is merely a
meaningless manipulation of symbols following certain rules. (btw, this is
no trivial thought.)
One can look at computer languages with the perspective of math notations.
Simple mindedly, we say that _syntaxes_ are rules that say which strings are
valid in a language. We can in fact have a precise definition of it.
However, it would be hard to formalize _semantics_. Another way to look
syntax and semantics, is that two programs in two languages that implements
the same idea will look very different not just because the rules for
putting the strings are different (narrow def of syntax), but also because
of their semantics and grammar. Looked in another way: an idea expressed in
different languages differ not because results of syntax specifications.
Given an algorithmic idea, you can express it in a variety of generic
languages. Like the various notations in the history of math, these
languages all express the same idea but differ in _nature_ and looks (i.e.
syntax, semantics, grammar, and any other unformalizable features that
capture language.). In other words, we can think of computer languages as
different notation systems for ideas of computation. When non-programer look
at printed pages of programs, this aspect is exactly what he sees.
This is what i meant when i say "syntax" is the only thing in a language,
and it is a very important perspective.
Armed with this insight, we can look at Scheme and Common Lisp, and you have
yet another reason to believe that Naggum is showcasing his garish spleen
when he insists Scheme is not a dialect of the Lisp family.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Xah Lee <···@xahlee.org>
> Organization: Verio
> Newsgroups: comp.lang.lisp
> Date: Thu, 22 Feb 2001 10:28:50 GMT
> Subject: Re: Perl becoming Lispier
>>>>"XL" == Xah Lee schrieb am Thu, 22 Feb 2001 12:50:51 GMT:
[Quote deleted]
Thanks. I knew that already, although not the particular excerpt. But
I could have given you a somewhat more elaborate quote (a complete
chapter) by Sowa in which he discusses the various notational variants
of logic systems with their respective semantics *plus* its relation
to the denotational system commonly used in music composition. So what
gives?
XL> Given an algorithmic idea, you can express it in a variety of
XL> generic languages. Like the various notations in the history of
XL> math, these languages all express the same idea but differ in
XL> _nature_ and looks (i.e. syntax, semantics, grammar, and any
XL> other unformalizable features that capture language.). In other
XL> words, we can think of computer languages as different notation
XL> systems for ideas of computation. When non-programer look at
XL> printed pages of programs, this aspect is exactly what he sees.
I agree. I was just trying to point out, that some aspects of a
language specification beyond its EBNF may have an important influence
on how an algorithmic idea may look like in different language that
even have the same EBNF --- exactly because of the different
semantics.
XL> This is what i meant when i say "syntax" is the only thing in a
XL> language, and it is a very important perspective.
Then you seem to confound syntax and semantics, despite your claim to
the contrary. Let me give you a simple example from todays standard
predicate logic: the syntax of FOL consists of a set of predicate
symbols P, a set of function symbols F, a set of individual symbols I
plus a set of operator symbols (\and, \or) and two quantifier
symbols. You also have some kind of grammar which says that operators
are infix and quantifiers occur at the beginning and tells you that
you can't combine form an expression with predicates over predicates,
etc. When it comes to semantics, you need a domain and an
interpretation function that essentially tells you how to map the
_syntactic expressions_ onto the domain. So, the point I want to make
is that the interpretation function is the crucial point: (a) it
belongs on the side of semantics and (b) different interpretation
functions may lead to different interpretations.
Now, when it comes to Scheme vs. Lisp, to many people at least here on
c.l.l., Scheme looks like propositional logic compared to the FOL of
Common Lisp. I won't make a comment on this one, as I don't know much
about Scheme, but it looks clear to me that the standard of Scheme
specifies a lot less than CL's one. To re-iterate, of course this does
not mean that you can't program in Scheme what you can in CL, but it
may be responsible for much larger programs in Scheme. And yes, of
course, both programs will capture the same algorithmic idea, but when
looking at the practical side this may be worth considering.
Holger
--
--- http://www.coling.uni-freiburg.de/~schauer/ ---
"(/ (- (f common-lisp) (f scheme)) (f C)) => float underflow"
-- <···@rebol.com> in comp.lang.lisp
Dear Holger Schauer,
you wrote:
> Thanks. I knew that already, although not the particular excerpt. But
> I could have given you a somewhat more elaborate quote (a complete
> chapter) by Sowa in which he discusses the various notational variants
> of logic systems with their respective semantics *plus* its relation
> to the denotational system commonly used in music composition. So what
> gives?
Spill your life's worth for me, will you?
why don't you explain who is Sowa? What book are you referring to?
I did some search on the web and found:
http://www.bestweb.net/~sowa/
he must be the guy. What can you say or want to say of him or his works? I
beg you to delight me.
> ...
> Then you seem to confound syntax and semantics, despite your claim to
> the contrary. Let me give you a simple example from todays standard
> predicate logic: the syntax of FOL consists of a set of predicate
> symbols P, a set of function symbols F, a set of individual symbols I
> plus a set of operator symbols (\and, \or) and two quantifier
> symbols. You also have some kind of grammar which says that operators
> are infix and quantifiers occur at the beginning and tells you that
> you can't combine form an expression with predicates over predicates,
> etc.
> When it comes to semantics, you need a domain and an
> interpretation function that essentially tells you how to map the
> _syntactic expressions_ onto the domain.
How exactly these interpretation function are defined? and how's the domain
formalized? Can you define "semantics"?
> So, the point I want to make
> is that the interpretation function is the crucial point: (a) it
> belongs on the side of semantics and (b) different interpretation
> functions may lead to different interpretations.
I can see that you are trying to make a point, but i don't really see your
point of refuting my use of the word syntax. Anyhow, perhaps you'd do us a
favor by giving a short intro of the whole syntax + semantics + grammar +
shebang? I'm really interested here, in you telling me what elements capture
language, and how you define these elements.
This is not a solved problem, but don't be shy; your account of it counts.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Holger Schauer <··············@gmx.de>
> Organization: Organization ? What Organization ?
> Newsgroups: comp.lang.lisp
> Date: 22 Feb 2001 16:41:28 +0100
> Subject: Re: Perl becoming Lispier
>>>>"XL" == Xah Lee schrieb am Fri, 23 Feb 2001 13:46:42 GMT:
XL> why don't you explain who is Sowa? What book are you referring
XL> to? I did some search on the web and found:
XL> http://www.bestweb.net/~sowa/ he must be the guy. What can you
XL> say or want to say of him or his works? I beg you to delight me.
Yes, I'm sorry. I made indirect reference to the following book: John
F. Sowa, Knowledge Representation: Logical, Philosophical, and
Computational Foundations, Brooks Cole Publishing Co., Pacific Grove,
CA, 2000. He's a pretty well known-guy when it comes to AI and
ontology.
However, I just wanted to draw a parallel between your quote and the
first chapter of the above mentioned book in order to illustrate that
you were not telling something that were new to me.
>> When it comes to semantics, you need a domain and an
>> interpretation function that essentially tells you how to map the
>> _syntactic expressions_ onto the domain.
XL> How exactly these interpretation function are defined? and how's
XL> the domain formalized? Can you define "semantics"?
/To me/ semantics is more or less the mapping of some symbols to
something else, and it is important to distinguish of what kind of
semantics we are talking here[1]. When it comes to computers and
programming languages, semantics is more or less a mapping between the
expressions that your languages allow onto, ultimately, bits and what
do with them. It is possible (to what extent I don't know) to capture
the behaviour of programs in some kinds of logics (temporal logics,
which can be seen as a kind of modal logic), which is theoretically
very interesting.
To answer your first question: the interpretation function is a simple
mathematical function, and to give but one answer to your second
question: it can be made up out of the individual symbols used. Get an
introductory book to predicate logic and search for the term "herbrand
universum". This forms the basis for the model-theoretic semantics of
(predicate) logic.
>> So, the point I want to make is that the interpretation function
>> is the crucial point: (a) it belongs on the side of semantics and
>> (b) different interpretation functions may lead to different
>> interpretations.
XL> I can see that you are trying to make a point, but i don't really
XL> see your point of refuting my use of the word syntax.
Okay. Point taken. I guess you make reference to the necessity that an
interpretation function needs to know about the syntactic elements?
IMO, this still does not make the interpretation function part of the
syntax.
XL> Anyhow, perhaps you'd do us a favor by giving a short intro of
XL> the whole syntax + semantics + grammar + shebang? I'm really
XL> interested here, in you telling me what elements capture
XL> language, and how you define these elements.
I'm not certain to which "language" you make reference here. And I'm
almost certain that if you're not talking about CL, that we're getting
off-topic. To give a CL-specific answer anyway, I would say that the
main syntax and grammar of CL could be specified in an EBNF or
something alike, excluding the domain language that you may create
with CL and use along the way. The semantics of CL are to some
extents specified by the standard ala CLHS, which for example
specifies how to evaluate a CL expression. This is, of course, not a
formal semantic. I'm not sure whether giving a formal semantics to
Scheme has been tried, but I'm quite certain that such things have
been done for other languages.
To get back on the initial topic, and to sound like an MP3-player in
recursive mode, I think that the CL standard specifies a lot more than
the Scheme one does, i.e., it assigns a semantics to constructs that
standard-conforming implementations need to follow, where the number
of pre-specified constructs in CL outnumbers the one in the Scheme
(disclaimer: I'm not a Scheme expert). This indeed makes a difference
in languages, to me beyond Syntax.
Holger
Footnotes:
[1] In Natural Language Processing, research also makes use of
model-theoretic semantics. However, as NLP is not only concerned
with machines and formalisms, the general aggreement is probably
such that the elements that make up the ``model'' necessarily
have some complements in human reality. This does not imply that
these things have a spatial- or temporal reality. E.g., it is possible
to talk about "unicorns" without having any unicorns around, or to
talk about "peace" which is a (more or less) abstract object.
--
--- http://www.coling.uni-freiburg.de/~schauer/ ---
"Nur ein vermiedener Mausklick ist ein guter Mausklick."
-- Jochem Huhmann in de.comp.os.unix.discussion
>>>>"XL" == Xah Lee schrieb am Thu, 22 Feb 2001 10:28:50 GMT:
XL> Your brain is not good enough for me to converse with. How do I
XL> know? Look at this:
>> [Pointless rumbling deleted]
XL> which points to the following paragraph i wrote:
>> If you have studied the history of math notations, [...]
No, my [Pointless rumbling deleted] pointed to
XL> Yeah, we all know Erik got problems with Scheme. We can ignore
XL> him on this one.
Sorry, I should have avoided that cause of confusion.
XL> Without understanding what i'm talking about here, there's no
XL> hope for you to understand deeply the issues of syntax and
XL> semantics.
I'm quite certain that I understand them at least as deep as you'll
ever do. To add an argument: of course, having or not having
constructs in a language could be seen as an issue of syntax. But
there is more to it, i.e. the ANSI standard or even RSRn specify
semantics for these constructs, which is exactly where much of the
differences lie between Scheme and CL (not only which semantics is
assigned to constructs, but which constructs have a well-specified
semantic at all).
Holger
--
--- http://www.coling.uni-freiburg.de/~schauer/ ---
"(/ (- (f common-lisp) (f scheme)) (f C)) => float underflow"
-- <···@rebol.com> in comp.lang.lisp
Xah Lee wrote:
> Holger Schauer,
>
> Your brain is not good enough for me to converse with. How do I know? Look
> at this:
>
> you wrote:
>> [Pointless rumbling deleted]
>
> which points to the following paragraph i wrote:
>
>> If you have studied the history of math notations, you'll know that the
>> significance of notation is not merely in their prettiness or
>> convenience, but have in fact catapult the speed of progress in math, and
>> launched new ideas, methodologies, and philosophies in core mathematics
>> _caused_ by syntaxes. (e.g. matrixes, formalism.)
>
> Run to your library, and check out:
> _Mathematical thought from ancient to modern times_ by Morris Kline, V.2,
> Ch.33 Determinants and Matrices, p.795. And, Howard Eves, _An introduction
> to the history of mathematics_, 6th ed., Chapter 15-8 Philosophies of
> Mathematics, middle: Formalism. As examples.
>
> Without understanding what i'm talking about here, there's no hope for you
> to understand deeply the issues of syntax and semantics.
The problem is that "syntax" is often meant as a weaker part then semantic.
I have the impression that most people would say that the "syntax" of the
mathematic matrix-notation are things like the choose of parens over
brackets, or the choose of not using gridlines or using them.
It is questionable if the facilities of the matrix-notation comes therefore
only from the layout of some lines and numbers or if they come from the
idea of representing e. g linear equation systems this way and defining
operations like gauss elimination... on it. There _are_ also semantics in
notations I think and if _you_ do not understand what _you_ talk upon than
_I_ do not know what that means for you...
Regards,
Jochen
http://www.dataheaven.de
"Xah Lee" <···@xahlee.org> wrote in message
······················@xahlee.org...
> Syntax is important. It's so important that a language is nothing but
syntax
> _alone_.
Oh, dem wacky deconstructionists! What will dey think of nex? You go, Xah!
faa
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
> The fact that nothing that applies to any other Lisp applies to Scheme,
> and vice versa, at this time of its development.
This is false.
The first Lisp grew out of John McCarthy's desire for an algebraic
list processing language. The collection of ideas that inspired his
implementation are the core ideas that Lisp implementations have
evolved around, all of which apply to Scheme:
1. Symbolic information is represented externally by lists and
internally by list structure.
2. Garbage collection is used to solve the erasure problem
3. Program syntax is expressed as the list data structure
3. Prefix notation is used for procedural expressions
4. Types are determined at runtime
5. Functions are first class objects
There is space around these core ideas for many different language
designs and some are better than others for given purposes.
To assert that Scheme is not a Lisp because it has design flaws is bad
reasoning just as the hasty generalization you fear will taint
Common Lisp is bad reasoning.
"news.earthlink.net" <········@earthlink.net> wrote in message
··························@newsread1.prod.itd.earthlink.net...
> The first Lisp grew out of John McCarthy's desire for an algebraic
> list processing language. The collection of ideas that inspired his
> implementation are the core ideas that Lisp implementations have
> evolved around, all of which apply to Scheme:
> 1. Symbolic information is represented externally by lists and
> internally by list structure.
However, this is not necessarily true in Scheme, as #:Erik has stated much
more elegantly than I ever could have.
> 2. Garbage collection is used to solve the erasure problem
McCarthy did not intend for the language to be garbage collected initially.
See some of the documentation on the history of Lisp (the stuff from the
first HOPL proceedings is quite enlightening).
> 3. Program syntax is expressed as the list data structure
Again, not in R5RS. Program syntax is explicitly stated to be character
based.
> 3. Prefix notation is used for procedural expressions
Nope. Interlisp (which was a Lisp) had a mode that allowed you to write
arithmetic expressions with infix notation (and mix the code with prefix, as
well).
> 4. Types are determined at runtime
Not if you use the "the" operator incorrectly. The system is free to
produce an error (i.e., the results are undefined) if the type of an
expression in a "the" form is not of the specified type. Sounds like types
are not necessarily determined at runtime in all cases.
> 5. Functions are first class objects
In early lisps they weren't.
> There is space around these core ideas for many different language
> designs and some are better than others for given purposes.
Well, given that your "core ideas" are incorrect, it's not unusual that your
space is quite misdefined. This is probably WHY you misclassify Scheme.
> To assert that Scheme is not a Lisp because it has design flaws is bad
> reasoning
No Scheme is not a Lisp -in part - because your issues 1 and 3 are not true
of Scheme. The other ones are not necessarily true of Lisps, but we'll let
them pass.
> just as the hasty generalization you fear will taint
> Common Lisp is bad reasoning.
When I was young I thought Scheme was elegant and CL was bloated, clunky and
obtuse. Then I tried to program in Scheme. I found myself re-inventing a
heck of a lot of wheels. And that was when Schemes actually had real macro
processors (rather than the pattern templating bastardizations they have via
R5RS). I'd shudder to think how much code I'd have to write in Scheme to
provide what Common Lisp provides out of the box. To the extent that Scheme
makes programming in Scheme hard and has a similar surface syntax to Lisp,
it does become a threat, due to misunderstandings of naive users, to the
increased use of Lisp.
faa
On Thu, 22 Feb 2001 22:15:22 -0800, "Frank A. Adrian" <·······@uswest.net>
wrote:
> Nope. Interlisp (which was a Lisp) had a mode that allowed you to write
> arithmetic expressions with infix notation (and mix the code with prefix, as
> well).
Do you refer to "CLISP" (Conversational LISP)?
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/
To be honest, it's been so long since I saw an Interlisp manual I don't
remember the exact name of the facility. OTOH, you'd best behave, or I'll
bring up EVALQUOTED lisps, too...
"Paolo Amoroso" <·······@mclink.it> wrote in message
·································@4ax.com...
> On Thu, 22 Feb 2001 22:15:22 -0800, "Frank A. Adrian" <·······@uswest.net>
> wrote:
>
> > Nope. Interlisp (which was a Lisp) had a mode that allowed you to write
> > arithmetic expressions with infix notation (and mix the code with
prefix, as
> > well).
>
> Do you refer to "CLISP" (Conversational LISP)?
>
>
> Paolo
> --
> EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
> http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/
Erik Naggum <····@naggum.net> writes:
> There is no reason to consider Scheme a Lisp.
I think most people with experience in computer languages would
consider Scheme to be a `dialect' of the Lisp `family' of languages.
This assertion does hinge on the definition of `dialect' (and family),
however. A broad enough definition (turing completeness) would place
C++ in the same family as Lisp, a narrow enough one (strict ANSI CL
compliance) would exclude Franz Allegro.
> * <········@earthlink.net>
> > What is an appropriate definition of "Lisp"?
> <····@naggum.net>
> More importantly, which existents satisfy it, and on which conditions?
I consider these things to be fundamental characteristics of Lisp:
1. A foundation or inspiration from Church's lambda calculus.
2. Primarily applicative order.
3. Wide use of functional composition as a means of combination.
4. Frequent use of higher-order functions.
5. Latent (dynamic) types.
6. Strong isomorphism between code and data which leads to
a) easy introspection and reflection,
b) language is its own metalanguage,
c) code often manipulates other code
7. Automatic storage management.
8. Late binding
9. Few `second-class' objects.
10. Significant support for interactive and incremental development.
I'm sure I missed some, and I'm sure there are things people would
call Lisp that don't have some of these characteristics. I'm also
sure that there are languages that fulfill most or all of the above
criteria, yet are obviously not lisp.
One would expect strong similarities between languages in the same
`family'. Rather than examining the languages themselves, you could
examine the programs or the programmers.
If two languages are `dialects' of the same `family', it would be
reasonable to assume that programmers familiar with one dialect could
comprehend a different one without significant difficulty. Here are
some examples of a simple algorithm written in several different
languages (source http://www.webcom.com/nazgul/change.html):
**********
Awk
function cc(amount, kinds_of_coins)
{
if (amount == 0) {
return 1;
}
else if (amount < 0 || kinds_of_coins == 0) {
return 0;
}
else {
return cc(amount - first_denomination(kinds_of_coins), \
kinds_of_coins) + \
cc(amount, kinds_of_coins - 1);
}
}
C
int cc(int amount, int kinds_of_coins)
{
if (amount == 0) {
return 1;
}
else if (amount < 0 || kinds_of_coins == 0) {
return 0;
}
else {
return cc(amount - first_denomination(kinds_of_coins),
kinds_of_coins) +
cc(amount, kinds_of_coins - 1);
}
}
Ghostscript
/cc {
exch
dup 0 eq { pop pop 1 } {
dup 0 lt 2 index 0 eq or { pop pop 0 } {
dup 2 index firstden sub 2 index cc
1 index 3 index 1 sub cc add exch pop exch pop
} ifelse
} ifelse
} def
Intercal (excerpt, it's too big)
(2000) PLEASE STASH .2
DO .2 <- #1
DO (2001) NEXT
(2001) PLEASE FORGET #1
DO .1 <- '?.1$.2'~'#0$#65535'
DO (2002) NEXT
DO .2 <- !2$#0'~'#32767$#1'
DO (2001) NEXT
(2003) PLEASE RESUME "?!1~.2'$#1"~#3
(2002) DO (2003) NEXT
PLEASE RETRIEVE .2
(2004) PLEASE RESUME #2
Rebol
cc: func [amount kinds-of-coins] [
either amount = 0
[1]
[either (amount < 0) or (kinds-of-coins = 0)
[0]
[(cc amount - first-denomination kinds-of-coins
kinds-of-coins) +
(cc amount kinds-of-coins - 1)]]]
UCB Logo
to cc :amount :kinds
output ifelse :amount = 0 [1] [ ~
ifelse or :amount < 0 :kinds = 0 [0] ~
[(cc :amount - firstden :kinds :kinds) + ~
cc :amount :kinds - 1]]
end
Orthogonal (excerpt, I can't understand this at all, I don't even know
if this is a complete subroutine.)
L ky kx # @ ny nx # ? J 1 ~ y
ccw ky & bn = nx ny cw
L kx = ! | ! ? J 0 ~ y
y ccw = kx ky = nx ny 15 cw
10 1 cw 14 ny nx = 13 ky kx = y - ky kx = cw
K - nop ~ ky kx cw x 1 H
L K cw y cw x #
Pascal
function cc(amount, kinds : integer) : integer;
begin
if amount = 0 then
cc := 1
else if (amount < 0) or (kinds = 0) then
cc := 0
else
cc := cc(amount - first(kinds), kinds) + cc(amount, kinds - 1)
end;
Tex
\def\cc#1#2{{\ifnum #1=0 \global\count1=1 \else
\ifnum #1<0 \global\count1=0 \else
\ifnum #2=0 \global\count1=0 \else
\count3=#1 \count0=#1 \advance\count0 by-\firstden{#2}
\cc{\count0}{#2}\count0=\count1 \count2=#2
\advance\count2 by-1
\cc{\count3}{\count2}\global\advance\count1 by\count0
\fi\fi\fi}}
**********
Now let's look at a few more versions:
NASE Algol 60
integer procedure cc(amount, kinds);
value amount, kinds;
integer amount, kinds;
begin
if amount = 0 then
cc := 1
else if (amount < 0) or (kinds = 0) then
cc := 0
else
cc := cc(amount - first(kinds),
kinds) +
cc(amount, kinds - 1)
end;
MIT Scheme
(define (cc amount kinds-of-coins)
(cond ((= amount 0) 1)
((or (< amount 0) (= kinds-of-coins 0)) 0)
(#t (+ (cc (- amount
(first-denomination kinds-of-coins))
kinds-of-coins)
(cc amount
(- kinds-of-coins 1))))))
Common Lisp
(defun cc (amount kinds-of-coins)
(cond ((= amount 0) 1)
((or (< amount 0) (= kinds-of-coins 0)) 0)
(t (+ (cc (- amount
(first-denomination kinds-of-coins))
kinds-of-coins)
(cc amount
(- kinds-of-coins 1))))))
Admittedly, simple syntactic similarities are not the whole story when
it comes to language families. For instance, many people consider ML
and Dylan to be in the Lisp family (but few would consider them
`dialects').
It is rather straightforward to translate many programs between Scheme
and Common Lisp. Jonathan Rees's pseudoscheme is a macro package for
Common Lisp that can handle a good number Scheme programs.
> * <········@earthlink.net>
> > So what qualities does Scheme lack to exclude it from the label of a
> > "Lisp"?
Aside from the imprimatur of Erik, the criteria that would exclude
Scheme, but not exclude such languages, such as AutoLisp, Common Lisp,
InterLisp, PCL, MacLisp, ZetaLisp, etc. are (to my mind) rather
obscure.
Erik points out that Scheme has ``barely any namespaces at all, and
[lacks] real symbols.'' Common Lisp, on the other hand, does not
require proper tail recursion or first-class continuations. For the
most part, I have not found these differences to be a significant
impediment in translating between Scheme and Common Lisp.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall <···@content-integrity.com> writes:
> Erik Naggum <····@naggum.net> writes:
>
> > There is no reason to consider Scheme a Lisp.
I think a more defensible claim is "There is reason not to consider
Scheme a Lisp." It's certainly an undeniable fact that certain people
do consider Scheme a Lisp, and that these people are not acting without
any reason. (We can all debate endlessly the goodness of such reasons,
but I've already recently posted my thoughts on the context-relative
nature of good and bad, so I'll spare you a reprise here.)
> I think most people with experience in computer languages would
> consider Scheme to be a `dialect' of the Lisp `family' of languages.
If you said "some" and perhaps even "many", this would be an undeniable fact.
There's plenty to disagree on here without getting our initial positions
misstated. :-)
Kent M Pitman <······@world.std.com> writes:
> Joe Marshall <···@content-integrity.com> writes:
>
> > I think most people with experience in computer languages would
> > consider Scheme to be a `dialect' of the Lisp `family' of languages.
>
> If you said "some" and perhaps even "many", this would be an undeniable fact.
How about `there exists'?
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall <···@content-integrity.com> wrote:
>Kent M Pitman <······@world.std.com> writes:
>
>> Joe Marshall <···@content-integrity.com> writes:
>>
>> > I think most people with experience in computer languages would
>> > consider Scheme to be a `dialect' of the Lisp `family' of languages.
>>
>> If you said "some" and perhaps even "many", this would be an undeniable fact.
>
>How about `there exists'?
Are we going to vote? ;-)
Except on this newsgroup, I never have met Lispers or Schemers saying Scheme is
not a Lisp dialect. Most (most) of the ones I have personally met never read
this newsgroup and, I think, don't care.
--
Francis Leboutte www.algo.be +32-(0)4.388.39.19
[Apologies if this got posted twice. My newsreader hung forever trying to
deliver it the first time, and I don't know how far it got so I'm retrying.
One extra paragraph at end added in the process, based on thoughts I had
while staring at the first round not being delivered...]
Francis Leboutte <··········@algo.be> writes:
> Except on this newsgroup, I never have met Lispers or Schemers
> saying Scheme is not a Lisp dialect. Most (most) of the ones I have
> personally met never read this newsgroup and, I think, don't care.
When discussing such issues, surely the numbers on either side don't
matter.
My paper "Lambda, The Ultimate Political Party" addresses this issue in
more detail, but the essence of the article is to assert that languages
are not mere piles of semantics but are locuses of human endeavor that
serve to attract a base of users.
The "speech act" involved in saying "these two languages are in the
same family" is to suggest that "users of one language might also be
served the another". However, in practice, there is a huge degree of
animosity between Scheme and Lisp. The split did not happen over some
small detail of design, but over several major religious points that
were such an absolute division that when the Lisp & Functional Programming
conference used to exist, it was like watching a breathing organism:
when Lisp papers were up, all the FP people left the room and vice versa.
These communities talk to each other a whole lot less than people would
expect, and exactly because of these differences.
Yes, there is overlap of ideas, but there is overlap between all
languages in ideas. The presence of assignment in a language isn't
enough to make BASIC and Common Lisp seem dialects of each other, and
yet they are siblings in that limited regard when compared to a
pure-functional language like the lambda calculus which has no
primitive assignment. The notion of class structure brings together
C++ and Lisp and separates it from C, yet most people wouldn't say that
C++ and Lisp are dialects of one another.
By the same token, I and at least some others, feel that the various
elements of conspicuous overlap between Lisp and Scheme do not make up
for the even larger differences.
Yes, Scheme and Lisp both have parentheses. But Scheme defines its
semantics in terms of those parens, and Lisp defines its semantics in
terms of the objects that those parens will read as. This leads to
peculiar disconnects, such as that there is no semantics to (+ . (1
2)) in Scheme even though it's the same list as (+ 1 2), while in Lisp
they have the same meaning since they are the same list. Further,
Lisp treats gensyms and other objects with no print names in a
meaningful way because Lisp values object identity during program
analysis in a way that Scheme doesn't.
Yes, Scheme and Lisp both have first class functions and higher order
functions to combine and manipulate them. But Scheme considers this
the purpose of life, while Common Lisp sees this as one of many
possible expressive tools. This is a non-trivial difference because
underlying it is the not-so-hidden assumption in Scheme design that
there should a minimum of ways to express oneself, while Common Lisp
plainly values not just semantics but expressive style, and sees a
multiplicity of expressive styles as importnat both to support and
even to offer primitively in cases where it's plain that the user base
cannot agree on a single such device as being universally preferrable.
Yes, Scheme and Lisp both have the ability to write recursive
procedures, but Common Lisp has not advocated this style to the
exclusion of all else. Some Common Lisp advocates (myself included)
feel that tail recursion makes debugging hard, and prefer to have at
least the option to accumulate stack as tail calls are done. This
exposes a HUGE RIFT in the priorities of the two communities, one
focused on style of written programs and the other focused on
debuggability. (And, incidentally, I and at least some others don't
think the notion of writing every loop as a tail recursion IS
stylish.)
Yes, Scheme and Lisp appear to have the same kinds of program
elements: LAMBDA, IF, CAR, CDR, CONS, variables, assignment, etc. But
on closer inspection the low-level datatypes are not the same
(treatment of false/null is different, for example), the treatment of
variables is not the same (different namespaces), the treatment of
assignment is not the same (Lisp doesn't put a "scary" marker, "!", on
the end of its assignment operator because it doesn't moralize about
assignment). Even LAMBDA is very different because of Lisp's use of
&keywords, which provide enormous and important functionality, simplifying
expressivity for Lisp programmers, something apparently not valued by
Scheme, at least at the langauge level.
Yes, Scheme and Lisp both have the moral equivalent of CATCH, but Lisp
limits its to a mode that is stack-compatible, while Scheme has full
first-class continuations. Yes, there are fun theoretical things you
can write with full continuations, but it hasn't been shown that those
things are computationally/efficiency-wise best written that way. In
my experience, programmers who come out of Scheme used to using that
are not very sensitive to resource consumption in their programs
because it's been hidden from them.
AND, on that same matter, Scheme sweeps utterly under the rug (because
it's an embarrassment to the whole design) the nightmare caused by the
bad interaction of UNWIND-PROTECT with first-class continuations,
since UNWIND-PROTECT cannot knwo [halting problem] whether any given
throw through the guarded clauses is the "last" throw through, and so
it can't run the protected code. Only the GC can run that code when
it does the proof that the continuation is no longer reachable, but
that's too late to make things like WITH-OPEN-FILE really work
correctly. Scheme considers this a minor issue (though I suspect
secretly major enough that this is the reason UNWIND-PROTECT is not in
the core language), but I consider it wholly major. I have often said
that if I could ask only one question about a language to tell if it was
usable, I would ask "Does it have unwind-protect or the equivalent concept
as a primitive piece of syntax?" Lisp does, Scheme does not. That's a
major difference, in my opinion.
Yes, Scheme and Lisp both have fancy number systems like bignums and
stuff, but Lisp cares about efficiency by providing declarations to compile
these things efficiently. Scheme does not treat that issue, except to say
that type inferencing is allowed. I don't think that's enough.
Yes, Scheme and Lisp both have numeric functions like SIN, COS, TAN, etc.
But Scheme doesn't like to get messy about the details of branch cuts.
It makes the spec longer and that is considered a fundamental linguistic
flaw by many Scheme designers; the one "must do" thing of the language is
to keep the spec short. CL doesn't have that limitation. Its concern is to
specify the set of things that matter to programmers doing real work, and
to programmers porting among implemetnations. That is a major difference.
I could go on and on, but the point is this: Language design is a set
of choice points. At nearly every choice point except the very most
superficial, Scheme has made materially different choices than Lisp.
I suspect a Lisp user would be happier using Smalltalk or even Java
than Scheme, in terms of programming paradigm, library availability,
etc. I suspect a Scheme programmer would be happier using ML or
Haskell or even maybe Pascal than using Lisp. CL programmers that
wander into Scheme by accident write pretty darned bad programs; their
intuitions are all wrong. Likewise in reverse for Scheme programmers.
This is not characteristic of dialectal variation. An American
wandering into England or Canada can pretty much get by, in spite of a
few words difference; major retraining isn't required. English and
Spanish seem closer to me than Lisp and Scheme because although I have
to substitute different words eveywhere, the sentence structure is
largely the same. Transliteration mostly works. Going from Lisp to
Scheme is more like going from English to German, with not just words
changing but whole sentences needing to be reordered and just plain
expressed differently.
Just my opinion, of course. But I hope I've at least motivated the
notion that these langauges serve separate user bases. And that's
what I consider criterial to the design of a language: who uses it.
The semantics can change. We didn't lose too many people from Maclisp
to Common Lisp even though the language got turned on its head. It
was the same "political party" and people just updated their programs.
Scheme serves a different crew of people. It is, therefore, I claim,
a different language.
As to Francis' original remark about whether most people care, I would
say, as with all philosophy, they don't care about the question per se.
But they often care about its effects. When someone recommends a language
to them, based on knowledge about them, they care that they have been
directed in the right direction. If you think Scheme and Lisp to be
close siblings, then you will make the "mistake" (I claim) of directing
fans of one to the other. They may not care if Scheme and Lisp are dialects
of the same language, but they will care about ending up with a language
they don't like. Since I think they will be happier in other languages,
I think it's best not to regard these two as close choices.
If you are into math, history of math, or philosophy of mathematics,
doubtless you are familiar with the following quotes:
De Sua, F. (1956)
Suppose we loosely define a religion as any discipline whose foundations
rest on an element of faith, irrespective of any element of reason which may
be present. Quantum mechanics for example would be a religion under this
definition. But mathematics would hold the unique position of being the only
branch of theology possessing a rigorous demonstration of the fact that it
should be so classified.
In H. Eves In Mathematical Circles, Boston: Prindle, Weber and Schmidt,
1969.
Bertrand Russell:
Pure mathematics consists entirely of such assertions as that, if such and
such a proposition is true of anything, then such and such another
proposition is true of that thing. It is essential not to discuss whether
the first proposition is really true, and not to mention what the anything
is of which it is supposed to be true...Thus mathematics may be defined as
the subject in which we never know what we are talking about, nor whether
what we are saying is true.
--
Since most of you here are not familiar with philosophies of mathematics,
i'd like to prep you on why
Mathematics is a Religion
It so happens, that I have my notes saved for a speech presentation in some
philosophy class of community college back in 1995. Upon reading it, it is
quite good. Here it is.
<begin attachment>
Mathematics is in essence a religion, and it is the only religion that
can rightly classify itself being so. This is what I wish to convince you in
the following paragraphs.
What I mean by religion? What is religion? By religion, we commonly
think of Christianity, Hinduism, Islam, Judaism and so forth. The common
element shared by all religions is faith. By the word religion, I will mean
a system of beliefs based on faith, and by faith I will mean the acceptance
of notions without questioning them.
What is mathematics? This is not a question easily answered to every
scholar's satisfaction but it does not matter here. We all know what
mathematics is. We have learned elementary algebra in school, and we do
arithmetic everyday when balancing our bank accounts. This everyday
understanding suffices for my argument. For the shake of precision, I will
quote the definition of mathematics from two dictionary. 1) American
Heritage Dictionary: "The study of the measurement, properties, and
relationships of quantities, using numbers and symbols." 2) Webster's Ninth
New Collegiate Dictionary: "the science of numbers and their operations,
interrelations, combinations, generalizations, and abstractions and of space
configurations and their structure, measurement, transformations, and
generalizations."
Most of us are familiar the way mathematics text books differ from other
text books. In each chapter we find theorems and their proofs. Chapter after
chapters are theorems. Proofs of theorems are all based on previous
theorems. All mathematics have this characteristic. In fact, mathematics is
nothing but a series of theorems. But if all these theorems are based on
other theorems, shouldn't there be something like a first theorem? Yes. The
first few theorems are called axioms or postulates. American Heritage
Diction define axiom as: "A self-evident principle or one that is accepted
as true without proof as the basis for argument".
Why cannot we prove axioms? To built mathematics, one must start at some
point. If an axiom can be proven, then it is considered a theorem, while the
basis for the proof will be called axioms. In an analogy, axioms are like
the ground of a building. Buildings must sit on some ground. If the ground
can be built, then that ground must be built on some other ground. In
arithmetic, one of the axioms assumes that there are infinite number of
integers. This we cannot prove. As a way of nature, we are unable to see or
count infinity. Only by inductive inference we conceive infinity and the
infinitude of numbers. Take another example of axioms. Euclid (c. 300 B.C.)
in his Elements used the following five axioms to built what is now called
Euclidean geometry, using only these to deduce various theorems. (e.g. The
angles of a triangle must add to 180 degrees):
1) It is possible to draw a straight line from any point to any point.
2) It is possible to produce a finite straight line continuously in a
straight line.
3) It is possible to describe a circle with any center and distance.
(radius)
4) All right angles are equal to one another.
5) Through a point outside a given line only one parallel to the line can be
drawn.
These are obvious to common sense and everyday experience, but just
because a person have seen a million red apples doesn't mean all apples are
red. It is not logically ruled out that one day we may find it impossible to
draw a straight line through two points. [footnote 1] Therefore these are
accepted as axioms, as oppsoed to absolute truth.
It is not a mathematician's concern to question the validity of axioms, but
the philosopher's. Every theorem is based ultimately on axioms, and axioms
are taken for granted. Thus we have a system of beliefs based on faith,
therefore mathematics is a religion.
I will show you now why mathematics is the only religion that can be
rigorously demonstrated that it belong to such classification. Previously I
have shown the roll of axioms in mathematics, here I wish to discuss some
restrictions on axioms. There are two things standing out that axioms must
satisfy. 1) The number of axioms must be finite. 2) Axioms must not
contradict themselves. (consistency) If we start with an infinite number of
axioms, perhaps we do not need to built any theorems, and if we started with
axioms that contradict themselves, the mathematics we built on it wouldn't
be any good. For example, suppose I have the following axioms to work with:
Axiom #1: Banana are fruits.
Axiom #2: Apple are fruits.
Axiom #3: A person can eat banana or apple.
Axiom #4: fruits cannot be eaten.
From these we can deduce a few theorems:
Theorem #1: All fruits are edible. This follows from Axiom #1, #2, and #3.
Theorem #2: All fruits are not edible. This follows from axiom #1, #2, and
#4.
The contradiction arise because the axioms we start with are
inconsistent. As a mathematician, s/he must make sure that the axioms are
consistent. The above inconsistency can be spotted by inspection because it
is simple. The problem of proving an axiomatic system consistent turned out
to be one of the most difficult problem in mathematics.
To make sure that we won't see a theorem that states one plus one equals
three, mathematicians for the last few hundred years have busied themselves
with proving the consistency of their axioms. This went on without success
until in 1931, a mathematician named Kurt G�del (1906-1978) proved that this
task is impossible. G�del showed that, for a sufficient large axiomatic
system, it is not possible to show the consistency of the system without
assuming axioms outside the system. This discovery in mathematics is
comparable to Einstein's theory of relativity in physics. It shocked the
world and left mathematics in a somber state with uncertain future.
The consequences of G�del's theorem is far reaching. In our discussion,
it means that mathematicians must blindly accept that their axioms being
consistent, and that their theorems will not contradict each other. All
these without possible proof. G�del proved this impossibility, therefore we
can say that, mathematics is the only religion that can rightly claim itself
to be with a rigorous proof.
[footnote 1] In fact, physicists have experimentally shown that axiom #5 is
not true in the space-time we live in.
<end attachment>
When we inquire into a topic that verges into philosophy, sufficient experts
with deep knowledge can often cogently arrive at some absurd ideas for your
amusement. Now that you have seen the demo that mathematics is a religion,
then should you forthwith insist to friends and family that Mathematics is a
Religion? Even though the argument is in some sense technically impeccable,
it would be egregious to overthrow roots of tradition. Perhaps in two
hundreds years from today when the world's religions are gone, then perhaps
we could insist that mathematics or quantum mechanics are religions without
appearing asinine.
The above is a sufficient kick in the ass to Erik Naggum and Kent Pitman's
_Scheme is not a lisp_. They won't be able to sit for weeks. Say "thank you
Xah".
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Kent M Pitman <······@world.std.com>
> Organization: The World Public Access UNIX, Brookline, MA
> Newsgroups: comp.lang.lisp
> Date: Sat, 24 Feb 2001 01:35:14 GMT
> Subject: Re: Is Scheme a `Lisp'?
Kent M Pitman wrote:
> Yes, there is overlap of ideas, but there is overlap between all
> languages in ideas. The presence of assignment in a language isn't
> enough to make BASIC and Common Lisp seem dialects of each other, and
> yet they are siblings in that limited regard when compared to a
> pure-functional language like the lambda calculus which has no
> primitive assignment. The notion of class structure brings together
> C++ and Lisp and separates it from C, yet most people wouldn't say that
> C++ and Lisp are dialects of one another.
Yes thats true. another example would be to compare C and Pascal which have
a lot in common, but I think neither the Pascalers nor the C'ers will say
that one is a dialect of the other.
The Syntax of Pascal and C is IMHO similar in a grade Scheme's syntax is
similar to CommonLisp. The semantics of Pascal and C are very similar too.
Perhaps it helps, seeing Scheme only as another language with prefix-syntax
and special parens-syntax with partly similar concepts like Lisp.
Regards,
Jochen
In article <···············@world.std.com>, Kent M Pitman
<······@world.std.com> wrote:
>[Apologies if this got posted twice. My newsreader hung forever trying to
> deliver it the first time, and I don't know how far it got so I'm retrying.
> One extra paragraph at end added in the process, based on thoughts I had
> while staring at the first round not being delivered...]
>
>Francis Leboutte <··········@algo.be> writes:
>
>> Except on this newsgroup, I never have met Lispers or Schemers
>> saying Scheme is not a Lisp dialect. Most (most) of the ones I have
>> personally met never read this newsgroup and, I think, don't care.
>
>When discussing such issues, surely the numbers on either side don't
>matter.
>
>My paper "Lambda, The Ultimate Political Party" addresses this issue in
>more detail, but the essence of the article is to assert that languages
>are not mere piles of semantics but are locuses of human endeavor that
>serve to attract a base of users.
>
>The "speech act" involved in saying "these two languages are in the
>same family" is to suggest that "users of one language might also be
>served the another". However, in practice, there is a huge degree of
>animosity between Scheme and Lisp. The split did not happen over some
>small detail of design, but over several major religious points that
>were such an absolute division that when the Lisp & Functional Programming
>conference used to exist, it was like watching a breathing organism:
>when Lisp papers were up, all the FP people left the room and vice versa.
>These communities talk to each other a whole lot less than people would
>expect, and exactly because of these differences.
I think that this could also be construed as an example of just how close
Scheme and Lisp are: if they weren't so nearly identical, they wouldn't be
fighting over the same memetic niche. It's a little like the animosities
among verious religious groups, where apostates and schismatics are far
more hated than the heathen. It's the fact that they have such similar
goals that makes disagreement over how to go about achieving them
such a big deal. (Or, as someone once said about academia: "The fights
are so vicious because the stakes are so low.)
From even a slight distance, the differences between Lisp and Scheme
pale in comparison to their combined distance from most other big-name
languages. I think the "ultimate political party" moniker is a good way to
look at it, because there's a lot of commonality between the status to
Lisp et al. and the self-destruction of progressive political movements.
paul thinking of the old bicolor star trek episode
··@panix.com (Paul Wallich) writes:
> I think that this could also be construed as an example of just how close
> Scheme and Lisp are: if they weren't so nearly identical, they wouldn't be
> fighting over the same memetic niche. It's a little like the animosities
> among verious religious groups, where apostates and schismatics are far
> more hated than the heathen. It's the fact that they have such similar
> goals that makes disagreement over how to go about achieving them
> such a big deal. (Or, as someone once said about academia: "The fights
> are so vicious because the stakes are so low.)
> From even a slight distance, the differences between Lisp and Scheme
> pale in comparison to their combined distance from most other big-name
> languages. I think the "ultimate political party" moniker is a good way to
> look at it, because there's a lot of commonality between the status to
> Lisp et al. and the self-destruction of progressive political movements.
No, their differences don't pale in comparison to other languages,
especially if we look at the underlying goals of the two language
communities, instead of letting ourselves be blinded by superficial
similarities. For my professional work, I'd rather switch to Ada or
some other big-system language, than switch to Scheme, which IMHO is
just as much a teaching and small-system language, as e.g. the
original Pascal was. I think that many Scheme users would likewise
rather switch to some other language, than use Common Lisp.
The fights are so vicious, because the stakes are so _high_: If one
of the language camps would loose their language, they couldn't just
switch to the other language with little loss.
The reason why there is so much animosity between the two camps, is
that there _are_ huge differences in values, goals, methods,
standards, process, etc., yet outsiders (and some insiders) only see
the superficial similarities (parens, lambda, car, ...), and IMHO
wrongfully conclude that the differences are minor, and that they can
therefore lump the two together under one category or niche.
The reason why there isn't so much animosity between e.g. Ada and
Scheme, is not because they really are further apart, but rather
because they are even superficially perceived to be so different, that
there is no competition for the same memetic niche (except maybe in
the much larger category of programming languages).
So the two camps are more or less forced into competing for the
memetic niche even though they are part of very different niches in
the programming language ecosystem.
Regs, Pierre.
--
Pierre R. Mai <····@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
Thank you Pierre et al for your contribution on the diff and stakes of
Scheme and Common Lisp and related issues.
Being a man of clear mind, let me just remind everyone the debate in this
thread is _Is Scheme a Lisp_, or more verbosely _Is Scheme a dialect of
Lisp_, not _is Scheme a Common Lisp_, _The difference between Scheme and
Common Lisp_, _The importance of the awareness of Scheme and Common Lisp's
differences_, _The significance of languages whose codes have similar
looks_, or _The legitimacy of the conceptual position that Scheme could be
usefully, or at least meaningfully, considered not to be a Lisp._.
Feel free to digress or ramble, but be conscious of what is going on.
So far, with Kent Pitman made clear of his past contributions that he was
"merely defending the legitimacy of the conceptual position that Scheme
could be usefully, or at least meaningfully, considered not to be a Lisp.",
the only person who holds _Scheme is not a Lisp_ is Erik Naggum. And, so
far, Naggum is gagged by Xah's opus ID ·················@xahlee.org (the one
with the _Mathematics is a Religion_).
To prevent any mudding of the waters, anyone who wishes to jump in please
make a clear statement that either you believe
* Scheme is a Lisp
or
* Scheme is not a Lisp
then we can all consider your argument or muse over your digression and move
on to other topics of lesser burden. Meanwhile, unless Erik Naggum have
something urgent to say, we all live happily ever after with the peace of
mind that the dire debate has ended with Xah's opus and we all learned that
when Xah is watching it is better not to fuck around with reason.
Thank you.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: "Pierre R. Mai" <····@acm.org>
> Organization: Pretty Much Science Fiction --- www.pmsf.de
> Newsgroups: comp.lang.lisp
> Date: 25 Feb 2001 17:10:52 +0100
> Subject: Re: Is Scheme a `Lisp'?
Xah Lee <···@xahlee.org> writes:
> So far, with Kent Pitman made clear of his past contributions that he was
> "merely defending the legitimacy of the conceptual position that Scheme
> could be usefully, or at least meaningfully, considered not to be a Lisp.",
> the only person who holds _Scheme is not a Lisp_ is Erik Naggum. And, so
> far, Naggum is gagged by Xah's opus ID ·················@xahlee.org (the one
> with the _Mathematics is a Religion_).
My personal purely syntactic lisp-predicate is implemented by the
following CL function:
(defun language-lisp-p (language)
(if (search "Lisp" (language-name language) :test #'char-equal)
t
nil))
Hence we get:
(deftype lisp ()
`(and language (satisfies language-lisp-p)))
* (typep (make-language :name "Common Lisp") 'lisp)
T
* (typep (make-language :name "InterLisp") 'lisp)
T
* (typep (make-language :name "New Implementation of Lisp" :abbrev "NIL")
'lisp)
T
* (typep (make-language :name "Emacs Lisp") 'lisp)
T
* (typep (make-language :name "IS Lisp") 'lisp)
T
* (typep (make-language :name "Dylan") 'lisp)
NIL
* (typep (make-language :name "Scheme") 'lisp)
NIL
* (typep 42 'lisp)
NIL
I think that naming is an expression of intent.
Regs, Pierre.
--
Pierre R. Mai <····@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
"Pierre R. Mai" <····@acm.org> wrote
> (defun language-lisp-p (language)
> (if (search "Lisp" (language-name language) :test #'char-equal)
> t
> nil))
>
> Hence we get:
>
> (deftype lisp ()
> `(and language (satisfies language-lisp-p)))
>
> * (typep (make-language :name "Common Lisp") 'lisp)
> T
> * (typep (make-language :name "InterLisp") 'lisp)
> T
> * (typep (make-language :name "New Implementation of Lisp" :abbrev "NIL")
> 'lisp)
> T
> * (typep (make-language :name "Emacs Lisp") 'lisp)
> T
> * (typep (make-language :name "IS Lisp") 'lisp)
> T
> * (typep (make-language :name "Dylan") 'lisp)
> NIL
> * (typep (make-language :name "Scheme") 'lisp)
> NIL
> * (typep 42 'lisp)
> NIL
I'm not sure for this last one as it is "The Answer to the Great Question Of
Life, the Universe and Everything ..."
This would falsely imply that Lisp isn't. Maybe you should modify
language-lisp-p...
Marc
"Marc Battyani" <·············@fractalconcept.com> writes:
> > (deftype lisp ()
> > `(and language (satisfies language-lisp-p)))
[...]
> > * (typep 42 'lisp)
> > NIL
>
> I'm not sure for this last one as it is "The Answer to the Great Question Of
> Life, the Universe and Everything ..."
> This would falsely imply that Lisp isn't. Maybe you should modify
> language-lisp-p...
But that would imply that
(typep 42 'language)
Yet, since we already have
(typep 42 'number)
This would imply that the two types number and language are not
disjoint, since they have at least 42 in common. But in this way we
run afoul of Section 4.2.2 Type Relationships of the ANSI Common Lisp
standard.
Of course this might explain why Life, the Universe and Everything
sometimes breaks...
Regs, Pierre.
--
Pierre R. Mai <····@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
"Pierre R. Mai" <····@acm.org> writes:
> (deftype lisp ()
> `(and language (satisfies language-lisp-p)))
>
* (typep (make-language :name "MockLisp") 'lisp)
T
Uh, oh.
> I think that naming is an expression of intent.
The road to hell....
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Jochen Schmidt wrote:
(snip)
Goddess bless us Lispers, we need all the %^%*^$*& help we can get...
Love lisp. Really I do. I only vist this place every 6 months or
so,though, because between my own age induced brain damage, stupidity
like this, or one of Eric's usual comments, I can be guaranteed that I
will not find an answer here.
It's a real pity - when I first picked up lisp around 1987, I could
count on Usenet. I haven't been able to for longer than I can really
remember... take it as you all will, I know, but I'll make this explicit
- in my mind, Eric, you have done more damage to lisp than the AI winter
even imagined doing.
I don't care what your answer is. That's my opinion - oh, just like
your's. Isn't that a surprise? I still don't care and any reply from you
will be ignored.
There. Made my statement. And I didn't change a god&#&$ thing either,
did I?
William
--
You better watch out What you wish for;
It better be worth it So much to die for.
Courtney Love
William Barnett-Lewis wrote:
> Jochen Schmidt wrote:
> (snip)
>
> Goddess bless us Lispers, we need all the %^%*^$*& help we can get...
You should let some of the things I said in when quoting my name and not
only a stupid "(snip)"
As I got this message out of it's regular thread I'am not able to relocate
the message you replied to without doing an effort I really don't want to
do after reading your post...
Jochen Schmidt
"William Barnett-Lewis" <······@mailbag.com> wrote in message ······················@mailbag.com...
>
> It's a real pity - when I first picked up lisp around 1987, I could
> count on Usenet. I haven't been able to for longer than I can really
> remember... take it as you all will, I know, but I'll make this explicit
> - in my mind, Eric, you have done more damage to lisp than the AI winter
> even imagined doing.
>
Strange, my classmates keep telling me I shouldn't waste time on Lisp
because it's an antiquated dinosaur, like FORTRAN or COBOL. Arguments
about it being a dedicated AI language never come up. Stranger still,
not a single one of them has ever mentioned Eric, go figure.
Where the heck did this come from anyway? Did you have a rough night,
miss a deadline?
Geoff
* William Barnett-Lewis wrote:
> It's a real pity - when I first picked up lisp around 1987, I could
> count on Usenet. I haven't been able to for longer than I can really
> remember... take it as you all will, I know, but I'll make this explicit
> - in my mind, Eric, you have done more damage to lisp than the AI winter
> even imagined doing.
This is such a stupid thing to say.
Here's why people don't like Lisp:
Their first exposure to Lisp was probably at university, where some
academic who had never done any significant real-world programming,
let alone programming in Lisp, and probably thought programming is
something that non-intellectuals do, and thus beneath contempt, taught
them some subset of Lisp 1.5, badly.
Their next exposure to CL was when they got told to look after an
application written in an expert system shell. Let me tell you about
this shell. It's written in a kind of mutant CL-derived language with
horrible syntax by the academic in the previous paragraph and his
mates, who somehow wangled a job in industry. And it is just hard to
make it do anything without having it periodically blow up in your
face because the interfaces you need aren't really exposed. And it's
an *expert system* for God's sake, which is about the least
interesting thing people can think of to work on. AI is about as cool
as progressive rock.
Then there's the application code they now have to maintain. This was
largely written by people who were taught by the academic two
paragraphs above, but thought they were Gods. Do I have to explain
the results? Everyone hates these people because they are arrogant as
fuck, but not actually any good. Source control? testing? Efficiency?
documentation? Gods don't need that mundane crap.
And now these poor sods have to look after this pile of shit, and ship
a release every four weeks to a large, demanding client. They hate
Lisp, of course they do - they hate everything to do with the crap job
they have to do. They want to reimplement it in C++/Java/tcl/perl -
anything, *anything* is better than the mess they're in. But they
can't because the only thing that's holding the whole thing together
is the fact that Lisp will keep programs running long after they
should by rights have sunk back into mud, taking their authors with
them if we're lucky.
These people have not heard of comp.lang.lisp, and they certainly
haven't heard of Erik. Erik is absolutely nothing to do with the
reason these people don't like Lisp: he is a total irrelevance to
them. I don't know why you want to blame him so much - I can only
guess it's because you don't want to face the fact that you are part
of the problem - we are all part of the problem because we're the
arrogant fools who produced this legacy of crap code and bogus
science that makes people hate Lisp.
If you want to deal with the problem stop trying to find scapegoats.
Write some cool applications, teach people how to write well in Lisp.
Don't, whatever you do, mention AI.
--tim
Xah Lee wrote:
> To prevent any mudding of the waters, anyone who wishes to jump in please
> make a clear statement that either you believe
>
> * Scheme is a Lisp
>
> or
>
> * Scheme is not a Lisp
I personally would simply say Scheme is a (the) Scheme and Common Lisp is a
Lisp.
As others have already pointed out, Scheme has a lot of other sources it
comes from. The major difference here I see is maybe that Common Lisp was
meant as the ultimate standardised Lisp while Scheme was meant as a new
programming language that inherits certainly some aspects of Lisp but also
from other languages. I don't think the designers of Scheme saw it as the
future replacement for existing Lisps.
Why do I think it would be better to say that Scheme is not (exactly) a
Lisp?
* It is good for Common Lisp because the *many* students that was forced to
learn Scheme by their unmotivated professors may possibly not think that
Common Lisp is only another implementation of their much-hated Scheme.
* it is good for Common Lisp "The industrial strengh" language to convince
IT-managers that know Scheme from university as a curious little
toy-language that Common Lisp is a real alternative to other industrial
strength languages.
* it would probably finally end the ridiculous recommendations that if
someone wants to learn Lisp he should start with Scheme.
* Both Scheme *and* Common Lisp would get a bit more "Identity"
* "Calling Scheme a Lisp" discriminates the other language-sources Scheme
has (e. g. Algol)
Regards,
Jochen
Dear Jochen Schmidt,
don't know if you are a student or what, but i'll teach you a thing or two
now. (having ignored you about that message on syntax)
I wrote:
>> To prevent any mudding of the waters, anyone who wishes to jump in please
>> make a clear statement that either you believe
>>
>> * Scheme is a Lisp
>>
>> or
>>
>> * Scheme is not a Lisp
and you wrote:
> I personally would simply say Scheme is a (the) Scheme and Common Lisp is a
> Lisp.
When it is clear to you what we are debating about, and which side you side
with, then i'll consider explaining to you how stupid your forthcoming
argument would be.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Jochen Schmidt <···@dataheaven.de>
> Organization: Dataheaven
> Newsgroups: comp.lang.lisp
> Date: Sun, 25 Feb 2001 20:56:28 +0100
> Subject: Re: Is Scheme a `Lisp'?
Xah Lee wrote:
> Dear Jochen Schmidt,
>
> don't know if you are a student or what,
I don't know what that would change...
> but i'll teach you a thing or two
You can explain your opinions and I may consider them if I find them sound
but you certainly don't teach me anything.
> now. (having ignored you about that message on syntax)
You seem to dislike critics hm? That's not my problem. You don't have to
hear my opinions nor do I have to hear yours - It's just a matter of good
will...
> I wrote:
>>> To prevent any mudding of the waters, anyone who wishes to jump in
>>> please make a clear statement that either you believe
>>>
>>> * Scheme is a Lisp
>>>
>>> or
>>>
>>> * Scheme is not a Lisp
>
> and you wrote:
>> I personally would simply say Scheme is a (the) Scheme and Common Lisp is
>> a Lisp.
Yes and that's as I stated my personal opinion and I have presented it to
you because you demanded it. It would be not bad for Scheme if it would not
count as a Lisp - I think it would be no penny worse or better.
Furthermore only because this is *my* opinion doesn't mean that I would try
to force you to have the same.
> When it is clear to you what we are debating about, and which side you
> side with, then i'll consider explaining to you how stupid your
> forthcoming argument would be.
I don't know what you wanted to _teach_ me "teacher", but I think others
opinions don't count much to you as it seems...
Jochen Schmidt
Dear Jochen Schmidt,
The debate as i outlined is:
(A) Is Scheme a Lisp.
or
(B) Is Scheme not a Lisp.
In one sentence: Whether Scheme is a Lisp. In more elaborate term: Whether
Scheme is a dialect of Lisp. In more explicit form it can be rephrased as:
Do you consider it true, that Scheme is a dialect of Lisp.
(note: this is different from "Do you consider that Scheme is a dialect of
Lisp.")
Now, you can pick you sides. Or, you can choose not to engage in this
debate, and perhaps start another debate topic that is similar, or simply
state some opinion related to my debate.
it would be absurd to join my debate and say:
>I personally would simply say Scheme is a (the) Scheme
> and Common Lisp is a Lisp.
And when i look at your reasonings that follows, it tells me you don't
clearly understand what the debate is, and if i assume you did, you have
several irrelevant and uncontrolled statements.
That is your folly, from my point of view.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Jochen Schmidt <···@dataheaven.de>
> Organization: Dataheaven
> Newsgroups: comp.lang.lisp
> Date: Mon, 26 Feb 2001 00:36:48 +0100
> Subject: Re: Is Scheme a `Lisp'?
Dearly beloved readers,
Erik has spoken. Let me serve my duty of translating his opus for the
laymen, and also placing it in the frame of our debate.
His post is very informative. It is informative in two ways. The first one,
is that it told us in no ambiguous terms Erik's position on the debate: "I,
Erik Naggum, consider it true that Scheme is a dialect of the Lisp family,
however, i don't like it". Let us take a moment to thank Xah for this
beautiful, unobstructed view of his head.
The second, is that we captured a rare and much wanted moment of Erik's
elusive behavior that can be easily explained to public.
When i said:
>> Do you consider it true, that Scheme is a dialect of Lisp.
>> (note: this is different from "Do you consider that Scheme is a dialect
>> of Lisp.")
He opened his message to add:
> And even more different from "What is this Lisp that would make "Scheme
> is a (dialect of) Lisp" a true statement?" vs "What is this Lisp that
> would make "Scheme is not a Lisp" a true statement?".
This is what we may think of as a prologue. Like, in the 007 movies they
have prologues. It gives us a sense of what's to come. It would be wrong to
say "i think we need to define 'Lisp'", just as it would be wrong if the 007
movie does not start with some daredevil acts by some suave handsome fella.
Erik's prologue, is catered to fit his views AND intentions to a tee.
Erik then said:
> I consider it pointless to argue whether Scheme is a Lisp without making
> the point that Scheme may well be a dialect of 1960's-style Lisp without
> being a dialect of _whatever_ Lisp is in the year 2000 and beyond.
In this paragraph, he indicated, in no Basic English grammar, that if he
were to join the debate in this thread which Xah have helped define, then he
agrees with Xah that _Scheme is a Lisp_. However, he does not exactly wish
to join the debate in such a manner. Instead, he comes in now as an
observer, not proponent of a side, and gave his opinion about the debate. If
Erik is a normal person, then the paragraph might go like this:
"ok, Scheme is a dialogue of Lisp all right, but I wish to remind everyone
some facts. In 1960 blab blab blab...".
Erik continues:
> If Scheme is a Lisp, Lisp has not evolved since its inception, and this
> is indeed what many Scheme-infested anti-Lisp beliefs is based in. If
> Lisp _has_ evolved since 1960 (or make it 1980 if you like), Scheme is no
> longer part of the Lisp evolution. Scheme _left_ Lisp's evolution, Lisp
> moved on forward, and "Scheme is a dialect of Lisp" is true only in a
> historical sense that there simply is no point in talking about any more.
This is an elaboration of ideas in his previous paragraph. For a true
understanding, one has to dive into the original instead of a translation,
so i'll leave my readers to their tasks, as i have served my purpose.
Thank you Erik, and thank you all for the delightful weekend. I'm going to
take a hike.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Erik Naggum <····@naggum.net>
> Organization: Naggum Software, Oslo, Norway
> Newsgroups: comp.lang.lisp
> Date: 26 Feb 2001 00:38:19 +0000
> Subject: Re: Is Scheme a `Lisp'?
Erik Naggum <····@naggum.net> writes:
> If Scheme is a Lisp, Lisp has not evolved since its inception, and this
> is indeed what many Scheme-infested anti-Lisp beliefs is based in. If
> Lisp _has_ evolved since 1960 (or make it 1980 if you like), Scheme is no
> longer part of the Lisp evolution. Scheme _left_ Lisp's evolution, Lisp
> moved on forward, and "Scheme is a dialect of Lisp" is true only in a
> historical sense that there simply is no point in talking about any more.
To me, this is a rather curious view. Back in circa 1984 when I was in high
school, I read an article in a Finnish computer magazine outlining an
implementation of a Lisp for Z-80. Armed with this, the Winston and
Horn Lisp book, and a lot of imagination, I wrote a simple Lisp interpreter
for the RCA 1802.
The language was a horrible mess, as you might imagine, and it had a
strange collection of features and absence of features (e.g. property lists
but no multiplication). By the time it was stable enough, RCA 1802 was
already passe, so it never got distributed anywhere. In that sense it
never even entered Lisp's evolution let alone left it. It certainly
was not a big systems language, and compared to it even Scheme seems
like a luxury cruiser. There never was much of a user community except
for a couple of friends to whom I showed it in the basement.
Despite all that, I claim to have implemented "a Lisp". Maybe not a
very elegant or useful member of the family, but "a Lisp"
nevertheless. It even passes the lisp-p test, as I called it pLisp.
I can understand the political and marketing reasoning in trying to
equate Lisp and Common Lisp. However, to someone with my background it
does not make much sense. I came from my home grown Lisp to Xlisp and
then to Scheme and some Common Lisp without much difficulty. The
basic feeling of programming in any of the language was more or less
the same, and distinctly different from any other languages I came
across.
The whole discussion is like someone claiming that a Volkswagen
Beetle is not a car, because it is so different from an Opel Astra.
--
Pertti Kellom\"aki, Tampere Univ. of Technology, Software Systems Lab
Kellom{ki Pertti <··@arokyyhky.cs.tut.fi> writes:
> The whole discussion is like someone claiming that a Volkswagen
> Beetle is not a car, because it is so different from an Opel Astra.
This is the second time in this discussion an appeal has been made to
an analogy involving a tree with a measurable number of named node
levels betwen the root and the item in question that have been
collapsed out for analogy's sake. Testing if these two are both cars
is not a matter of checking if they are siblings in the type tree.
There is a lot more bushiness there.
I think the better analogy would be whether someone claiming a certain
kind of minivan was really a station wagon. Or whether a certain kind
of Jeep was a kind of van. The point isn't about shape. The point is
that classifications exist for the purpose of making sweeping statements
about sets of things that have stuff in common. Plainly, there are
interesting statements one wants to make about vans that one does not
want to make about "other cars".
The question becomes whether there are interesting statements one
wants to make about the union of Scheme and Common Lisp and other
Lispy languages. I claim once you add Scheme to that mix, you water
down the set of interesting things you could say to such an extent
that it's hardly worth having the naem. Fred says "Lisp has no
special variables" because he knows Scheme (post 1978) doesn't. Mary
says "Lisp has no tail recursion elimination" because she knows CL
doesn't. What's the point? There are so few points of similarity
that it becomes a named category without a very good purpose, except
to hopelessly confuse people, which is what it does all the time because
it enables people who know Scheme to think they know CL or vice versa.
I'd rather have Scheme and Lisp be part of that icky unnamed superclass
that David Bakhash called "LispScheme" which I claim might be more of
a union class than a parent class but at least would allow people not
to be confused into thinking Lisp and CL was the same.
For example, we got into this a bit in designing ISO ISLISP, which I
consider to be a Lisp. It has a class system. It has specials. It has
two namespaces. It has a lot of important kinds of arrays. It solves
some detail questions differently than CL, but it is largely conceptually
compatible with CL, and it is properly in that same close space that makes
me comfortable that if someone knew CL or knew ISLISP, one could move
back and forth, and might reasonably want to.
In some sense, any statement made about the subclass and assumed to be
true of the superclass (about ISLISP but assumed about all Lisps, or about
CL and assumed true of all Lisps) is at risk of being in error. For
example, Elisp doesn't have a class system (that I know of). There is
no ELOS, like there is CLOS and ILOS. But it doesn't make a structural
difference in existing programs if you add it, and you could draw a lot
on other languages in the family to know what it should probably look like.
If you DIDN'T draw on those languages, you'd be deliberately distancing
yourself and pushing closer to being a new language. Scheme talks about
a class system or an error system sometimes, but never cares about being
conceptually compatible with CL. A mark of being its own language, I
claim: no concern about the lost constituency of those who cling to
compatibility with certain things. Elisp, because of its treatment of
specials, plainly distances itself a little from both CL and ISLISP, but
it's not an all or nothing thing. Over time, maybe it will break more away.
Seems plausible. It doesn't have to be all or nothing. It's not a precise
science. It's just, as someone earlier noted, a way of retaining focus
in conversations.
>>>>"KMP" == Kent M Pitman schrieb am Mon, 26 Feb 2001 15:38:17 GMT:
KMP> For example, Elisp doesn't have a class system (that I know of).
KMP> There is no ELOS, like there is CLOS and ILOS.
There is eieieo: http://cedet.sourceforge.net/eieio.shtml
KMP> But it doesn't make a structural difference in existing programs
KMP> if you add it, and you could draw a lot on other languages in
KMP> the family to know what it should probably look like.
Indeed: "EIEIO is an Emacs lisp program which implements a controlled
object-oriented programming methodology following the CLOS standard."
Holger
--
--- http://www.coling.uni-freiburg.de/~schauer/ ---
"Hi ! I'm a .signature virus!
Copy me into your ~/.signature to help me spread!"
Kellom{ki Pertti wrote:
> The whole discussion is like someone claiming that a Volkswagen
> Beetle is not a car, because it is so different from an Opel Astra.
"car" would be much more like "language" in this case.
As I understand it the problem is not that Scheme is no Lisp at all, but
that Scheme is no Lisp in the nowadays use of the term "Lisp".
If people talk about Common Lisp, they often call it only "Lisp". If I hear
Schemers talking on Scheme then the term Lisp is only spoken out if they
talk upon the language roots and is meant as "This old language of the
sixtees". I think using the term "Lisp" nowadays most time implicitely
involves meaning "Common Lisp".
The real problem is, that this is only clear to people that know Lisp
history good enough to differentiate between Scheme and Common Lisp.
I often here people discussing on some of the bad sides of Lisp but really
meaning Scheme - explaining them that Common Lisp has evolved and doesn't
have this problems any more lets them thinking that there is some
"implementation" of "Scheme aeehh Lisp" that is a bit enhanced.
IMHO Common Lisp is the evolved and unified language Lisp entering the new
millenium, while Scheme is some branch of one of it's grandparents.
Scheme as an equivalent to the term "Lisp" would mean no evolution of the
language Lisp since Scheme exists. Lisp in the meaning of "Common Lisp" has
*much* evolved and is nowadays a modern language that is able to compete
with all alternatives that are available on the programming language market.
The development of Scheme never raised the question if major old Lisps such
as InterLisp of MacLisp could be replaced by it - Common Lisp was thought
as an replacement it was thought as the evolution of the language Lisp at
all. So it deserves called simply "Lisp" nowadays because it is *the* Lisp.
Regards,
Jochen
>>>>> "Jochen" == Jochen Schmidt <···@dataheaven.de> writes:
Jochen> Kellom{ki Pertti wrote:
>> The whole discussion is like someone claiming that a Volkswagen
>> Beetle is not a car, because it is so different from an Opel Astra.
Jochen> "car" would be much more like "language" in this case.
But then what is "cdr" ?
(sorry, I just couldn't resist, I really tried, I really did :-)
------------------------+-----------------------------------------------------
Christian Lynbech | Ericsson Telebit, Skanderborgvej 232, DK-8260 Viby J
Phone: +45 8938 5244 | email: ·················@ted.ericsson.dk
Fax: +45 8938 5101 | web: www.ericsson.com
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
Christian Lynbech <···@tbit.dk> writes:
> >>>>> "Jochen" == Jochen Schmidt <···@dataheaven.de> writes:
>
> Jochen> Kellom{ki Pertti wrote:
> >> The whole discussion is like someone claiming that a Volkswagen
> >> Beetle is not a car, because it is so different from an Opel Astra.
>
> Jochen> "car" would be much more like "language" in this case.
>
> But then what is "cdr" ?
>
> (sorry, I just couldn't resist, I really tried, I really did :-)
>
Try "rest" if you are tried out :-)
Peter
Erik Naggum <····@naggum.net> writes:
> All too many of those who have first been exposed to Scheme continue to write
> in Scheme when using Common Lisp.
I do not happen to be one of them. My first exposure was with a home
grown implementation that had dynamic scoping. Before being exposed to
Scheme I had already written a parser generator in Xlisp (probably the
closest equivalent of Common Lisp I could afford at the time that
would run on the hardware I could afford). I would say I had
nontrivial programming experience on "a Lisp" before encountering
Scheme. Not years of experience implementing complex systems, but more
than your average freshman. I even had a copy of CLTL before a copy of
R3RS or SICP.
So it must be something else that makes me think of Common Lisp,
Xlisp, pLisp and Scheme as "Lisps".
--
Pertti Kellom\"aki, Tampere Univ. of Technology, Software Systems Lab
On 26 Feb 2001 16:34:11 +0200, Kellom{ki Pertti wrote:
> does not make much sense. I came from my home grown Lisp to Xlisp and
> then to Scheme and some Common Lisp without much difficulty. The
> basic feeling of programming in any of the language was more or less
> the same
I don't think it is. In fact, I'm fairly confident that given a
Common Lisp program, I can tell whether it was written by a "Schemer"
or a "Lisper" [and, in fact, I suspect that everyone who says Scheme
is not Lisp will do pretty well at making that distinction, while
those who say it is will do badly...and I'd bet none of us would do
well given a Scheme program...if someone's looking to experiment...]
--
For thæm se the his cræft forlætt, se bið fram thæm cræfte forlæten.
-- Ælfric
(setq reply-to
(concatenate 'string "Paul Foley " "<mycroft" '(··@) "actrix.gen.nz>"))
Paul Foley <·······@actrix.gen.nz> writes:
> On 26 Feb 2001 16:34:11 +0200, Kellom{ki Pertti wrote:
> > The
> > basic feeling of programming in any of the language was more or less
> > the same
> I don't think it is. In fact, I'm fairly confident that given a
> Common Lisp program, I can tell whether it was written by a "Schemer"
> or a "Lisper" [and, in fact, I suspect that everyone who says Scheme
> is not Lisp will do pretty well at making that distinction, while
> those who say it is will do badly...and I'd bet none of us would do
> well given a Scheme program...if someone's looking to experiment...]
I could probably tell from a Scheme program whether it was written by
someone who mostly writes Scheme or by someone who mostly writes
Common Lisp, but that's beside the point. I do not write much Common
Lisp, so it is hardly surprising that I would not write idiomatic
CL. But that is a property of me, not a property of Scheme or Common
Lisp, and certainly tells nothing about whether Scheme and Common Lisp
are "Lisps".
What I was trying to convey was that going from language to language
was pretty much like going from a dialect of Finnish to another. The
vocabulary may be somewhat different and some of the surface syntax
may be different, but the system of expressing oneself is the
same. There are few surprises at the more fundamental level,
e.g. "What do you mean I cannot create an anonymous function and store
it in a binary tree?" Maybe I look at things from a different
perspective being in a natural language minority. For example, all the
Germanic languages are more or less the same to me.
Let me point out that I have no personal investment whatsoever in
whether Scheme is considered to be a Lisp or not. I gain or lose
nothing either way. I am just surprised that other people draw
dividing lines in a way that goes agains my gut feeling (because that
is what all this is really about).
Let me add yet one data point that has not been mentioned so far. I
have my copy of CLtL at home, but the blurb from Amazon seems to
confirm what I remember from the cover of the book:
Common LISP: The Language - MACLISP, SCHEME, SPICELISP, ZETALISP,
STANDARD, LISP, NIL; Digital Press , 1984
Admittedly Steele is a "Schemer" if anyone, so you may disregard this
as just a Schemer's devious attempt to associate Scheme with
Lisp. However, the description of the book goes on to say:
Includes complete COMMON LISP language specifications, precise
descriptions of all standard language constructs, notes on key
differences between COMMON LISP and other dialects, and notes on ways
to implement unique or ambiguous cases.
--
Pertti Kellom\"aki, Tampere Univ. of Technology, Software Systems Lab
>>>>> "Kellom{ki" == Kellom{ki Pertti <··@arokyyhky.cs.tut.fi> writes:
Kellom{ki> Common LISP: The Language - MACLISP, SCHEME, SPICELISP, ZETALISP,
Kellom{ki> STANDARD, LISP, NIL; Digital Press , 1984
Kellom{ki> Admittedly Steele is a "Schemer" if anyone, so you may disregard this
Kellom{ki> as just a Schemer's devious attempt to associate Scheme with
Kellom{ki> Lisp. ...
Hmm, since Steele wrote both the initial Scheme definition AND was
editor on CLtL, perhaps we should regard all of Common Lisp as one big
devious attempt at moving Scheme back in to the Lisp family?
Conspiracy theory is such a rewarding field :-)
Whether or not Scheme is Lisp, then Scheme certainly has a lot in
common with Common Lisp and I am certainly glad for this. In my
project we are in the process of moving a sizable Scheme application
to Common Lisp (using a translator written in Emacs Lisp). I am very
glad that we are moving to Common Lisp and not to something completely
different such as C++ or Java.
I personally think of Scheme as a member of the Lisp family since it
shares a number of (for me) important characteristics such as the
syntax (whether that is wellfounded in RxRs or not). I think that
Larry Wall would agree that the parentheses are a prominent feature of
Lisp languages. Also macros (even though they entered the RnRs pretty
late, but Scheme is more than just RnRs, IMHO) are also a common feature.
However, there is a world of difference between the mindset of the
Scheme community and the Common Lisp community. Scheme is still
fighting hard to release itself of the claws of the language purists
and transcend into the more practically oriented field of applications
programming. Efforts are underways, but it is unclear whether they
will win in the longer term.
------------------------+-----------------------------------------------------
Christian Lynbech | Ericsson Telebit, Skanderborgvej 232, DK-8260 Viby J
Phone: +45 8938 5244 | email: ·················@ted.ericsson.dk
Fax: +45 8938 5101 | web: www.ericsson.com
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
In article <···············@world.std.com>,
Kent M Pitman <······@world.std.com> wrote:
>I can remember lots of serious dialog over the years about how to make
>Lisp more palatable to people that came repeatedly, at one time or
>another, to the same inevitable conclusion: get the substring "lisp"
>out of the name. ... So
>"parens" and the word "lisp" are what tag us as being bad.
:-) All that frenetic battling for exclusive
rights to the name "Lisp", only to feel sorry for
yourself...!
Unseriously,
--d
Dear nagging nag Naggum,
you wrote:
> Funny how the Scheme freaks choose to stand out from the Lisp crowd...
The more funny things is how Common Lispers are all schemers in disguise.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Erik Naggum <····@naggum.net>
> Organization: Naggum Software, Oslo, Norway
> Newsgroups: comp.lang.lisp
> Date: 27 Feb 2001 20:46:25 +0000
> Subject: Re: Is Scheme a `Lisp'?
····@goldshoe.gte.com (Dorai Sitaram) writes:
> In article <···············@world.std.com>,
> Kent M Pitman <······@world.std.com> wrote:
> > I can remember lots of serious dialog over the years about how to
> > make Lisp more palatable to people that came repeatedly, at one
> > time or another, to the same inevitable conclusion: get the
> > substring "lisp" out of the name. ... So "parens" and the word
> > "lisp" are what tag us as being bad.
>
> :-) All that frenetic battling for exclusive rights to the name
> "Lisp", only to feel sorry for yourself...!
I'm responding to this post not because KMP needs someone to state the
obvious, which is that this post is nonsense (though the "Unseriously"
at the end might already indicate that).
The downside of naming a language as a "Lisp" -- especially as time
goes by -- is that it then becomes just another Lisp. I'm more
interested in looking at non-Lisps that have borrowed concepts from
Lisp than other Lisps. Other Lisp systems seem to be some subset of
Common Lisp, with some extra functionality to perform particular
tasks, and a few semantic differences.
My comfort levels with sexps and how much I associated them with Lisp
in general makes it nearly impossible to consider any language a
dialect of Lisp without the lispy syntax.
Since the set of languages which have this syntax are almost all
obviously Lisps, even containing the word "Lisp" in them, and the set
of languages lacking this syntax are just about all obvious non-Lisps,
it's easy to weigh syntax very heavily when defining what Lisp is. I
think that when Scheme was developed, this was even more the case.
But since the Scheme community simply thought differently with many of
the Lisp proponents, the definition of "Lisp" *had* to change;
otherwise (as KMP said recently), the meaning of the word would simply
be watered down.
But this is only one aspect of the driving force behind naming of
languages. When Sun came out with Java, for example, they created a
_new_ name which they spent millions marketing, evangelizing, selling,
and pushing. C++ had already had a name, and among its
implementations, VC++ was huge. So Microsoft released Visual J++ soon
after. This is an example of how Microsoft tried their best to both
provide support for Java, but to deprecate it as nothing more than a
close relative of C++. It's not a matter of true or not true. It's a
matter of a name being used to make people think of it a certain way.
If Microsoft had successfully branded VJ++ and got people to think of
Java as VJ++ half the time, then that certainly would have been a blow
to Sun. They failed, but it was still an excellent marketing
strategy. Since no one's pushing Common Lisp, the common joke "Visual
Lisp++" as an MS-based CL implementation would be a blow to Common
Lisp. CL people (I hope) don't want MS anywhere near their language,
only to ignore the ANSI standard and introduce and water down not just
the name Common Lisp, but the implementation that they could easily
make the most commonly used within a couple of years.
Getting back to KMP's post, and the questionable follow-up, the name
"Scheme" was new, and (from the perspective of the language designers)
would specifically *allow* them to break away from the Lisp community,
which was likely their intention from the start, and not be hindered
by the Lisp legacy, good or bad. Considering where Lisp has gone, and
what Scheme is today, I'm surprised that their community so vehemently
contends that Scheme is a Lisp. Lispy syntax. Some functions in
common. That's about it.
dave
David Bakhash <·····@alum.mit.edu> writes:
> ····@goldshoe.gte.com (Dorai Sitaram) writes:
>
> > In article <···············@world.std.com>,
> > Kent M Pitman <······@world.std.com> wrote:
> > > I can remember lots of serious dialog over the years about how to
> > > make Lisp more palatable to people that came repeatedly, at one
> > > time or another, to the same inevitable conclusion: get the
> > > substring "lisp" out of the name. ... So "parens" and the word
> > > "lisp" are what tag us as being bad.
> >
> > :-) All that frenetic battling for exclusive rights to the name
> > "Lisp", only to feel sorry for yourself...!
>
> I'm responding to this post not because KMP needs someone to state the
> obvious, which is that this post is nonsense (though the "Unseriously"
> at the end might already indicate that).
Well, not everything in the world requires defense. I got the intended
chuckle from Dorai's message. [...]
> Getting back to KMP's post, and the questionable follow-up, the name
> "Scheme" was new, and (from the perspective of the language designers)
> would specifically *allow* them to break away from the Lisp community,
Sticking with this name might have this effect, you could claim. But note
that historically the name Scheme wasn't chosen for this reason. THe original
Scheme came long before anyone knew people would rally around it (and I'm
not so sure people would have rallied around the original definition, though
I personally liked the ealier Scheme dialects better than the modern ones).
It was just one of a series of papers coming out of the AI lab which was
playing a kind of cutesie thesauraus game. Every successful research
idea at the MIT AI lab, and maybe in academia generally, though the ivory tower
being what it was, I never much checked, had to be given some silly metaphor.
You couldn't just think up a way to separate salt from seawater, you had to
give it a good name like Moses and talk about the parting of the waters.
Every major success had a central noun and a bunch of trapping taken from
the vocabulary that the noun evoked. Look at the Actors metaphor, for example.
And the Lisp Machine's Flavors system, with its mixins (you'd have to go
to Steve's Ice Cream to get this joke, I guess, but this referred to the
optional m&m's or crushed oreos or other things you could mix in) and
si:vanilla-flavor. [Sometimes the metaphor would feed back into the real
world, as happened when Toscanini's ice cream, the nearest ice cream place
to the lab, and still to this day by some people's reckoning the best in
the Boston area, perhaps the world, once for a day offered si:vanilla-flavor
as one of its available flavors.] Anyway, all of zthis to say that there
was this whole community of folks doing the study of planning, and there
were a series of paper titles battling over whose way was best. I don't
remember the titles or the ordering, but I think it started with just Planning,
from the Planner language. Then there was the Conniver language, I think,
with a paper about "Why Conniving is better than Planning" and then there
was the first paper on Scheme, and there may have been others. But the reason
it wasn't called Lisp was that Lisp didn't fit the naming pattern they needed
to fit into the ongoing debate. This all happened just before my time and
I was only partly aware of it all at the time, so I'm probably botching some
detail of the explanation or leaving out some other important element, but
maybe now that I've mentioned it someone who remembers better will give a
better account.
> which was likely their intention from the start, and not be hindered
> by the Lisp legacy, good or bad.
I don't know that there was much lisp legacy back then. And to the extent
there was, certainly none of it was bad. People were just playing.
Reinventing for the purpose of stretching their own minds and the minds of
others. Something that's done all too little nowadays, mostly because no
one can afford the luxury now that (as I mentioned Sussman has lamented)
things have gotten popular and people now depend on things to work a certain
way. That's the double-edged nature of progress.
> Considering where Lisp has gone, and
> what Scheme is today, I'm surprised that their community so vehemently
> contends that Scheme is a Lisp. Lispy syntax. Some functions in
> common. That's about it.
I don't know that their community DOES contend that Scheme is a Lisp.
That's why I keep claiming I'm not being exclusionary for saying what I do.
Among those in the Scheme community that I interact with, they could not
care less about the name Lisp. The use of the other community's name
damages each community equally, it seems to me.
MIT Maximum Confusion PDP-10
MC ITS.1488. PWORD.2632.
TTY 57
16. Lusers, Fair Share = 86%
Erik Naggum <····@naggum.net> writes:
> The way I heard this history was that it was called Schemer, but the
> six-character filename limit under some DEC operating system made it
> "Scheme",
ITS, the Incompatible Time-sharing System, was the AI lab's answer to
DEC's CTSS (compatible time-sharing system). Filenames were limited
to six upper case characters.
ITS 1.4 Reference Manual
By Donald E. Eastlake III
AI memo 161, June 1968, 83 pages
Reference: Also published as MAC-M-377.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Erik Naggum <····@naggum.net> writes:
> The way I heard this history was that it was called Schemer, but the
> six-character filename limit under some DEC operating system made it
> "Scheme",
(This is also stated in Steele and Gabriel's paper "The evolution
of Lisp", p 250 in "History of Programming Languages" (1996).)
····················@ling.helsinki.fi.invalid (O-V R:nen) wrote
> Erik Naggum <····@naggum.net> writes:
>
>> The way I heard this history was that it was called Schemer, but the
>> six-character filename limit under some DEC operating system made it
>> "Scheme",
>
> (This is also stated in Steele and Gabriel's paper "The evolution
> of Lisp", p 250 in "History of Programming Languages" (1996).)
yes and yes, in the age of the internet, every moron can sound like a
historian. May I -- an also-ran -- present:
Scheme Frequently Asked Questions and answers
http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/scheme/part1/faq-doc-14.h
tml
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
>>>>> On 01 Mar 2001 13:43:22 +0000, Erik Naggum ("Erik") writes:
Erik> * Kent M Pitman <······@world.std.com>
>> Then there was the Conniver language, I think, with a paper about "Why
>> Conniving is better than Planning" and then there was the first paper on
>> Scheme, and there may have been others.
Erik> The way I heard this history was that it was called Schemer, but the
Erik> six-character filename limit under some DEC operating system made it "Scheme"
Kent has got the name of the paper and the general history correct.
(I have all those papers in my library.) The operating system that
Erik is referring to is almost certainly not a DEC operating system,
but ITS, the Incompatible Timesharing System. ITS was a completely
home-grown system written at Project Mac for the AI Lab's (PDP-10)
computer. ITS supported filenames that were six characters long,
although each file had two names (the second name was used either
as a type extension like LISP or FASL, or else a version number).
ITS was a great operating system, and was the home of TECO, EMACS,
MACLISP, MACSYMA, SHRDLU, ZORK, and every other thing you heard of.
It is quite believable that SCHEME wanted to be called Schemer,
in the same vein as Planner and Conniver.
Christopher Stacy <······@spacy.Boston.MA.US> writes:
> It is quite believable that SCHEME wanted to be called Schemer, in
> the same vein as Planner and Conniver.
And a crucial factor here is the fact these were intentionally puns or
similar. There are fairly often gripes about "things schemely"
involving some nefarious intention, sometimes involving complaining
about the FSF people being dishonest because they took on the further
pun of calling their Scheme "Guile."
Missing the point that it's all a game of playing on words.
--
(reverse (concatenate 'string ··········@" "enworbbc"))
http://vip.hyperusa.com/~cbbrowne/finances.html
"When we write programs that "learn", it turns out that we do and they
don't." -- Alan Perlis
In article <·············@spacy.Boston.MA.US>, Christopher Stacy
<······@spacy.Boston.MA.US> wrote:
>>>>>> On 01 Mar 2001 13:43:22 +0000, Erik Naggum ("Erik") writes:
> Erik> * Kent M Pitman <······@world.std.com>
> >> Then there was the Conniver language, I think, with a paper about "Why
> >> Conniving is better than Planning" and then there was the first paper on
> >> Scheme, and there may have been others.
> Erik> The way I heard this history was that it was called Schemer, but the
> Erik> six-character filename limit under some DEC operating system
made it "Scheme"
>
>Kent has got the name of the paper and the general history correct.
>(I have all those papers in my library.) The operating system that
>Erik is referring to is almost certainly not a DEC operating system,
>but ITS, the Incompatible Timesharing System. ITS was a completely
>home-grown system written at Project Mac for the AI Lab's (PDP-10)
>computer. ITS supported filenames that were six characters long,
>although each file had two names (the second name was used either
>as a type extension like LISP or FASL, or else a version number).
>ITS was a great operating system, and was the home of TECO, EMACS,
>MACLISP, MACSYMA, SHRDLU, ZORK, and every other thing you heard of.
>It is quite believable that SCHEME wanted to be called Schemer,
>in the same vein as Planner and Conniver.
steele and gabriel's "evolution of lisp" paper confirms that:
(1) scheme was written as steele and sussman were trying to understand
the "actor" notion of computation in hewitt's "planner" and "conniver"
languages.
(2) they developed it in maclisp running under ITS.
(3) they intended to call it "schemer" but this was truncated in
concordance with the 6-character limit.
sashank
Joe Marshall <···@content-integrity.com> wrote:
+---------------
| Kent M Pitman <······@world.std.com> writes:
| > get the substring "lisp" out of the name.
|
| Visual L++
| L#
| It worked for mumps.
+---------------
You mean M, of course. ;-} (MUMPS is dead; long live MUMPS!)
-Rob
-----
Rob Warnock, 31-2-510 ····@sgi.com
SGI Network Engineering <URL:http://reality.sgi.com/rpw3/>
1600 Amphitheatre Pkwy. Phone: 650-933-1673
Mountain View, CA 94043 PP-ASEL-IA
Talking about a possible bias amongst the Scheme authors towards
keeping Scheme as a "non-practical" research langauge, Kent M Pitman
<······@world.std.com> writes:
> Dylan was, I thought, an attempt to make a practical Scheme.
Eulisp seemed to be another.
--
T. Kurt Bond, ···@tkb.mpl.com
>>>>> "Kent" == Kent M Pitman <······@world.std.com> writes:
Kent> Special variables...
Kent> FORMAT ...
Kent> Class system...
If we are down to these kinds of details, we really need to define
more specifically what we mean when we say `Scheme'. The RnRs standard
is so pathetic^H^H^H^H^H^H^H^H puristic that very few Scheme
implementation implements that and nothing else.
With the above, we have:
- slib (generic scheme library) has a pretty close port of
FORMAT (plus bunches of other CL functionality)
- at least Guile Scheme has something that works like special
variables (called `fluids')
- most practical scheme systems that I know about has OO
extensions, including almost-CLOS power in STk and Guile,
and there is tiny-clos which is a port of Gregory Kiczales'
Closette from AMOP to pretty generic scheme.
Kent> Macros, heavily used at least in CL and increasingly used in
Kent> Scheme, are done in a wholly different way, too, that seems
Kent> to my quick glance like something that would not translate
Kent> at all well automatically. (Maybe someone who has studied
Kent> this in detail can say say otherwise.)
Many implementations has traditional defmacro facilities. Slib has
implementations of some of the various hygenic macros systems in terms
of defmacro like systems.
------------------------+-----------------------------------------------------
Christian Lynbech | Ericsson Telebit, Skanderborgvej 232, DK-8260 Viby J
Phone: +45 8938 5244 | email: ·················@ted.ericsson.dk
Fax: +45 8938 5101 | web: www.ericsson.com
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
Christian Lynbech <···@tbit.dk> writes:
> >>>>> "Kent" == Kent M Pitman <······@world.std.com> writes:
>
> Kent> Special variables...
>
> Kent> FORMAT ...
>
> Kent> Class system...
>
> If we are down to these kinds of details, we really need to define
> more specifically what we mean when we say `Scheme'. The RnRs standard
> is so pathetic^H^H^H^H^H^H^H^H puristic that very few Scheme
> implementation implements that and nothing else.
>
> With the above, we have:
>
> - slib (generic scheme library) has a pretty close port of
> FORMAT (plus bunches of other CL functionality)
Then why not use CL? (Instead of reimplementing the wheel over and
over and over and over, until you get the last wheel on the block avec
forced indentation :) )
>
> - at least Guile Scheme has something that works like special
> variables (called `fluids')
What's wrong with DEFVAR and (DECLAIM (SPECIAL FOO)) ? (What about
systems that do not have them?)
> - most practical scheme systems that I know about has OO
> extensions, including almost-CLOS power in STk and Guile,
> and there is tiny-clos which is a port of Gregory Kiczales'
> Closette from AMOP to pretty generic scheme.
Again, then why not use CL? (note that most implementations are
slightly incompatible).
> Kent> Macros, heavily used at least in CL and increasingly used in
> Kent> Scheme, are done in a wholly different way, too, that seems
> Kent> to my quick glance like something that would not translate
> Kent> at all well automatically. (Maybe someone who has studied
> Kent> this in detail can say say otherwise.)
>
> Many implementations has traditional defmacro facilities. Slib has
> implementations of some of the various hygenic macros systems in terms
> of defmacro like systems.
If you have DEFMACRO.... Again, WHY NOT USE CL INSTEAD???????
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
Like DNA, such a language [Lisp] does not go out of style.
Paul Graham, ANSI Common Lisp
In article <···············@octagon.mrl.nyu.edu>,
Marco Antoniotti <·······@cs.nyu.edu> wrote:
>Then why not use CL? (Instead of reimplementing the wheel over and
>over and over and over, until you get the last wheel on the block avec
>forced indentation :) )
>
>What's wrong with DEFVAR and (DECLAIM (SPECIAL FOO)) ? (What about
>systems that do not have them?)
>
>Again, then why not use CL? (note that most implementations are
>slightly incompatible).
>
>If you have DEFMACRO.... Again, WHY NOT USE CL INSTEAD???????
>
Just plain lack of skill, perhaps? Kent Pitman and
others here have pointed out, fairly persuasively I
think, that Scheme programmers (except for a very few
happy exceptions) generally lack the skills needed to
write even passable CL, and not for lack of
trying. The ability to translate bits of
vocabulary from a language does not automatically scale
to an ability to function completely in that language.
--d
····@goldshoe.gte.com (Dorai Sitaram) writes:
> In article <···············@octagon.mrl.nyu.edu>,
> Marco Antoniotti <·······@cs.nyu.edu> wrote:
> >Then why not use CL? (Instead of reimplementing the wheel over and
> >over and over and over, until you get the last wheel on the block avec
> >forced indentation :) )
> >
> >What's wrong with DEFVAR and (DECLAIM (SPECIAL FOO)) ? (What about
> >systems that do not have them?)
> >
> >Again, then why not use CL? (note that most implementations are
> >slightly incompatible).
> >
> >If you have DEFMACRO.... Again, WHY NOT USE CL INSTEAD???????
> >
>
> Just plain lack of skill, perhaps? Kent Pitman and
> others here have pointed out, fairly persuasively I
> think, that Scheme programmers (except for a very few
> happy exceptions) generally lack the skills needed to
> write even passable CL, and not for lack of
> trying. The ability to translate bits of
> vocabulary from a language does not automatically scale
> to an ability to function completely in that language.
Well, but Scheme is a Lisp isn't it? So why not use the more powerful
and standardized tool? :)
Seriously, I do not buy the "lack of skill" argument. You can do
without call/cc (anybody in his right mind would not use call/cc for
high level programming) and without (let loop ((...)) ...) very very
very easily.
What else stops the average Scheme guy from seeing the light? (And
start working on much more serious open problems in CL?)
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
Like DNA, such a language [Lisp] does not go out of style.
Paul Graham, ANSI Common Lisp
Marco Antoniotti <·······@cs.nyu.edu> writes:
> Well, but Scheme is a Lisp isn't it? So why not use the more powerful
> and standardized tool? :)
[...]
> What else stops the average Scheme guy from seeing the light? (And
> start working on much more serious open problems in CL?)
I thought it was already well established that Scheme and Common Lisp
differ rather dramatically in some ways. The fact that Schemers have
not flocked to CL and vice versa is empirical evidence that some
people prefer some set of design decisions while others prefer another
set of design decisions.
Let me put it this way. If I were to start a large project involving
business risks, I would most likely choose Common Lisp over
Scheme. Why? Because of the existence of several alternative
commercial implemenentations, existence of people like Erik Naggum who
have first hand experience in successfully utilizing Common Lisp in a
commercial setting and are willing to share their experience, tools like
defsystem, etc. etc.
Most of the stuff really has very little to do with any of the
differences between Scheme and CL. The fact that Common Lisp is a well
thought out member of the Lisp family with proper formal and informal
support is the key. Anyone claiming it is the sole global optimum has
a very large blind spot indeed. Also, the key differences are between
implementations, not between languages. I concede that CL contains
more useful standardized stuff, but I've never seen anyone refute
that either. Scheme as defined by RnRS is not and does not claim to be
a big systems language.
None of this really has anything to do with the subject of the thread
any more either. In a situation where implementations are on a more
equal footing, I fail to see why the average Scheme guy should switch
to CL. Would he be dramatically more productive? Would it be more fun?
If the open problems in CL you are referring to are things like GUI or
network libraries, I could not really care less. If every CL came with
a superb GUI library, that would be really nice and a good reason to
use CL. However, I have no interest in putting effort into building
such a beast either.
--
Pertti Kellom\"aki, Tampere Univ. of Technology, Software Systems Lab
Kellom{ki Pertti <··@arokyyhky.cs.tut.fi> writes:
> Let me put it this way. If I were to start a large project involving
> business risks, I would most likely choose Common Lisp over
> Scheme. Why? Because of the existence of several alternative
> commercial implemenentations, [...]
> Most of the stuff really has very little to do with any of the
> differences between Scheme and CL.
If you don't believe that one of the differences between Scheme and CL is
that the Scheme people actively value keeping their spec very short by
providing as little information as possible for their functions, and you
don't see this as a barrier to compatible implementations, then I guess
you would say this. Scheme has, at every opportunity, left things to
the implementors where they didn't want to specify a detail. By contrast,
just to pick an example, CL specifies a total ordering of the class precedence
list even when the user has underspecified it, exactly so that implementations
won't deviate during porting. There are numerous such decisios made in CL,
where we didn't HAVE to specify something, but where we did in order to
support cross-vendor compatibility and second sourcing. This is, I claim,
an intrinsic feature of CL that we have spent man-years of haggling and
specification-time on and that is absent in Scheme. I know because I have
raised the issue in the Scheme design meetings and people have not seen it
as a priority.
Of course, if you think all there is to a language is words on paper and
you think they just appear there magically and not by a process of people
and discussion and ideologies and antipathies and fear and joy and resource
constraints and personal ideosyncracies of the person holding the pen, then
you would have a different point of view. This would seem to me the
programming equivalent of treating all diseases with drugs and never telling
anyone to just wash their hands before they eat in the hopes that maybe
that would sometimes matter, too.
My thesis in this thread is that languages are political parties. They change
every time you issue a new spec, so what is held constant that entitles you
to keep the same name? The constituency they serve.
Kent M Pitman <······@world.std.com> writes:
> There are numerous such decisios made in CL,
> where we didn't HAVE to specify something, but where we did in order to
> support cross-vendor compatibility and second sourcing. This is, I claim,
> an intrinsic feature of CL that we have spent man-years of haggling and
> specification-time on and that is absent in Scheme.
We are in a violent agreement on this point. I do not see how the
presence of these decisions in CL and absence in Scheme affect their
respective lispness, though.
> My thesis in this thread is that languages are political parties. They change
> every time you issue a new spec, so what is held constant that entitles you
> to keep the same name? The constituency they serve.
I only buy into this partially. If Common Lisp somehow drifted to
become a statically typed infix language, would you still call it a
Lisp?
To someone like me who has never been to L&FP conferences, never been
to a LUG meeting and never seen Scheme evangelists in live action, the
only way to compare languages is to look at them as technical
artefacts.
--
Pertti Kellom\"aki, Tampere Univ. of Technology, Software Systems Lab
Marco Antoniotti <·······@cs.nyu.edu> writes:
> ····@goldshoe.gte.com (Dorai Sitaram) writes:
>
> > In article <···············@octagon.mrl.nyu.edu>,
> > Marco Antoniotti <·······@cs.nyu.edu> wrote:
> > [...]
> > >If you have DEFMACRO.... Again, WHY NOT USE CL INSTEAD???????
> >
> > Just plain lack of skill, perhaps? Kent Pitman and
> > others here have pointed out, fairly persuasively I
> > think, that Scheme programmers (except for a very few
> > happy exceptions) generally lack the skills needed to
> > write even passable CL, and not for lack of
I don't know that I've made so sweeping a claim as "generally", which
I would assume implies a "large percentage". I don't have numbers to
back that up. I could go for "frequently" since in my career I've bumped
into quite a number of people who learned Scheme and were trying to puzzle
out CL, and in the experience of the sample I've dealt with, this has been
very common.
I also don't know if it's that they lack the skills as that it has been so
consistently drilled into them as a religious point that they must not
use those skills. They KNOW what iteration is, for example, but they've
been taught that iteration is bad and one must only tail recurse. And they
try in vain to make it work and can't. I think they know what non-local
return is and what stacks are, but they've been taught stacks are
capital-B Bad and that first-class continuations are capital-G Good.
> > trying. The ability to translate bits of
> > vocabulary from a language does not automatically scale
> > to an ability to function completely in that language.
>
> Well, but Scheme is a Lisp isn't it? So why not use the more powerful
> and standardized tool? :)
>
> Seriously, I do not buy the "lack of skill" argument. You can do
> without call/cc (anybody in his right mind would not use call/cc for
> high level programming) and without (let loop ((...)) ...) very very
> very easily.
I agree. This is like saying a vegetarian
lacks the skill to eat meat. That's not what's going on. They're making
a reasoned choice. Just one I don't agree with.
> What else stops the average Scheme guy from seeing the light? (And
> start working on much more serious open problems in CL?)
Religious training. Scheme has become a religion. I have far less objection
to it technically than I do religiously. The people who merely use it
technically, and are not into the accompanying ideology--that is, the people
who aren't into telling me that I shouldn't have both WHEN and UNLESS
because thy're redundant, and who can simply cope with depriving themselves
of one or the other without infliciting the deprivation on me, are usually ok.
I don't have a deathwish for religion, mind you. As a thought process,
religion can be fine. But as a dogma, it's not. I hate being with someone
who is a "religious follower" to the extent that you can tell them a joke
and they don't know whether they're allowed to laugh without consulting
someone in the faith who they trust to tell them if it's ok. The Scheme
community has, in my personal experience, and someone is welcome to tell
me my experiences are unique and unrepresentative, bread a lot of these
kinds of people. (The main other kind I've seen are people who didn't
understand the ideology that was being preached and came out unable to
understand anything, because the teacher was unwilling to tell them that
there were other manners of expression that might have worked for them...)
In article <···············@octagon.mrl.nyu.edu>,
Marco Antoniotti <·······@cs.nyu.edu> wrote:
>
>····@goldshoe.gte.com (Dorai Sitaram) writes:
>>
>> Just plain lack of skill, perhaps? Kent Pitman and
>> others here have pointed out, fairly persuasively I
>> think, that Scheme programmers (except for a very few
>> happy exceptions) generally lack the skills needed to
>> write even passable CL, and not for lack of
>> trying. The ability to translate bits of
>> vocabulary from a language does not automatically scale
>> to an ability to function completely in that language.
>
>Well, but Scheme is a Lisp isn't it? So why not use the more powerful
>and standardized tool? :)
You are underestimating the depth of your skill in and
internalization of CL. It is going to be very
difficult to duplicate that in others. There is a
reason that Common Lispers are a select and respected
group, rare and expensive.
>Seriously, I do not buy the "lack of skill" argument. You can do
>without call/cc (anybody in his right mind would not use call/cc for
>high level programming) and without (let loop ((...)) ...) very very
>very easily.
>
>What else stops the average Scheme guy from seeing the light? (And
>start working on much more serious open problems in CL?)
Lack of skills seems a pretty overwhelming reason to
me.
--d
On 27 Feb 2001, Marco Antoniotti wrote:
[snip]
> Well, but Scheme is a Lisp isn't it? So why not use the more powerful
> and standardized tool? :)
[snip]
> What else stops the average Scheme guy from seeing the light? (And
> start working on much more serious open problems in CL?)
[snip]
Two possible explanatory factors:
1) Preference. (If you like your lisp in an algol sauce, or is that
your algol oatmeal with garishly lacquered fingernail parings on
top, you'll prefer a Scheme. :) Or, for example, let's say you
know core Scheme, and you have a need to write cross mac/unix/
windows GUI apps in a libre, free beer environment, you might
find that DrScheme does the job just fine. Why work to fix the
holes in CL if you can get everything you need as it stands?
Plus, DrScheme (for example) seems to have a reasonable user base
and some good developers.
You're definitely implementation dependant in that circumstance,
but (if you need a GUI) I don't see a comperable *platform*
portable solution ready-to-hand (yet) for CL.
It's interesting to compare with Smalltalk, which only a few years
got a ANSI standard which defines much less than the CL one. (Of
course, there was the Blue Book which was pretty much the
*de facto* standard (with several blessed implementations), which
makes things a little different.)
In any case, you now have 6-9 implementations with substantial
user bases, usually sharing a (very small) core language, a fair
number of libraries, and then *huge* variation. Migration and
porting between implementation ranges from trivial, to
automatable, to a gigantic pain in the tuckus. Yet, it doesn't
*greatly* bother me. Indeed, much of the time, I enjoy the
differences. I'd like to see some things more standardized, and I
certainly am not a typical or business case, so while it's not
a showstopper for me, I can certainly see how it would be for
others. I will say that I tend to value cross platform
standarization over cross-implementation standardization. So,
both Squeak and VisualWorks work (fairly) seemlessly across
a *wide* range of platforms, there are large differences between
the two dialects that--depending on what you use--can main
moving code between them a real nightmare. But, in this case,
the cross platform is what dominates for me.)
2) Ok, I blurred them :) The second was going to be that the wide
implementation diversity. You can get tiny schemes and huge
schemes. You can make your own scheme. Free schemes, libre
schemes, free libre schemes, expensive schemes, etc. For most
any platform from the PalmPilot and WinCE on up.
There's something to be said for that. It *may* be easier for
certain folks to find a scheme to their taste. Having a standard
well understood core may ease the pain of switching
implementations (for some folks).
It certainly seems somewhat easier to get hold of and get running an
interesting scheme system, so if one wants to dabble the barrier to entry
is lower.
Of course, these values are primarily aspects of scheme implementations,
so don't bear directly on the respective *languages*.
Er..if your questions were rhetorical, I hope you didn't read this far :)
Cheers,
Bijan Parsia.
Bijan Parsia <·······@email.unc.edu> writes:
> On 27 Feb 2001, Marco Antoniotti wrote:
> [snip]
> > Well, but Scheme is a Lisp isn't it? So why not use the more powerful
> > and standardized tool? :)
> [snip]
> > What else stops the average Scheme guy from seeing the light? (And
> > start working on much more serious open problems in CL?)
> [snip]
>
> Two possible explanatory factors:
>
> 1) Preference. (If you like your lisp in an algol sauce, or is that
...
I'll skip the first one.
>
> 2) Ok, I blurred them :) The second was going to be that the wide
> implementation diversity. You can get tiny schemes and huge
> schemes. You can make your own scheme. Free schemes, libre
> schemes, free libre schemes, expensive schemes, etc. For most
> any platform from the PalmPilot and WinCE on up.
I believe this is the real reason. People love to while away
especially in individualized endevours. Alas, also writing in CL has
this feeling right now. However, this is no excuse for wasting time
re-implementing the (1+ *godzillion*) slightly or very incompatible
Scheme variety.
> There's something to be said for that. It *may* be easier for
> certain folks to find a scheme to their taste. Having a standard
> well understood core may ease the pain of switching
> implementations (for some folks).
CL has a standard and well understood core. CL implementations are
available for all platforms.
> It certainly seems somewhat easier to get hold of and get running an
> interesting scheme system, so if one wants to dabble the barrier to entry
> is lower.
>
> Of course, these values are primarily aspects of scheme implementations,
> so don't bear directly on the respective *languages*.
Of course. CL has way more useful features than Scheme.
> Er..if your questions were rhetorical, I hope you didn't read this far :)
My question was not quite rethorical. I simply want to dare any
Scheme programmer to stop working with Scheme and come over the Dark
Side :) Note that the opposite can't be done. Scheme is too bare
bone and lacking features to be used for serious programming.
BTW. I tried to stay out of this. But I simply cannot. This is as
irrational as using Scheme instead of CL. I guess that by using CL I
am a bad person.
Yet, remember: good people sleep well at night, OTOH, bad people enjoy
much more the waking hours. (W. Allen)
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
Like DNA, such a language [Lisp] does not go out of style.
Paul Graham, ANSI Common Lisp
Dear Dorai,
Some folks in this thread have "I HATE SCHEME" tattooed to their foreheads.
No wonder they need to don on hats in Scheme meetings.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: ····@goldshoe.gte.com (Dorai Sitaram)
> Organization: GTE Laboratories Incorporated
> Newsgroups: comp.lang.lisp
> Date: 28 Feb 2001 00:50:07 GMT
> Subject: Re: Is Scheme a `Lisp'?
>>>>> "Marco" == Marco Antoniotti <·······@cs.nyu.edu> writes:
Marco> If you have DEFMACRO.... Again, WHY NOT USE CL INSTEAD???????
We are probably going to (we are pretty busy looking into the
feasibilty of it at the moment).
But when we made the initial choice of using Scheme, we had fewer
options open to us than we have today, and a more severe lack of
general knowledge about the lisp/scheme field.
We were at the time a small independent company and thus was not able
to pay big bucks for a commercial system, and we were initially
targeting a Transputer based embedded system, without heaps of memory,
leaving out all of the native code based systems.
I was also under the impression that common lisp systems were
necessarily big and bulky, and going with Guile Scheme seemed to make
sense, since it appeared to be smaller, had source code, a business
compatible license, a near-CLOS-power object system and a very active
user community (something that was very important to us, being the
small company we were). Guile Scheme is interpreted, but the Hobbit
Scheme->C compiler had been ported to the Guile Scheme environment.
After the initial work had begun, several things happened, including
hearing at the Lisp Users Meeting in Amsterdam that Franz had been
able to squeeze their runtime system down to about 700Kb which really
changed my view on the field of possible solutions. Also we had
several major disappointments with Guile Scheme (poor performance,
runtime was small but the application still was big, poor debugging,
no profiling).
If I was going to start the project today, with all the things I have
learned over the last 3 years, I would probably have started out with
ECL (though it is a pretty dead project) or CLISP (though it does not
have threads).
------------------------+-----------------------------------------------------
Christian Lynbech | Ericsson Telebit, Skanderborgvej 232, DK-8260 Viby J
Phone: +45 8938 5244 | email: ·················@ted.ericsson.dk
Fax: +45 8938 5101 | web: www.ericsson.com
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
Christian Lynbech <···@tbit.dk> writes:
> If I was going to start the project today, with all the things I have
> learned over the last 3 years, I would probably have started out with
> ECL (though it is a pretty dead project) or CLISP (though it does not
> have threads).
Note though that ECLS (aka. EcoLisp-Spain, IIRC) is currently quite
active, and seems to be moving along nicely to bringing ECL
up-to-date.
Regs, Pierre.
--
Pierre R. Mai <····@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
Christian Lynbech <···@tbit.dk> writes:
> If we are down to these kinds of details, we really need to define
> more specifically what we mean when we say `Scheme'. The RnRs standard
> is so pathetic^H^H^H^H^H^H^H^H puristic that very few Scheme
> implementation implements that and nothing else.
Likewise for nearly every standardized language in the known
universe. But that is irrelevant to the scope of this discussion,
unless you really want to say that there is no language named Scheme,
but rather 100 different implementation-defined languages.
If that is the case, then by implication, Scheme is not a Lisp, since
it is not a language (at least for my personal lisp type, which also
excludes 42 on this basis).
And can we please stop treating the Lisp label as some kind of quality
badge in this discussion? The qualities of Scheme as a language are
totally orthogonal to it being a language in the Lisp family of
languages or not.
Regs, Pierre.
--
Pierre R. Mai <····@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
Dear Pierre R. Mai,
(defun language-lisp-p (language) (if (search "Lisp" (language-name
language) :test #'char-equal) t nil)) (deftype lisp () `(and language
(satisfies language-lisp-p)))
(typep (make-language :name "I am Scheme, and you spell my name Lisp")
'lisp)
T
Your scheme when taken to extreme, woman becomes man, and that is really,
REALLY woeful.
At least now you too, concede that Scheme is a Lisp.
This thread now without Xah's guidance is like a headless horseman. I would
if i have time, but what's that linguistic joke?
http://ourworld.compuserve.com/homepages/WJHutchins/Myths.htm
I didn't realize THAT!
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: "Pierre R. Mai" <····@acm.org>
> Organization: Pretty Much Science Fiction --- www.pmsf.de
> Newsgroups: comp.lang.lisp
> Date: 28 Feb 2001 01:35:51 +0100
> Subject: Re: Is Scheme a `Lisp'?
Xah Lee <···@xahlee.org> writes:
> (defun language-lisp-p (language) (if (search "Lisp" (language-name
> language) :test #'char-equal) t nil)) (deftype lisp () `(and language
> (satisfies language-lisp-p)))
>
>
> (typep (make-language :name "I am Scheme, and you spell my name Lisp")
> 'lisp)
>
> T
Oh, I've no problem calling Scheme a Lisp if all Schemers were to
adopt your spelling of the language as the official name.
Or better yet, since
* (typep
(make-language :name "I am Scheme, a wonderful language, without a Lisp")
'lisp)
T
use that name instead.
> Your scheme when taken to extreme, woman becomes man, and that is really,
> REALLY woeful.
That is not true, because neither man nor woman are members of the
domain of my type predicate. Your need to wrongly overgeneralize is
not my fault.
> At least now you too, concede that Scheme is a Lisp.
I do no such thing. First you'll have to specify which predicate
constrains membership of the set of all Lisp languages. Without that,
the membership of the set is not well defined, and hence meaningless.
Unless of course you accept my predicate, which I'll take as
acceptance of the new official name of "I am Scheme, a wonderful
language, without a Lisp".
Regs, Pierre.
--
Pierre R. Mai <····@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
>>>>> "Pierre" == Pierre R Mai <····@acm.org> writes:
Pierre> Christian Lynbech <···@tbit.dk> writes:
>> If we are down to these kinds of details, we really need to define
>> more specifically what we mean when we say `Scheme'. The RnRs standard
>> is so pathetic^H^H^H^H^H^H^H^H puristic that very few Scheme
>> implementation implements that and nothing else.
Pierre> Likewise for nearly every standardized language in the known
Pierre> universe. But that is irrelevant to the scope of this discussion,
Pierre> unless you really want to say that there is no language named Scheme,
Pierre> but rather 100 different implementation-defined languages.
Fair enough. All I really asked for was a definition, and
Scheme == RnRs
certainly is such a definition.
Pierre> And can we please stop treating the Lisp label as some kind of quality
Pierre> badge in this discussion? The qualities of Scheme as a language are
Pierre> totally orthogonal to it being a language in the Lisp family of
Pierre> languages or not.
I was unaware that I was doing this.
I was just trying to point out that if a number of specific features
such as FORMAT and DEFMACRO is the hallmark of being a lisp, then a
number of scheme implementations (such as Guile Scheme) could be
considered a member of the family as well, not through compliance with
RnRs but by virtue of the set of features available in that
implementation.
------------------------+-----------------------------------------------------
Christian Lynbech | Ericsson Telebit, Skanderborgvej 232, DK-8260 Viby J
Phone: +45 8938 5244 | email: ·················@ted.ericsson.dk
Fax: +45 8938 5101 | web: www.ericsson.com
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
Kellom{ki Pertti <··@arokyyhky.cs.tut.fi> writes:
> The whole discussion is like someone claiming that a Volkswagen
> Beetle is not a car, because it is so different from an Opel Astra.
Here, in Latvia, we used to say -- every car becomes an Opel sooner or
later :)
--
Janis Dzerins
If million people say a stupid thing it's still a stupid thing.
On Mon, 26 Feb 2001 00:22:50 GMT, Xah Lee wrote:
> In one sentence: Whether Scheme is a Lisp. In more elaborate term: Whether
> Scheme is a dialect of Lisp. In more explicit form it can be rephrased as:
> Do you consider it true, that Scheme is a dialect of Lisp.
> (note: this is different from "Do you consider that Scheme is a dialect of
> Lisp.")
You can consider it true that Scheme is a dialect of Lisp while not
considering Scheme a dialect of Lisp, or vice versa? [Well, that
doesn't really surprise me coming from Xah...]
Scheme is a dialect of Lisp in much the same way that gorillas are a
"dialect" of human. I.e., way back in prehistory (or at least before
some of the people reading this were born) they may have had some
common ancestor, but the modern descendants of that common ancestor
are neither particularly similar to that ancestor nor to each other.
[To suit Xah's apparent need for explicitness, today: No, I don't
ordinarily consider Scheme to be a dialect of Lisp.]
--
For thæm se the his cræft forlætt, se bið fram thæm cræfte forlæten.
-- Ælfric
(setq reply-to
(concatenate 'string "Paul Foley " "<mycroft" '(··@) "actrix.gen.nz>"))
Paul Foley <·······@actrix.gen.nz> writes:
> Scheme is a dialect of Lisp in much the same way that gorillas are a
> "dialect" of human.
I find this analogy to be poor insofar as the topic need no analogy to
other branches of taxonomy.
However, it is useful as far as demonstrating that though our genetics
with gorillas is vastly similar, and that basic body form and size is
similar, that still, we weight the differences very heavily.
Here, we're talking about a definition of the word "Lisp", where Lisp
is meant to designate a family of languages. As PM pointed out, it is
this *word* that we're discussing, and the decision to not even
include Lisp in the name (Scheme) was probably the best thing they
ever did to help keep the idea of what Lisp is pure. If they'd called
it "LispScheme", it would only bother me marginally, since most people
would guess that in the long life of something like Lisp, some
bastardizations would come about. But thankfully, the language Scheme
bore its own name, and went its own way. Obviously, it is without
question that they borrowed several ideas from Lisp, but that doesn't
make it definitively a Lisp (similar case with Dylan). It just meant
that they were aware of Lisp, and incorporated some of the ideas
(some central to Lisp, in my opinion).
To repeat what others have said, the more people think of Common Lisp
as defining what Lisp is, and relative proxmity to CL being Lisp-like,
the far less Scheme is anything of a Lisp. Common lisp is just messy
enough to make most solutions relatively elegant in what might appear
to be an all-over-the-place[1] language. Scheme, on the other hand,
is a language that has avoided these issues to make the language
itself look elegant. Viewing even a moderately complex project
implemented in Scheme would show most people just how
all-over-the-place Scheme is once you put it to the test. Not so for
Common Lisp. To me, the Lisp family adopts the view of "how to make
the overall solutions elegant" not just "how to make the language seem
elegant in and of itself". This is why I openly hate Scheme, and
avoid it as much as possible, as well as languages that remind me of
it, like C.
dave
David Bakhash <·····@alum.mit.edu> writes:
> ... an all-over-the-place[1] language
[1] "all-over-the-place" is the best I could do to describe what I
meant. CL is so many things, and so large to me, and I don't know
a good word to describe it. If I had to pick a word to describe
it, it might be a "masterbeast".
David Bakhash <·····@alum.mit.edu> writes:
> If they'd called it "LispScheme", it would only bother me
> marginally, since most people would guess that in the long life of
> something like Lisp, some bastardizations would come about.
Actually, there's a branch of psychology which studies the issue of what
is or can be regarded as a "natural concept". I took a course on this
in college and remember only the barest number of details; perhaps someone
who tracks these kinds of things will correct me and/or elaborate.
My recollection, though, is that my instructor, Dan Osherson of MIT,
was big on the idea that concepts linked by "or" were unlikely
candidates for "natural concepts" (things that feel good to think
about or are easy to reason about). For example, you can name the set
of things that are green on tuesday or blue otherwise, but you
probably don't have a lot of things to say about this set because this
is not a natural concept. On the other hand, things that are
connected by "and" are likely candidates to be natural concepts.
e.g., things that are both "blue" and "tall". Structurally, I would
say that what the psychologists were arriving at empirically is the
same thing as we in computer science have come about
operationally--that it's useful to have class hierarchies but it's
less useful descriptionally to to have "or". So, for example,
although some languages may have dallied in it slightly (Dylan
perhaps?), we generally don't write method dispatch on union classes.
I think the reason is that it's hard to say what the priority is of
conflicting methods that are taken from union classes, while it is
more easily possible to impose a method ordering on subclass chains
(which it seems to me that "and" can be regarded as).
So when you talk about SchemeLisp, you beg the question because you
don't know if the relationship is a union relationship of two distant
classes or redundant (in the sense that Lisp already comprises Scheme)
or whatever. Certainly any set can be named, but is it predictively
meaningful to do that? Would you know anything about the set?
I think operationally it matters to me whether Scheme is a Lisp, and I
think it matters to Schemers, too, is that in practice at a job when
one asks to use a Lisp, one may be told to use Scheme, and this may or
may not be acceptable. Personally, I'd often prefer to use Java than
Scheme. To me, CL is about having useful stuff laying around ready to
use, and Java at least shares that spirit. By contrast, Scheme seems to
me often an exercise in deprivation, and that's not my first choice to
get work done.
I think operationally it also matters because if you think Scheme and
Common Lisp are both just "kinds of Lisp", then everything Scheme does
reflects on Lisp and everything Common Lisp does reflects on Scheme
because people who are not "in the know" tend to reflect upward to a
level of abstraction they find more comfortable. If a manager can't
program in either CL or Scheme and belives Lisp is the superclass, he'll
attach all his knowledge of success/failure or style or power or
programmer availability to the superclass since it keeps him from
putting it on an inappropriate subclass.
And the reason THAT matters is that I personally find it annoying that
most people are taught that CL is about writing your programs in an
obscure functional style. I'm all for functional, but CL is
specifically about allowing myriad other styles. It's fine that
Scheme is willing to hitch itself to the star of tail recursion and
win or lose on that basis, but Lisp, certainly Common Lisp, is more
varied than that. And when typical classes teach "normal" programming
in Java (makes sense to me, since it's the commodity language) but
then teach "the leftovers" (functional, recursive, etc.) in
Scheme/Lisp, it gives the false impression that "the leftovers" is all
the other thing can do, rather than that Scheme/Lisp are maybe good
for both "normal" programming AND "functional, recursive, etc." The
Scheme community thinks this is a win, and I think that is a SERIOUS
tactical error. So I want to distance myself politically as far as
possible from it.
Historically, the reason I'm involved in Scheme is that *long* ago,
before Strucure and Interpretation of Computer Programs (S&ICP, the
CLTL of the Scheme world, around which many Scheme courses are built),
Scheme was about "options". One could program, as in CL, in a variety
of ways, and functional was one of them. The langauge showed
considerable promise. But increasingly over time, the Scheme
community has self-identified with a particular teaching and
programming style that I find questionable, but that I accept as "what
they want". I *do* think they continue to make a serious error by
asserting that this programming style is "natural". I don't think any
one style is natural. I think what is natural is to shift
representations, and I think the Scheme community specifically eschews
the notion of expressional shifts at the language level, leaving that
only to the application level. I think that's a mistake. I think
part of the reason that Abelson/Sussman went in the direction they did
in S&ICP was to offset the strong pressure for teaching other styles,
such as traditional iterative, which they felt (quite reasonably) had been
discussed to death in other teaching texts. So they didn't spend any time
teaching what they felt people would already know. But their omission
of the other "discussed to death" text was conspicuous and was met with
near religious zealousness as intending to "change" rather than merely
"broaden" the set of programming styles available. In practice, it has
turned hoards of confused newbies into religious zealots who appear to
hate iteration constructs, rather than merely to see them as a convenient
alternate notation for what they have learned in other forms. This outcome,
I think, was disastrous for Scheme because even in its success, it has built
a wall of inaccessibility around the language, certainly allowing some
measurable number of computer people in, but utterly locking out "ordinary
folk", who I do think are prime candidates for learning Lisp.
We have found historically that a lot of people put off by the numerical
languages are not put off to Lisp *if* they are guided carefully to use
constructs that feel familiar to them. Constructs like WHEN and UNLESS,
LOOP and its various keywords, etc. offer flexible ways of talking about
control in a way that is familiar to non-programmers and offers gradual
and comfortable entry. Scheme, by contrast, is an exercise in training
people to think anew. That's great for people who want their brains
reorganized, and it's why I said I consider Scheme "interseting", but
it not the set of people I personally care about Lisp reaching. There will
be no "crossing of the chasm" (see the book "Crossing the Chasm") so long
as the approach is what Scheme promotes.
To the extent that Scheme creates an impenetrable entry barrier of the kind
I have described, I want nothing of that to rub off on Lisp, and therefore
I want managers to understand clearly that what they know of Scheme does not
necessarily apply to Lisp / Common Lisp.
Moreover, oddly, I recognize some symmetry in the Scheme community
where they disagree with me about what it takes to tactically win.
There are people who assert in all good conscience and belief that
they think they are on the right track to winning over converts.
Maybe so. I doubt they'll make much headway beyond a limited class of
people predisposed to do mental calesthentics as entertainment; I
don't think this is a long class. But the Scheme folks believe
otherwise, and it's useful to them not to have "known facts" about CL
besmirching their pristine language either.
So the wall of separation serves in both directions.
Nothing keeps us from stopping by and chatting with our friends across
the barrier. There's a lot we can learn. But we should do it in the frame
of reference of what we're trying to accomplish. Scheme and CL are out for
different things. Giving them a common superclass will just confuse those
who don't program in either language into thinking they are both out for the
same thing and will encourage them to erroneously apply their conclusions
about one to the other. That won't do anyone any good.
None of this is to say I don't see similiarities between the two languages
in an academic sense. I just don't find those similarities very useful
in practice.
Kent M Pitman <······@world.std.com> wrote:
> Moreover, oddly, I recognize some symmetry in the Scheme community
> where they disagree with me about what it takes to tactically win.
> There are people who assert in all good conscience and belief that
> they think they are on the right track to winning over converts.
> Maybe so. I doubt they'll make much headway beyond a limited class of
> people predisposed to do mental calesthentics as entertainment; I
> don't think this is a long class. But the Scheme folks believe
> otherwise, and it's useful to them not to have "known facts" about CL
> besmirching their pristine language either.
Regarding "mental calesthentics" and your general critique of the forced
functional style in Scheme, I'm wondering if you mean these points to
apply to functional languages in general. Are Haskell, ML, Erlang, et
al. even worse than Scheme in your opinion, or are they in a different
class altogether?
Michael
--
Michael Schuerig
···············@acm.org
http://www.schuerig.de/michael/
········@acm.org (Michael Schuerig) writes:
> Kent M Pitman <······@world.std.com> wrote:
>
> > Moreover, oddly, I recognize some symmetry in the Scheme community
> > where they disagree with me about what it takes to tactically win.
> > There are people who assert in all good conscience and belief that
> > they think they are on the right track to winning over converts.
> > Maybe so. I doubt they'll make much headway beyond a limited class of
> > people predisposed to do mental calesthentics as entertainment; I
> > don't think this is a long class. But the Scheme folks believe
> > otherwise, and it's useful to them not to have "known facts" about CL
> > besmirching their pristine language either.
>
> Regarding "mental calesthentics" and your general critique of the forced
> functional style in Scheme, I'm wondering if you mean these points to
> apply to functional languages in general. Are Haskell, ML, Erlang, et
> al. even worse than Scheme in your opinion, or are they in a different
> class altogether?
Well, it's very rare for Haskell & company to come up as being
confused with Lisp, except by people who really know what FP is (and a
lot about its history) so I wasn't making a statement about them.
I did say I think a Schemer is more likely to feel comfortable with one
of the languages you mentioned (well, except I didn't mention Erlang,
since I'm not familiar with that one; I did say ML or Haskell). Implicit
in my statement was that maybe this is the language family Scheme most
predominantly belongs to...
If your question is only whether I think these languages are making a
tactical marketing error, it depends on whether they wish to reach
mainstream programmers. If they do, then yes, I think they're not
going to make it. If they don't have that as a goal, and I have
always assumed they let go of that ages ago, then perhaps they're
fine. I don't know any Erlang and have only seen Haskell code at
conferences. I have long ago read a book on ML and have plunked a few
times at an interpreter. My sense is that these are
still-even-more-mathy languages than Scheme, not in the sense that
they are "only good for math" but in the sense that their sense of
balance and order and how you do things is likely, I think, to appeal
to the same people who see harmony in math. And that's a small segment.
Note that I say these things about what does and doesn't appeal to the
public on the basis of a belief, based of now almost two dozen years
of experience of personally trying to "sell" various kinds of people
(from ivory tower folks to people on the street) the use of Lisp.
Part of what keeps people away is their inability to do certain
things, but I think that's a tiny number. I think it's a belief that
these could be retrained that keeps the Scheme folks
every-optimnistic. But I think the bigger barrier in practice is
people's level of interest, their tolerance for what looks familiar,
etc. I'd say Scheme was like cigarette vendors in having recognized
that if they don't capture the hearts and minds of 14-year-olds, they
have lost their cause, except that someone would later misquote me as
having said Scheme was a cancer on the programming language community
and its vendors were just peddlers of disease and death.
It's functionality, not aesthetics, that gets people after 14 (and the
age may go earlier all the time). Because people are too-early exposed
to other languages that are simply not hugely aesthetic and yet that
promise them a career of work. And even in situations where aesthetics
count, people have never understood how to anticipate how much it will
count enough to build it into their planning. Scheme is almost an active
effort in denying me nearterm functionality in order to assure some
long-term aesethetic. I don't need that, and I think a lot of other people
sense they don't either. I don't want to be on that bandwagon. I want
Lisp to be "approachable" by people from other languages. I like that
it has PROG even though I rarely use it because it provides a syntactic
bridge for explaining certain things to people from FORTRAN-esque languages.
I'm not embarrassed about PROG's presence there. And so on.
I can't speak to what Haskell and ML and friends are up to in that
regard, but FORTUNATELY their efforts don't tend to reflect on Lisp.
They do their thing and we do ours. And that's fine.
In article <···············@world.std.com>, Kent M Pitman
<······@world.std.com> wrote:
> although some languages may have dallied in it slightly (Dylan
> perhaps?), we generally don't write method dispatch on union classes.
You're correct that Dylan offers method dispatch on union types --
including anonymous unions created on the spot -- and I think it's quite
useful as a shorthand for writing exactly the same method twice with
different specializers.
Note that OCaml is curently moving in the same direction. It has for
some time allowed "match" constructs to give several alternate patterns
with the same action body (separated using "|"), but it has disallowed
binding parts of the patterns to variables which has made doing this
somewhat 2nd class. The latest version now allows variable binding in
patterns joined with "|".
Actually, I'm not clear on whether you are against union types as such,
or merely against method dispatch based on them.
The ML languages have *always* been based on union types, and have only
recently started adding more traditional OO classes.
The main uses for union types in Dylan seem to be:
- adding a "not valid" or "nil pointer" distinguished value to a
type. This usage is enshrined in the "false-or(foo)" standard
library function which produces "type-union(singleton(#f), foo)".
- producing an analogue to Pascal and C's enumerations. This usage is
enshrined in the "one-of(2, 3, 5, 7, 11)" standard library function
which expands to "type-union(singleton(2), singleton(3), ...)".
It's interesting to note that Wirth abandoned enumerations in Oberon
because he couldn't see how to make them extensible without conflicts
and he wanted to be able to type-extend *everything* in the language.
Union types together with lisp-style globally unique "symbols" solve
that problem nicely.
- conveniently giving the same interface to a number of classes
without requiring any commonality of implementation between
them. In this case you'll often have the Generic Function
declared using a union type, but the actual methods will each be
dispatched on only one particular concrete type.
> I think the reason is that it's hard to say what the priority is of
> conflicting methods that are taken from union classes, while it is
> more easily possible to impose a method ordering on subclass chains
> (which it seems to me that "and" can be regarded as).
Do you mean something like this:
------------------------------------------------------------
module: unions
synopsis:
author:
copyright:
define constant movement = one-of(#"crawl", #"walk", #"run");
define constant programming = one-of(#"edit", #"compile", #"run");
define method do-it(x :: movement)
format-out("in do-it(movement)\n");
end;
define method do-it(x :: programming)
format-out("in do-it(programming)\n");
end;
define method proxy(a)
do-it(a);
end;
define function main(name, arguments)
proxy(#"run");
exit-application(0);
end function main;
main(application-name(), application-arguments());
------------------------------------------------------------
bash$ ./unions
It is ambiguous which of these methods is most specific:
#(, )
{the <method> do-it{type-union(singleton(#"crawl"), singleton(#"run"),
singleton(#"walk"))}}{the <method> do-it{type-union(singleton(#"run"),
singleton(#"compile"), singleton(#"edit"))}}Aborted (core dumped)
------------------------------------------------------------
With both subclasses and type unions it is possible to create two
methods where neither is more specific than the other for some
particular arguments -- and Dylan and CLOS use very similar ordering
algorithms for this -- so I don't see a difference there. The only
real choice is whether to signal such an error at compile time or at run
time (I had to go through the "proxy()" method above to prevent d2c from
diagnosing the error at compile time).
I fibnd little to disagree with in the rest of your message. I'll just
say that I think Dylan lies closer to CL than to Scheme in terms of the
philisophical issues you raise.
-- Bruce
Dear David Bakhash and readers,
you wrote:
> I find this analogy to be poor insofar as the topic need no analogy to
> other branches of taxonomy.
> ...
Skills of writing and analysis comes naturally when you become mature in
these subjects, and if you force it, it looks very stupid and people will
know.
Who's got good skill of writing? Xah do, Erik Naggum does, Larry Wall does,
for examples.
Who's got good skill of analysis? Xah do, Erik Naggum does, for examples.
Most people on this list are relative dumb asses. Most true intellectuals
don't do newsgroups. Those who claim i use many obscure words, is outright
not an expert in literature. What's good literature on the web?
http://www.time.com/
http://www.suck.com/
That's professional journalism and satire. If you want verifiable claims,
just go to www.suck.com and evaluate yourself. You'll find that
(1) you have no idea what they are talking about.
(2) you don't understand every other word in their article.
And if the above are not true, then you'll also find Xah's writings and
insight pluperfect, speaking for myself.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: David Bakhash <·····@alum.mit.edu>
> Organization: EarthLink Inc. -- http://www.EarthLink.net
> Newsgroups: comp.lang.lisp
> Date: Mon, 26 Feb 2001 05:20:57 GMT
> Subject: Re: Is Scheme a `Lisp'?
Xah Lee wrote:
> Who's got good skill of writing? Xah do, Erik Naggum does, Larry Wall
> does, for examples.
> Who's got good skill of analysis? Xah do, Erik Naggum does, for examples.
>
> Most people on this list are relative dumb asses. Most true intellectuals
> don't do newsgroups. Those who claim i use many obscure words, is outright
> not an expert in literature. What's good literature on the web?
I've neither seen any good style writings of you nor do I've seen any clear
analytics. You seem to have a rather intense fantasy when it comes to
insulting of others. It says more than words that you mention yourself
before the people you compare with yourself. You have definitely
sub-average social skills.
Jochen
I wrote:
>> ...
>> Do you consider it true, that Scheme is a dialect of Lisp.
>> (note: this is different from "Do you consider that Scheme is a dialect of
>> Lisp.")
You wrote:
> You can consider it true that Scheme is a dialect of Lisp while not
> considering Scheme a dialect of Lisp, or vice versa? [Well, that
> doesn't really surprise me coming from Xah...]
Paul Foley, let me illustrate your folly. This will be a quick one.
We want to know the difference between the following:
* Do you consider it true, that Scheme is a dialect of Lisp
* Do you consider that Scheme is a dialect of Lisp.
This will become clear with an analogy:
* Do you consider it true, that you are a genius.
* Do you consider that you are a genius.
If you ask me this, my answers are "No" and "Yes", respectively.
Got it? I'll leave you alone of the other things you have to say.
(btw, if you want to know "gosh, how's Xah _so_ on the spot?", as i have
said several times, the answer lies in studying logic foremost, then
linguistics. As for written presentation skills, that's lots and lots of
reading and writing. (i also thank god everyday that i'm endowed with an
above above average IQ, not everyone's got that, but i also bitch god
everyday that i wasn't born well-to-do, and developed a curse for the world.
Well, i am what i am, and i'll just live it up.))
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Paul Foley <·······@actrix.gen.nz>
> Newsgroups: comp.lang.lisp
> Date: 26 Feb 2001 16:34:39 +1300
> Subject: Re: Is Scheme a `Lisp'?
Dearly beloved readers,
Erik has spoken. Let me serve my duty of translating his opus for the
laymen, and also placing it in the frame of our debate.
His post is very informative. It is informative in two ways. The first one,
is that it told us in no ambiguous terms Erik's position on the debate: "I,
Erik Naggum, consider it true that Scheme is a dialect of the Lisp family,
however, i don't like it". Let us take a moment to thank Xah for this
beautiful, unobstructed view of his head.
The second, is that we captured a rare and much wanted moment of Erik's
elusive behavior that can be easily explained to public.
When i said:
>> Do you consider it true, that Scheme is a dialect of Lisp.
>> (note: this is different from "Do you consider that Scheme is a dialect
>> of Lisp.")
He opened his message to add:
> And even more different from "What is this Lisp that would make "Scheme
> is a (dialect of) Lisp" a true statement?" vs "What is this Lisp that
> would make "Scheme is not a Lisp" a true statement?".
This is what we may think of as a prologue. Like, in the 007 movies they
have prologues. It gives us a sense of what's to come. It would be wrong to
say "i think we need to define 'Lisp'", just as it would be wrong if the 007
movie does not start with some daredevil acts by some suave handsome fella.
Erik's prologue, is catered to fit his views AND intentions to a tee.
Erik then said:
> I consider it pointless to argue whether Scheme is a Lisp without making
> the point that Scheme may well be a dialect of 1960's-style Lisp without
> being a dialect of _whatever_ Lisp is in the year 2000 and beyond.
In this paragraph, he indicated, in no Basic English grammar, that if he
were to join the debate in this thread which Xah have helped define, then he
agrees with Xah that _Scheme is a Lisp_. However, he does not exactly wish
to join the debate in such a manner. Instead, he comes in now as an
observer, not proponent of a side, and gave his opinion about the debate. If
Erik is a normal person, then the paragraph might go like this:
"ok, Scheme is a dialogue of Lisp all right, but I wish to remind everyone
some facts. In 1960 blab blab blab...".
Erik continues:
> If Scheme is a Lisp, Lisp has not evolved since its inception, and this
> is indeed what many Scheme-infested anti-Lisp beliefs is based in. If
> Lisp _has_ evolved since 1960 (or make it 1980 if you like), Scheme is no
> longer part of the Lisp evolution. Scheme _left_ Lisp's evolution, Lisp
> moved on forward, and "Scheme is a dialect of Lisp" is true only in a
> historical sense that there simply is no point in talking about any more.
This is an elaboration of ideas in his previous paragraph. For a true
understanding, one has to dive into the original instead of a translation,
so i'll leave my readers to their tasks, as i have served my purpose.
Thank you Erik, and thank you all for the delightful weekend. I'm going to
take a hike.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Erik Naggum <····@naggum.net>
> Organization: Naggum Software, Oslo, Norway
> Newsgroups: comp.lang.lisp
> Date: 26 Feb 2001 00:38:19 +0000
> Subject: Re: Is Scheme a `Lisp'?
In article <·················@xahlee.org>, Xah Lee wrote:
>Dearly beloved readers,
>
>Erik has spoken. Let me serve my duty of translating his opus for the
>laymen, and also placing it in the frame of our debate.
>
>His post is very informative. It is informative in two ways. The first one,
>is that it told us in no ambiguous terms Erik's position on the debate: "I,
>Erik Naggum, consider it true that Scheme is a dialect of the Lisp family,
>however, i don't like it". Let us take a moment to thank Xah for this
>beautiful, unobstructed view of his head.
I do not speak for Erik, but what he has cosistantly posted is that scheme
looks like lisp but is realy based on algol. He has been quite clear on
that point.
I did not read the rest, a flawed translation is worse then no translation.
[snip]
marc
"Marc Spitzer" <····@oscar.eng.cv.net> wrote in message
·························@oscar.eng.cv.net...
> I did not read the rest, a flawed translation is worse then no
translation.
Not true. A "flawed" translation may be compared with a "correct"
translation to gain information about both the message (and perhaps the
translators). No translation gives no information whatsoever. So unless
you are saying that ignorance is always better than knowledge, you cannot
make such a blanket statement.
Pedantically yours...
faa
In article <·····················@news.uswest.net>, Frank A. Adrian wrote:
>"Marc Spitzer" <····@oscar.eng.cv.net> wrote in message
>·························@oscar.eng.cv.net...
>> I did not read the rest, a flawed translation is worse then no
>translation.
>
>Not true. A "flawed" translation may be compared with a "correct"
>translation to gain information about both the message (and perhaps the
>translators). No translation gives no information whatsoever. So unless
>you are saying that ignorance is always better than knowledge, you cannot
>make such a blanket statement.
>
>Pedantically yours...
>faa
>
>
Perhaps "flawed" was a poor choice of words, a better choice would
have been wrong. I think that knowing I do not know something is
better then thinking I do know something when what I think I know is
completely wrong. The orignal message that I was talking about did
not agree with observed facts, Eriks other postings on why scheme is
not lisp, made the message into a work of fiction at best. And that
is worse then no translation at all.
marc
* Dear Marc Spitter and Readers,
Of my poor self image, i could have never imagined, that i've been talked
about as a translator, and my works are being debated among lettered
computer language programers.
I heard once, that the motto for some university is: "They say, what
they say, let them say.". Not till today, i realized its utility.
I thank thee, from the lowest bottom of my heart.
PS "They say, what they say, let them say.", i think that's rooted in
Greek or Latin. Does anyone know? and, which University is it? (i forgot)
#;Xah
--
I like long walks, especially when they are taken with people i like.
> From: ····@oscar.eng.cv.net (Marc Spitzer)
> Organization: Optimum Online
> Newsgroups: comp.lang.lisp
> Date: Tue, 27 Feb 2001 08:30:28 GMT
> Subject: Re: Is Scheme a `Lisp'?
Xah Lee <···@xahlee.org> writes:
> To prevent any mudding of the waters, anyone who wishes to jump in please
> make a clear statement that either you believe
>
> * Scheme is a Lisp
>
> or
>
> * Scheme is not a Lisp
>
Scheme is not a Lisp.
I'd rather call it an anti-dylan as an algol based language with
prefix syntax where dylan is a lisp based language (also not a lisp
anymore IMHO) with infix syntax.
--
Lieven Marchand <···@wyrd.be>
Gla�r ok reifr skyli gumna hverr, unz sinn b��r bana.
Xah Lee <···@xahlee.org> writes:
> To prevent any mudding of the waters, anyone who wishes to jump in please
> make a clear statement that either you believe
>
> * Scheme is a Lisp
>
> or
>
> * Scheme is not a Lisp
I think that is too simplistic. (Or in the words of Bill Clinton, 'it
depends on what your definition of "is" is.')
How about this:
Axiom 1
There are many dialects of Lisp, among which are interlisp,
maclisp, PCL, Common Lisp, zetalisp, autolisp, emacs lisp, etc.
Axiom 2
You can recognize a dialect of a language by looking for
properties that a language has in common with other dialects.
Now you can assert either
Scheme is a dialect of Lisp
or
Scheme is not a dialect of Lisp
If you are asserting the latter, you can either dispute Axiom 1 (by
saying, for example, that Common Lisp is the *only* lisp), or dispute
axiom 2 (by saying, for example, that proper tail recursion is not a
requirement of any other lisp).
> We all learned that when Xah is watching it is better not to fuck
> around with reason.
When Xah is watching, reason should be completely left out of the
discussion.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
In article <···················@192.168.1.100>,
Paul Wallich <··@panix.com> wrote:
>
>I think that this could also be construed as an example of just how close
>Scheme and Lisp are: if they weren't so nearly identical, they wouldn't be
>fighting over the same memetic niche. It's a little like the animosities
>among verious religious groups, where apostates and schismatics are far
>more hated than the heathen. It's the fact that they have such similar
>goals that makes disagreement over how to go about achieving them
>such a big deal. (Or, as someone once said about academia: "The fights
>are so vicious because the stakes are so low.)
That's a great quote! Did it have to do with the Great
Books debate? The argument I remember went along these
lines: When people were readers, there was no reason
to fight over what gets into the Great Books list,
because books, on or off the list, got read
anyway. When reading declines, membership in the Great
Books becomes important, because these may be the only
books that had a chance of being read...
There is a basic asymmetry in the Lisp membership
debate you are commenting on. It is not quite
isomorphic to the typical Turco-Mongol war of
succession, where every brother wants every other
brother out. There has been _no_ suggestion that
Common Lisp is not a Lisp, nor will there ever be, and
rightly so. Those who don't think of Scheme as a Lisp
seem to subscribe to a "Law of Conservation of
Lisp", if you will, which of course makes it imperative
to think in terms of cornering that Lisp memetic niche.
--d
Kent M Pitman <······@world.std.com> writes:
> Yes, Scheme and Lisp both have parentheses. But Scheme defines its
> semantics in terms of those parens, and Lisp defines its semantics in
> terms of the objects that those parens will read as. This leads to
> peculiar disconnects, such as that there is no semantics to (+ . (1
> 2)) in Scheme even though it's the same list as (+ 1 2), while in Lisp
> they have the same meaning since they are the same list.
This is not true. The string "(+ . (1 2))" will be read as a list of
three objects, the symbol +, the number 1, and the number 2. The
string "(+ 1 2)" will be read as a list of three objects, the symbol
+, the number 1, and the number 2. After being read, these objects
are indistinguishable.
This list potentially has further meaning: it can be interpreted as
an expression whose operator is the identifier named +, and whose
operands are the literal numbers 1 and 2. Assuming no one has
shadowed or redefined +, this expression denotes the number 3.
The above is true in *both* Scheme and Common Lisp.
> Yes, Scheme and Lisp both have numeric functions like SIN, COS, TAN, etc.
> But Scheme doesn't like to get messy about the details of branch cuts.
R5RS refers to CLtL for the details of branch cuts. No difference there.
> I suspect a Scheme programmer would be happier using ML or Haskell
> or even maybe Pascal than using Lisp.
It is hard to generalize, but I enjoy both CL and Scheme.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall <···@content-integrity.com> writes:
> Kent M Pitman <······@world.std.com> writes:
>
> > Yes, Scheme and Lisp both have parentheses. But Scheme defines its
> > semantics in terms of those parens, and Lisp defines its semantics in
> > terms of the objects that those parens will read as. This leads to
> > peculiar disconnects, such as that there is no semantics to (+ . (1
> > 2)) in Scheme even though it's the same list as (+ 1 2), while in Lisp
> > they have the same meaning since they are the same list.
>
> This is not true. The string "(+ . (1 2))" will be read as a list of
> three objects, the symbol +, the number 1, and the number 2. The
> string "(+ 1 2)" will be read as a list of three objects, the symbol
> +, the number 1, and the number 2. After being read, these objects
> are indistinguishable.
Really? I was working from memory and have never claimed to be infallible
but this doesn't match my memory. Do you have a page reference in R5RS
for how this works? Not that I disbelieve you--just trying to save myself
search time since you seem so certain and since I'd like to go reread.
(All my hardcopy documents of this are locked up in storage right now while
my house goes through some renovations, so doing the direct lookup thing is
hard for me at the moment. I could find an online version, but they're
harder to skim.)
Kent M Pitman <······@world.std.com> writes:
> Joe Marshall <···@content-integrity.com> writes:
>
> > Kent M Pitman <······@world.std.com> writes:
> >
> > > Yes, Scheme and Lisp both have parentheses. But Scheme defines its
> > > semantics in terms of those parens, and Lisp defines its semantics in
> > > terms of the objects that those parens will read as. This leads to
> > > peculiar disconnects, such as that there is no semantics to (+ . (1
> > > 2)) in Scheme even though it's the same list as (+ 1 2), while in Lisp
> > > they have the same meaning since they are the same list.
> >
> > This is not true. The string "(+ . (1 2))" will be read as a list of
> > three objects, the symbol +, the number 1, and the number 2. The
> > string "(+ 1 2)" will be read as a list of three objects, the symbol
> > +, the number 1, and the number 2. After being read, these objects
> > are indistinguishable.
>
> Really? I was working from memory and have never claimed to be infallible
> but this doesn't match my memory. Do you have a page reference in R5RS
> for how this works? Not that I disbelieve you--just trying to save myself
> search time since you seem so certain and since I'd like to go reread.
> (All my hardcopy documents of this are locked up in storage right now while
> my house goes through some renovations, so doing the direct lookup thing is
> hard for me at the moment. I could find an online version, but they're
> harder to skim.)
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> <)>
There are no productions of the forms:
<conditional> --> (if <test> <consequent> . (<alternative>))
<conditional> --> (if <test> . (<consequent> <alternative>))
<conditional> --> (if . (<test> <consequent> <alternative>))
Some people have taken this to mean that token sequences of the form
<(> <optional whitespace> <if> <whitespace> [expression] <whitespace>
[expression] <whitespace> <dot> <whitespace> <(> <optional whitespace>
[expression] <optional whitespace> <)> <optional whitespace> <)>
are prohibited.
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.
Under this interpretation, we do not need production rules of this
form:
<conditional> --> (if <test> <consequent> . (<alternative>))
because it is simply an non-canonical alternative to the standard
rule.
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.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
In article <···············@world.std.com>, Kent M Pitman wrote:
>Joe Marshall <···@content-integrity.com> writes:
>
>> Kent M Pitman <······@world.std.com> writes:
>>
>> > Yes, Scheme and Lisp both have parentheses. But Scheme defines its
>> > semantics in terms of those parens, and Lisp defines its semantics in
>> > terms of the objects that those parens will read as. This leads to
>> > peculiar disconnects, such as that there is no semantics to (+ . (1
>> > 2)) in Scheme even though it's the same list as (+ 1 2), while in Lisp
>> > they have the same meaning since they are the same list.
>>
>> This is not true. The string "(+ . (1 2))" will be read as a list of
>> three objects, the symbol +, the number 1, and the number 2. The
>> string "(+ 1 2)" will be read as a list of three objects, the symbol
>> +, the number 1, and the number 2. After being read, these objects
>> are indistinguishable.
>
>Really? I was working from memory and have never claimed to be infallible
>but this doesn't match my memory. Do you have a page reference in R5RS
>for how this works? Not that I disbelieve you--just trying to save myself
> ...
afaik, rxrs defines the language lexically, so it is conceivable to write
a compiler/interpreter that goes from the textual representation straight
to some internal representation and not know what to do with (+ . (1 2)).
however, all legal scheme programs (at least i think so) are also the textual
representation of liststructures, so the most likely way for any implementation
would be to read the program text as a list and proceed from there. in that
case all constructs that are indistingushable from correctly typed text would
be able to be processed just like in lisp
hs
··@paradise.nirvananet (Hartmann Schaffer) writes:
> In article <···············@world.std.com>, Kent M Pitman wrote:
> >Joe Marshall <···@content-integrity.com> writes:
> >
> >> Kent M Pitman <······@world.std.com> writes:
> >>
> >> > Yes, Scheme and Lisp both have parentheses. But Scheme defines its
> >> > semantics in terms of those parens, and Lisp defines its semantics in
> >> > terms of the objects that those parens will read as. This leads to
> >> > peculiar disconnects, such as that there is no semantics to (+ . (1
> >> > 2)) in Scheme even though it's the same list as (+ 1 2), while in Lisp
> >> > they have the same meaning since they are the same list.
> >>
> >> This is not true. The string "(+ . (1 2))" will be read as a list of
> >> three objects, the symbol +, the number 1, and the number 2. The
> >> string "(+ 1 2)" will be read as a list of three objects, the symbol
> >> +, the number 1, and the number 2. After being read, these objects
> >> are indistinguishable.
> >
> >Really? I was working from memory and have never claimed to be infallible
> >but this doesn't match my memory. Do you have a page reference in R5RS
> >for how this works? Not that I disbelieve you--just trying to save myself
> > ...
>
> afaik, rxrs defines the language lexically, so it is conceivable to write
> a compiler/interpreter that goes from the textual representation straight
> to some internal representation and not know what to do with (+ . (1 2)).
Only if it can prove at translation time that "+" was not a macro or
syntatic keyword.
> however, all legal scheme programs (at least i think so) are also the textual
> representation of liststructures, so the most likely way for any implementation
> would be to read the program text as a list and proceed from there. in that
> case all constructs that are indistingushable from correctly typed text would
> be able to be processed just like in lisp
>
> hs
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Kent M Pitman <······@world.std.com> writes:
> Joe Marshall <···@content-integrity.com> writes:
>
> > I think most people with experience in computer languages would
> > consider Scheme to be a `dialect' of the Lisp `family' of languages.
>
> If you said "some" and perhaps even "many", this would be an undeniable fact.
Are you suggesting that I *don't* think that?
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall <···@content-integrity.com> writes:
> Kent M Pitman <······@world.std.com> writes:
>
> > Joe Marshall <···@content-integrity.com> writes:
> >
> > > I think most people with experience in computer languages would
> > > consider Scheme to be a `dialect' of the Lisp `family' of languages.
> >
> > If you said "some" and perhaps even "many", this would be an undeniable fact.
>
> Are you suggesting that I *don't* think that?
Oops. Sorry. No, my commnet is on hypothetical you were entertaining...
In article <···············@world.std.com>,
Kent M Pitman <······@world.std.com> wrote:
>Joe Marshall <···@content-integrity.com> writes:
>
>> Erik Naggum <····@naggum.net> writes:
>>
>> > There is no reason to consider Scheme a Lisp.
>
>I think a more defensible claim is "There is reason not to consider
>Scheme a Lisp." It's certainly an undeniable fact that certain people
>do consider Scheme a Lisp, and that these people are not acting without
>any reason.
Hmm. Looks rather like you are distancing yourself
from their view. Do you not yourself consider Scheme
to be a Lisp?
>> I think most people with experience in computer languages would
>> consider Scheme to be a `dialect' of the Lisp `family' of languages.
>
>If you said "some" and perhaps even "many", this would be an undeniable fact.
Again your phraseology is intriguing, given your
influential status as R*RS co-author for many revisions
running, all of which describe Scheme in no uncertain
terms as a Lisp, right there in the opening lines.
Perhaps only "some" people consider Scheme to be a
Lisp, but are _you_ one of those "some"?
--d
····@goldshoe.gte.com (Dorai Sitaram) writes:
> In article <···············@world.std.com>,
> Kent M Pitman <······@world.std.com> wrote:
> ...
> >I think a more defensible claim is "There is reason not to consider
> >Scheme a Lisp." It's certainly an undeniable fact that certain people
> >do consider Scheme a Lisp, and that these people are not acting without
> >any reason.
>
> Hmm. Looks rather like you are distancing yourself
> from their view. Do you not yourself consider Scheme
> to be a Lisp?
Nope, usually I don't. But I recognize that the question is itself usually
political and perhaps also an issue of focus (relative to a conversation).
> >> I think most people with experience in computer languages would
> >> consider Scheme to be a `dialect' of the Lisp `family' of languages.
> >
> >If you said "some" and perhaps even "many", this would be an undeniable fact.
>
> Again your phraseology is intriguing, given your
> influential status as R*RS co-author for many revisions
> running, all of which describe Scheme in no uncertain
> terms as a Lisp, right there in the opening lines.
> Perhaps only "some" people consider Scheme to be a
> Lisp, but are _you_ one of those "some"?
Well, two quick comments here. Ask more questions if it leaves you with
questions--I don't mean to be cryptic.
First, when I work on Scheme, I do it with my "Scheme" hat on, that
is, in the context of trying to satisfy a political base that I think
is different than the CL base. The goodness or badness of Scheme is
not judged just by what it can do but by how well it suits the mindset
and practical needs of those who plan to use it. (If you don't
understand all the political references, see my somewhat-dated but
still relevant article "More Than Just Words: Lambda, The Ultimate
Political Party" at http://world.std.com/~pitman/PS/Lambda.html for
clarification.)
Second, when people make claims about "most people", especially in what
I regard as political debates, I am always skeptical. I think it's very
hard to speak for "most people". I probably do it as much as the next
person. But that doesn't make it better. Also, I don't think knowing
percentages here is relevant to the debate; if a certain percent of people
think other than the statements made, even if those people are in the
minority, it doesn't detract really from their claim. Perhaps it makes
it all the more interesting why. Perhaps I am in that minority. Then
again, I'm not sure how many Scheme people like being associated with Lisp;
some consider it a slam. How many are militant like that, and how many
are oblivious, and how many are just mellow, and so on--I can't say.
In article <···············@world.std.com>,
Kent M Pitman <······@world.std.com> wrote:
>
>First, when I work on Scheme, I do it with my "Scheme" hat on, that
>is, in the context of trying to satisfy a political base that I think
>is different than the CL base. The goodness or badness of Scheme is
>not judged just by what it can do but by how well it suits the mindset
>and practical needs of those who plan to use it. (If you don't
>understand all the political references, see my somewhat-dated but
>still relevant article "More Than Just Words: Lambda, The Ultimate
>Political Party" at http://world.std.com/~pitman/PS/Lambda.html for
>clarification.)
Thank you very much for the pointer. I carefully read
it through. You seem to initially use the word
"political" in an unpejorative sense to describe
community and subcommunity activity, and I thought you
were going somewhere with it. But in the end you
"celebrate" the difference between Common Lisp and
Scheme by saying that one of them can be excluded from
the community and need not be considered a Lisp at all.
That's a tricky syllogism you slip in there.
I appreciate and commend you for the overall tolerant,
all-surveying tone in the essay, so more's the pity
that the actual content is exclusionary.
--d
····@goldshoe.gte.com (Dorai Sitaram) writes:
> I appreciate and commend you for the overall tolerant,
> all-surveying tone in the essay, so more's the pity
> that the actual content is exclusionary.
Well, I think the point is this:
Suppose I have a set of friends who like drinking beer and watching
football and suppose I have another set of friends who like drinking
wine and discussing Greek philosophers. I feel like partying. Am I
better off trying to devise a party with everyone, or trying to devise
two separate parties. I claim, and you might disagree, that two parties
is better. That is, that a certain amount of "clustering" (in the data
mining sense) is appropriate in determining whether people are all on one
page, or would forever clash.
It's not so much that I believe in exclusion as that I believe that
people are not constructed to belong all in one tent.
Not everyone likes any particular genre of fiction. Some like mysteries.
Some humor. Some sci-fi. Some westerns. Sometimes there's an overlap.
But there is no writer who writes to all genres together. And the writer
who succeeds knows his target audience and seeks to serve that audience.
So, too, with languages, I think.
Dear Kent Pitman,
you wrote:
> Well, I think the point is this:
>
> Suppose I have a set of friends who like drinking beer and watching
> football and suppose I have another set of friends who like drinking
> wine and discussing Greek philosophers. I feel like partying. Am I
> better off trying to devise a party with everyone, or trying to devise
> two separate parties. I claim, and you might disagree, that two parties
> is better. That is, that a certain amount of "clustering" (in the data
> mining sense) is appropriate in determining whether people are all on one
> page, or would forever clash.
>
> It's not so much that I believe in exclusion as that I believe that
> people are not constructed to belong all in one tent.
>
> Not everyone likes any particular genre of fiction. Some like mysteries.
> Some humor. Some sci-fi. Some westerns. Sometimes there's an overlap.
> But there is no writer who writes to all genres together. And the writer
> who succeeds knows his target audience and seeks to serve that audience.
> So, too, with languages, I think.
My golly, which part of your brain are you trying to fool yourself with?
When Dorai Sitaram wrote:
>> I appreciate and commend you for the overall tolerant,
>> all-surveying tone in the essay, so more's the pity
>> that the actual content is exclusionary.
He meant that you sounded neutral and commentary in the article but is in
fact belittling the Scheme camp. But in your reply, you didn't address this
but with your fucking humbling proceed to fucking sounding like a hearty
saint with great forgiveness and passion.
Perhaps your humbleness made you a humbug?
Don't try to be evasive, and stop your fucking humblings, in my humble
suggestion.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Kent M Pitman <······@world.std.com>
> Organization: The World Public Access UNIX, Brookline, MA
> Newsgroups: comp.lang.lisp
> Date: Sat, 24 Feb 2001 01:48:52 GMT
> Subject: Re: Is Scheme a `Lisp'?
In article <···············@world.std.com>,
Kent M Pitman <······@world.std.com> wrote:
>····@goldshoe.gte.com (Dorai Sitaram) writes:
>
>> I appreciate and commend you for the overall tolerant,
>> all-surveying tone in the essay, so more's the pity
>> that the actual content is exclusionary.
>
>Well, I think the point is this:
>
>Suppose I have a set of friends who like drinking beer and watching
>football and suppose I have another set of friends who like drinking
>wine and discussing Greek philosophers. I feel like partying. Am I
>better off trying to devise a party with everyone, or trying to devise
>two separate parties. I claim, and you might disagree, that two parties
>is better. That is, that a certain amount of "clustering" (in the data
>mining sense) is appropriate in determining whether people are all on one
>page, or would forever clash.
Again, you draw the false conclusion from the analogy.
American citizens who are wine-drinkers and
philosophy-discussers may be sufficiently different
clusters of people (with some demographic overlap), but
all that says is that they have differences from each
other. It does not imply that one of them, say the
wine-drinkers, can unilaterally decide that the
philosophy-discussers are sufficiently different that
they can be considered not to be American
citizens.
That is the false syllogism you are using. You need to
acknowledge this head-on instead of listing some
truisms about how different Scheme and CL are. Scheme
is not Common Lisp, that's all you can say (although
you don't need to say it, since it is not being
contested). What you are doing is using arguments for
Scheme not being Common Lisp to claim, out of the blue,
that Scheme is not a Lisp!
>It's not so much that I believe in exclusion as that I believe that
>people are not constructed to belong all in one tent.
>
>Not everyone likes any particular genre of fiction. Some like mysteries.
>Some humor. Some sci-fi. Some westerns. Sometimes there's an overlap.
>But there is no writer who writes to all genres together. And the writer
>who succeeds knows his target audience and seeks to serve that audience.
>So, too, with languages, I think.
But he's still a writer. Mystery writers don't
unilaterally say that sci-fi writers are so different
from themselves that they (the sci-fi writers)
cease to be writers at all.
--d
Dearly beloved Erik Naggum,
in article
> From: Erik Naggum <····@naggum.net>
> Organization: Naggum Software, Oslo, Norway
> Newsgroups: comp.lang.lisp
> Date: 24 Feb 2001 15:34:56 +0000
> Subject: Re: Is Scheme a `Lisp'?
you wrote:
> What do you (or the Scheme community) gain by insisting that Scheme is a
> Lisp and thereby inhibiting any and all evolution in what "Lisp" is?
That's an interesting question. The answer is: What do you (or the Scheme
haters community) gain by insisting that Scheme is not a Lisp and thereby
ticks your personal itch of what the evolution of Lisp is?
> #:Erik
> --
> If you are concerned about netiquette, you are either concerned about
> your own and _follow_ good netiquette, or you are concerned about others
> and _violate_ good netiquette by bothering people with your "concern", as
> the only netiquette you can _actually_ affect is your own.
Xah
--
If you are concerned about netiquette, one of the thing you can _avoid_
is violating your own definition of netiquette, but one of the thing
you can _actually_ do is to affect others by education, like this:
(not on dejanews.com's archive, thus attached below)
User-Agent: Microsoft-Outlook-Express-Macintosh-Edition/5.02.2022
Date: Mon, 20 Mar 2000 10:40:20 -0800
Subject: Re: Who used the "D" word?
From: Xah <···@xahlee.org>
Newsgroups: comp.lang.lisp
Message-ID: <·················@xahlee.org>
References: <·················@iname.com>
<·················@analogsystems.com>
<·······················@knuth.brownes.org>
<··········@goliath.newsfeeds.com> <··············@wallace.nextel.no>
<··········@goliath.newsfeeds.com> <··············@wallace.nextel.no>
<····················@news.bc.tac.net> <················@naggum.no>
Mime-version: 1.0
Content-type: text/plain; charset="US-ASCII"
Content-transfer-encoding: 7bit
The world:
Please witness my metaphysical meta-meta-meta discussion of doctor Naggum's
reflective meta-meta discussion about moralizer Coby Beck's remonstrative
meta discussion of commentator Espen Vestre's affront at apologizer Janos
Blazi's apology to Espen Vestre's commentary on Janos' insemination of the
most fascinating off-topic subject of prophet Nostradamus' abysmal quatrains
sparked and assiduously followed up by topic-sensitive prig Christopher
Browne that is relished and denounced by all, histrionically.
We are the world. The human nature of loftiness are sometimes laudably
delectable.
Geomancy genius Xah aft and fore-bodes that off-topicality exist in history
and will continue to exist till kingdom come: "thy shall be complacent nay
complain lest the spate of furor swallows the soul of confabulation, whence
the woe not the Tower of Babel but bower of babble."
If anyone have shit to say, say it with splendor. It is better to have
ingenious pests in comp.lang.lisp than inflamed superheroes babbling about
pestilence.
--
There are many philosophies towards netiquette. The most common treat
newsgroups as a conversation medium. Thus you see "me too"s and "thank you"s
and a plethora of one-sentence trivia and Question & Answer slipslops that
are valueless and meaningless to practically all except a few people for a
brief duration. As examples, comp.lang.lisp dwellers Tim Bradshaw and Rainer
Joswig's posts are typical of this style. Then at the other extreme is the
relatively rare Victorian propensity where each post is a gem of literature
carefully crafted and researched for an entire century of readers to
appreciate and archive. Xah, Erik Naggum, and Kent Pitman's posts are
exemplary of this style, to name a few acquaintances like myself.
The conversationalists emphasizes the notions of utility and community.
Utilities can include the exchanging of opinions, getting questions
answered, chatting, bounding a community, and advancing the group's
interests. (and trampling other communities' conflicting interests. (e.g.
"it's categorically unacceptable to bash lisp in lisp group".)) A good post
in the conversationalist's eyes is basically a post that makes everyone in
the group happy. The Rococo style posters are in general more scholarly and
emphasize on quality and value. The intrinsic quality of a post of the
Rococo stylists can be judged on content and presentation aspects. The
presentation part essentially means the poster's writing skills and effort
she put into posts. This fact is not highbrowism because communication using
newsgroups are mostly done in written form: wrote and read; not spoke and
heard. The criterions for judging a post's content are essentially the same
as that of a scholar's work in science or humanitarian diciplines, roughly
that of correctness, originality, or artistry. In this school of thought, it
is ok for example to bash lisp in comp.lang.lisp if the post has sound
arguments, original ideas, thought provoking, or otherwise has value (!very
funny!). Whether a post is on-topic is less important here because the focus
is on truth and enduring quality, not sheerly bending over for the group
agenda.
The two contrasting model of posters can be realized sharply by reading a
newsgroup archive of a particular poster. Go to a newsgroup archive such as
dejanews.com and search for your favorite poster. If you find a huge
quantity of terse posts that is tiring, boring, has little content, and in
general requires you to carefully follow the entire thread to understand it,
then you know you've bumped into a conversationalist. On the other hand, if
you find posts being usually lengthy and thoughtful and fairly complete by
itself, then you've met a scholarly mannered poster that is probably skilled
at writing as well. Please note that the conversational mannered posters are
not necessarily lousy writers, uncultured, or unappreciated, but usually
are.
If there must a purpose to this post, then it is that i urge those
conversationalists who insists on their brand of morality of netiquette to
at least double the time they spend on composing messages so that their
posts might have more value in a scholarly point of view, if they are
incapable or otherwise unwilling to broaden their minds into the
philosophies of netiquette. I'm here expanding their brain from the mundane
notion of noise/signal to revolutionary signal/value idea. You fucking
buckets of morons.
--
"Coby Beck" <·····@mercury.bc.ca> wrote
> Xah is the only real troll i recall having seen here in
> the 8 or so months i have subscribed to c.l.l
In _The Land of Oz_, there are two type of witches: the wicked witches of
East and West, and the good witches of North and South. In the land of
newsgroups, there are perhaps also different type of trolls. I can't say
they do good or bad, but i think they are much brainier then the gazillion
ignorant big-mouthing and shit-dropping fishes being involuntary victims of
troll.
Coby, you gotta give me a break and be specific. Say something like "Xah is
the only real troll genius who ignited thought productivity in the meager 8
months i've observed on c.l.l...." or "Xah is a born-again Hitler who stinks
inane ruckuses like a baby's cry...". This way, posterity can judge you
without guesswork. You'd have saved me the duty of following up with this
off-topic long meander. Why do you have to mention my name anyway? Out of
respect? Need a straw man? Your legs all wobbling in front of the
perspicacious Naggum? If for respect, I hereby humbly acknowledge that in
the eyes of scholars, 1 xah's message equals to 100 conversationalist's
slobber.
Rarely,
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
Xah Lee <···@xahlee.org> writes:
> Dearly beloved Erik Naggum,
>
> you wrote:
> > What do you (or the Scheme community) gain by insisting that Scheme is a
> > Lisp and thereby inhibiting any and all evolution in what "Lisp" is?
>
> That's an interesting question. The answer is: What do you (or the Scheme
> haters community) gain by insisting that Scheme is not a Lisp and thereby
> ticks your personal itch of what the evolution of Lisp is?
I don't think Erik said he hated Scheme. I certainly don't hate
Scheme. I find Scheme interesting. I understand why other people
find it interesting.
I am not "insisting" that Scheme is not a Lisp. I am merely defending
the legitimacy of the conceptual position that Scheme could be usefully,
or at least meaningfully, considered not to be a Lisp.
Ever get assigned a project by someone and then given someone else to
cooperate with you but had the feeling that either of the two of you
alone could do the project faster than the two of you together? That's
what I think about Lisp and Scheme. It's not an issue of illegitimacy.
It's merely an issue of working at crossed purposes. The number of expected
points of agreement is small, and so each community working separately will
not needlessly spin its wheels satisfying those who will not be satisfied,
but instead will work forward in conjunction with those who are closer to
their positions, and with whom cooperation is more rational to expect.
Sort of like you and me. I generally take no position on whether you are
right and I am wrong or vice versa. I mostly just think you and I have so
few points of agreement that it's not worth our spending a lot of time trying.
But on this point, I thought maybe we could find some common ground.
You're welcome to show me wrong, but in so doing, you might prove my
underlying point, that it's sometimes not worth trying. ;-)
Dear Kent Pitman,
you wrote:
> I don't think Erik said he hated Scheme.
Oh, but he does. He hates Scheme's guts. He wants to dice Scheme to million
pieces. In action or in words. Now don't say that i ever said Erik hated
Scheme, and we can now each start writing an essay on meaning and
interpretation. We can gang up together on Erik.
> I certainly don't hate
> Scheme. I find Scheme interesting. I understand why other people
> find it interesting.
Indeed. I, for example, certainly don't hate Common Lisp either. I find
Common Lisp not uninteresting. I understand other people have a right to
find Common Lisp interesting, and it should not be a laughing matter.
> I am not "insisting" that Scheme is not a Lisp.
Nor am I "insisting" that Scheme is a Lisp. Don't know about you, but I do,
however, insist that Scheme is a Lisp.
> I am merely defending
> the legitimacy of the conceptual position that Scheme could be usefully,
> or at least meaningfully, considered not to be a Lisp.
Yes, you are merely declaring that at a last stage of our game. I too, for
example, find it useful to think Common Lisp as supplementary dialect of
Lisp, and consider its naming conceptually legitimate.
> Ever get assigned a project by someone and then given someone else to
> cooperate with you but had the feeling that either of the two of you
> alone could do the project faster than the two of you together? That's
> what I think about Lisp and Scheme. It's not an issue of illegitimacy.
> It's merely an issue of working at crossed purposes. The number of expected
> points of agreement is small, and so each community working separately will
> not needlessly spin its wheels satisfying those who will not be satisfied,
> but instead will work forward in conjunction with those who are closer to
> their positions, and with whom cooperation is more rational to expect.
Ever got asked the question of trains and airplanes? It is not an issue of
legitimacy. Non sequitur has its place in communication. For example, if a
lady asked "what are you doing tonight?" and got a reply "I hate night
time.", then she knew not only the answer to her question, but also the
other's predilection and temperament. Diplomacy is maintained, views are
exchanged, and nobody officially refused anything.
It is quite interesting, to overhear a meaningful conversation of two person
where all intercourses are non-sequiturs.
> Sort of like you and me.
Sort of like me and you.
>I generally take no position on whether you are
> right and I am wrong or vice versa.
I generally take position with raving vice on whether i'm correct or you are
incorrect.
> I mostly just think you and I have so
> few points of agreement that it's not worth our spending a lot of time trying.
You mostly wily, in-perceptibly, inexpressibly-illogically, and perhaps
subconsciously, have digressed to some non-sensible utterance. It is so
bewildering and can make thinking machines speechless.
> But on this point, I thought maybe we could find some common ground.
> You're welcome to show me wrong, but in so doing, you might prove my
> underlying point, that it's sometimes not worth trying. ;-)
With this finale, my logical brain is totally flummoxed. I profess to have
little idea what is your meanings. I can however correctly sense it's one of
multiple things:
* a calling for a needless truce.
* on Kent Pitman and Xah Lee.
* a weird wrap up of the Scheme is a Lisp debate.
* a friendly chat.
* a Trojan horse to befuddle my brain.
I could not fathom anymore. I'm old. Life is diverse, life is diverse!
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Kent M Pitman <······@world.std.com>
> Organization: The World Public Access UNIX, Brookline, MA
> Newsgroups: comp.lang.lisp
> Date: Sat, 24 Feb 2001 17:44:58 GMT
> Subject: Re: Is Scheme a `Lisp'?
Kent M Pitman <······@world.std.com> writes:
> Xah Lee <···@xahlee.org> writes:
>
> > Dearly beloved Erik Naggum,
> >
> > you wrote:
> > > What do you (or the Scheme community) gain by insisting that Scheme is a
> > > Lisp and thereby inhibiting any and all evolution in what "Lisp" is?
> >
> > That's an interesting question. The answer is: What do you (or the Scheme
> > haters community) gain by insisting that Scheme is not a Lisp and thereby
> > ticks your personal itch of what the evolution of Lisp is?
>
> I don't think Erik said he hated Scheme. I certainly don't hate
> Scheme. I find Scheme interesting. I understand why other people
> find it interesting.
You don't think Erik "said he hated Scheme."
That's interesting; I'm not sure what other conclusion could be drawn
from the _dramatic_ hostility that is clear any time he makes mention
of Scheme. It's pretty clear that he holds considerable distain for
both the language and the proponents thereof. The only way I can see
there _not_ being a contradiction here is if your preferred definition
of "hate" varies considerably from those used by others.
> I am not "insisting" that Scheme is not a Lisp. I am merely
> defending the legitimacy of the conceptual position that Scheme
> could be usefully, or at least meaningfully, considered not to be a
> Lisp.
Once that metadiscussion comes up, it surely is appropriate to also
consider other "would-be-Lisps" and see whether or not they measure
up. It is interesting that nobody seems to gripe about Emacs Lisp
being called a Lisp, for instance.
--
(concatenate 'string "aa454" ·@freenet.carleton.ca")
http://www.ntlug.org/~cbbrowne/unix.html
This less-than-witty quote forces Emacs into -*-Quip-*- mode. I may
be wise, witty, and wonderful, but if I have a custom mode for this, I
obviously spend too much time manipulating fortune messages...
········@hex.net writes:
> It is interesting that nobody seems to gripe about Emacs Lisp being
> called a Lisp, for instance.
This is more than obvious to anyone. It is understood that CL is one
of the larger Lisps -- the "kitchen sink" if you will. Elisp is very
much a lisp, and to even mention this is silly if not completely
stupid (if you're implying that Emacs Lisp is questionable). It has
been around for a long time, and is not only a Lisp, but one of the
languages which helps define the family, often used as the example of
why Lisp-like languages are good extension languages.
Despite my open intense dislike for Scheme, and relative unease with
the many of their proponents, I do consider Scheme to be in the family
of Lisps, in the broadest sense, though this is partially because I
was taught this from the first day of Scheme, and it's difficult to
consider Scheme NOT a Lisp when it was pounded into you as one of the
notable dialects of Lisp early on in one's computer science
eduacation, before ever hearing of "lisp" as a computer language.
I hope others who've also read this post see how confused some are as
to what is and isn't a Lisp, considering that Emacs Lisp is in
question. Even if "being a Lisp" were related to the qualitative
distance to Common Lisp, I feel that elisp would qualify over Scheme.
dave
David Bakhash wrote in message ...
>
>I hope others who've also read this post see how confused some are as
>to what is and isn't a Lisp, considering that Emacs Lisp is in
>question. Even if "being a Lisp" were related to the qualitative
>distance to Common Lisp, I feel that elisp would qualify over Scheme.
>
You certainly are confused! ;-)
cheers,
felix
"felix" <············@freenet.de> writes:
> You certainly are confused! ;-)
please speak. This statement in itself has little value.
I stated that Emacs Lisp is most definitely a Lisp, and would be happy
to discuss it, though not at too much length, since it's obvious. And
in that discussion, it might even become more apparent why some people
choose _not_ to consider Scheme as part of the present-day Lisp
family.
It would help to know, felix, if you are familiar with Emacs Lisp.
Otherwise, it might be a difficult thing to discuss with you.
dave
David Bakhash wrote in message ...
>
> [...blabla...]
Well, I don't think it would make sense to do any more
nit-picking about language-details, since common lispers will
*always* find something to complain about (in other languages).
This is a political issue, not a technical one. Arguing about wether
elisp is more lispy than Scheme is just as stupid as doing the
opposite
I'm sure you can see how people in this monster-thread keep
repeating themselves.
What I find *really* stupid is when someone starts with nonsense
like "...I hate language XYZ, yes, I really hate it, etc.etc.".
Let's leave the "hate" stuff to Mr. Naggum.
cheers,
felix
In article <·······················@news.freenet.de>,
felix <············@freenet.de> wrote:
>
>> [...blabla...]
>
Hmmm...I sense a certain tone here.
>Well, I don't think it would make sense to do any more
>nit-picking about language-details, since common lispers will
>*always* find something to complain about (in other languages).
In my experience, they can find things to complain about in
Common Lisp, also. The syntax of LOOP comes to mind - I don't
like it myself, but it has the advantage of being powerful and
standard.
>This is a political issue, not a technical one.
Of course! It's kind of like natural languages: which are dialects
of a larger language and which are their own languages depends
heavily on the politics involved. I'm not a Platonist in programming
languages. I don't believe there is an archetypical Lisp, and that
we can just check out how much Scheme, Dylan, Common Lisp, Python,
Emacs Lisp, and COBOL differ from it.
Lisp, as a concept, is completely artificial, and whether we should
call implementation X a Lisp depends very heavily on what we want
to mean by Lisp. In some cases this might be structural, in other
cases political: if Scheme users have more in common with Ada users
than with Common Lisp users we might doubt the usefulness of a
category that includes Scheme and Common Lisp but not Ada.
Arguing about wether
>elisp is more lispy than Scheme is just as stupid as doing the
>opposite
As stated, I'd agree. I don't think doing either is stupid. It
allows us to find what people consider "lispy".
>What I find *really* stupid is when someone starts with nonsense
>like "...I hate language XYZ, yes, I really hate it, etc.etc.".
>Let's leave the "hate" stuff to Mr. Naggum.
>
What Mr. Naggum has been primarily saying is that he does not
consider Scheme a Lisp. He obviously isn't fond of Scheme, but
that's not what he has been stating very emphatically.
Heck, I like C++ (which seems to put me in the minority here), and
I don't consider it a Lisp. However, I do hate COBOL.
--
David H. Thornley | If you want my opinion, ask.
·····@thornley.net | If you don't, flee.
http://www.thornley.net/~thornley/david/ | O-
"David Thornley" <········@visi.com> wrote in message
························@ruti.visi.com...
>
> Heck, I like C++ (which seems to put me in the minority here), and
> I don't consider it a Lisp. However, I do hate COBOL.
>
Oh, come on, admit it, when you finished slogging your way down to
the procedure division, didn't you feel the tiniest bit of relief
at finally being able to write stuff that actually did something? :-)
Geoff
The way people refer to languages, you can't say* that when Scheme was created,
it was a Lisp, but because Lisp has evolved it isn't anymore. You might say
that it isn't a modern Lisp, but Erik and Kent go beyond that. I understand the
marketing reasons, but unless you want to change the categorization paradigm
implicit in the way English (and probably German, Finnish, etc.) handles
language names, the solution must lie elsewhere.
Beowulf was written in an English. This post is written in Modern English.
* Well, you can say anything you want. But not if you want to truthfully use
words with cocsnsusual meanings.
dear ········@aol.com (DvdAvins),
Excellent analysis! (see attached below)
By the way, both Erik and Kent would no longer bluntly say "Scheme is not a
dialect of Lisp". Xah have pricked their conscience.
An important discovery in this thread is that quite a few Common Lispers
HATE Schemers to death. I knew the two groups don't get along, but have not
observed the degree of hatred exhibited here. Xah made a sapient remark that
in reality Scheme might have helped Common Lisp's existence.
Perhaps, someone like to start a new debate on "does Scheme help Common Lisp
in the market?". I would think very much so. Let's grope for facts.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: ········@aol.com (DvdAvins)
> Organization: AOL http://www.aol.com
> Newsgroups: comp.lang.lisp
> Date: 01 Mar 2001 23:02:27 GMT
> Subject: Re: Is Scheme a `Lisp'?
>
> The way people refer to languages, you can't say* that when Scheme was
> created,
> it was a Lisp, but because Lisp has evolved it isn't anymore. You might say
> that it isn't a modern Lisp, but Erik and Kent go beyond that. I understand
> the
> marketing reasons, but unless you want to change the categorization paradigm
> implicit in the way English (and probably German, Finnish, etc.) handles
> language names, the solution must lie elsewhere.
>
> Beowulf was written in an English. This post is written in Modern English.
>
> * Well, you can say anything you want. But not if you want to truthfully use
> words with cocsnsusual meanings.
Dear Erik Naggum,
you wrote:
> Really? Just because it does not need repeating, does not mean that it
> has been rebutted or retracted.
yes, also there is a thing called silent confession, like, if someone slaps
you in court, and you quiet down, then you are guilty.
> If anything, we have established _why_
> Scheme is not a Lisp.
You meant to say: "If anything, I have established 'The reasons for those
who like to consider that Scheme is not a Lisp'", right right?
The other possibility is that you, Erik Naggum, are out of the jurisdiction
of reason. That, comp.lang.lispers'll just have to accept too.
Like, once i read an article in i think Playboy that the woman author is
dithering over a super dildo and a boyfriend. She concluded that although
the super dildo is so much better a love machine and a boyfriend has so many
flaws and so woeful to maintain, but she accepted a boyfriend over the super
dildo because she is a human restrained by humanity, after all. The super
dildo won't comfort her when she's in dire need of words, for instance, or
chained and whipped, for another instance.
yeah, so we comp.lang.lispers accept Nagging Naggum's flaws and problems,
and let you subtly fuck around with reason and people at times, because we
consider your unworldly views on the whole worthy. In this particular case
for example: "The reasons for those who like to consider that Scheme is not
a Lisp" is a food for thought.
Comfy comfy my child. Do you still have a point on "Scheme is not a Lisp"?
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Erik Naggum <····@naggum.net>
> Organization: Naggum Software, Oslo, Norway
> Newsgroups: comp.lang.lisp
> Date: 02 Mar 2001 12:45:48 +0000
> Subject: Re: Is Scheme a `Lisp'?
In article <·················@xahlee.org>, Xah Lee wrote:
>Dear Erik Naggum,
>
>you wrote:
>> Really? Just because it does not need repeating, does not mean that it
>> has been rebutted or retracted.
>
>yes, also there is a thing called silent confession, like, if someone slaps
>you in court, and you quiet down, then you are guilty.
Not in my country.
marc
>
> Xah
> ···@xahlee.org
> http://xahlee.org/PageTwo_dir/more.html
>
>
>> From: Erik Naggum <····@naggum.net>
>> Organization: Naggum Software, Oslo, Norway
>> Newsgroups: comp.lang.lisp
>> Date: 02 Mar 2001 12:45:48 +0000
>> Subject: Re: Is Scheme a `Lisp'?
>
········@aol.com (DvdAvins) writes:
> Beowulf was written in an English. This post is written in Modern English.
>
Debatable. Do you have any references that the language Beowulf was
written in was commonly referred to as English? The remaining
manuscripts are from around 1000 CE but the probable date of
composition varies according to sources from 650 to 800. At that time
West-Germanic and North-Germanic were not yet separated enough to be
mutually incomprehensible, let alone something like English.
ObLisp: I would not call a lisp-like programming language without
strings that has to use symbols and EXPLODE a Lisp today, although
such a language could refer to more precedents in the lisp family tree
than Scheme, and I don't think Scheme can be referred to as a Lisp
either.
--
Lieven Marchand <···@wyrd.be>
Gla�r ok reifr skyli gumna hverr, unz sinn b��r bana.
········@hex.net writes:
> Kent M Pitman <······@world.std.com> writes:
> >
> > I don't think Erik said he hated Scheme. I certainly don't hate
> > Scheme. I find Scheme interesting. I understand why other people
> > find it interesting.
>
> You don't think Erik "said he hated Scheme."
>
> That's interesting; I'm not sure what other conclusion could be drawn
> from the _dramatic_ hostility that is clear any time he makes mention
> of Scheme. It's pretty clear that he holds considerable distain for
> both the language and the proponents thereof.
Are you talking about the Scheme or Scheme community?
> Once that metadiscussion comes up, it surely is appropriate to also
> consider other "would-be-Lisps" and see whether or not they measure
> up. It is interesting that nobody seems to gripe about Emacs Lisp
> being called a Lisp, for instance.
Scheme is about purity. Common Lisp is about usability. See where they
are heading?
--
Janis Dzerins
If million people say a stupid thing it's still a stupid thing.
"Xah Lee" <···@xahlee.org> wrote in message
······················@xahlee.org...
> Then at the other extreme is the
> relatively rare Victorian propensity where each post is a gem of
literature
> carefully crafted and researched for an entire century of readers to
> appreciate and archive. Xah, Erik Naggum, and Kent Pitman's posts are
> exemplary of this style, to name a few acquaintances like myself.
I suspect that Erik Naggum and Kent Pitman spend little time _researching_
their posts. Erik and Kent do not write like their opinions are based on
second-hand knowledge. I believe they speak from actual experience, not
just from what they've read in a book, which is what makes their posts worth
reading.
"news.earthlink.net" <········@earthlink.net> writes:
> "Xah Lee" <···@xahlee.org> wrote in message
> ······················@xahlee.org...
> > Then at the other extreme is the
> > relatively rare Victorian propensity where each post is a gem of
> literature
> > carefully crafted and researched for an entire century of readers to
> > appreciate and archive. Xah, Erik Naggum, and Kent Pitman's posts are
> > exemplary of this style, to name a few acquaintances like myself.
>
> I suspect that Erik Naggum and Kent Pitman spend little time _researching_
> their posts. Erik and Kent do not write like their opinions are based on
> second-hand knowledge. I believe they speak from actual experience, not
> just from what they've read in a book, which is what makes their posts worth
> reading.
A lot of what Pitman says seems representative of "what's in the
Hyperspec." Seeing as how he was rather involved in writing it, well,
draw your own conclusions :-). I'm reasonably certain that he's read
it once or twice :-).
There certainly seems to be a tendancy for this newsgroup to see
postings written in perhaps exceedingly erudite style. That would go
along with the considerable complexity inherent in Common Lisp; those
that can cope with CL likely can do sophisticated things in English
too :-).
In comparisons, while Xah's postings make more use of obscure English
vocabulary than the others, which _might_ suggest greater
"sophistication," he then writes something that leaps out and shouts
"Bad grammar!" which rather undermines the impression of
sophistication.
It is interesting to note that some degree of "literary interest"
<http://www.jammed.com/~jwa/Misc/scoville_unix_as_literature.txt>
seems to also be correlated with people in the Unix community. As
much as the Lisp community likes to denigrate Unix, both tend to have
the common characteristic of being quite literate...
--
(reverse (concatenate 'string ··········@" "enworbbc"))
http://vip.hyperusa.com/~cbbrowne/nonrdbms.html
LISP car-and-cdr worlds are a more reasonable representation of the things
that make life interesting than fixed decimal(15) or FILE OLDMSTR RECORD IS
PAYROLL.
-- Bernie Greenberg.
<········@hex.net> wrote in message
···························@news6.giganews.com...
> "news.earthlink.net" <········@earthlink.net> writes:
> In comparisons, while Xah's postings make more use of obscure English
> vocabulary than the others, which _might_ suggest greater
> "sophistication," he then writes something that leaps out and shouts
> "Bad grammar!" which rather undermines the impression of
> sophistication.
And, I would assume that this impression is also a calculated effect. We we
have seen how Xah plays - both with language and with the people in this
group. The Xah is quite an amusing character at times. The Xah that can be
read is not the eternal Xah.
faa
Dear warden Browne,
> In comparisons, while Xah's postings make more use of obscure English
> vocabulary than the others, which _might_ suggest greater
> "sophistication," he then writes something that leaps out and shouts
> "Bad grammar!" which rather undermines the impression of
> sophistication.
Splendid potshot.
Want to know what i think of you? You are the archetype of bookworm: Read
many, ingest little; opinion lots, original none; statistics you got,
interpretation you got wrong. There is a kind of worm that sucks on blood at
one end and shits blood on the other end, used to be used for bloodletting
in the old med school. With regards to data, you are like that. In unix
jargon, it's called a pipe.
> It is interesting to note that some degree of "literary interest"
> <http://www.jammed.com/~jwa/Misc/scoville_unix_as_literature.txt>
> seems to also be correlated with people in the Unix community. As
> much as the Lisp community likes to denigrate Unix, both tend to have
> the common characteristic of being quite literate...
It is actually not surprising to me, that you would quote the most low
quality, lurid, myth riding, tabloid-class writings by internet-proclaimed
journalist. (its author is moron numero uno.) You have done damage to
society now by citing that trite article celebrated by the community it
eulogizes. Folks, i don't know if there's any correlation of literary
penchant and unix liking, but can tell you this: The unix fanatics, are the
shallowest of writers. They are all the poet, novelist, journalist,
satirist, stylist, playwright who could not make it into the literary
circle. (and they are couldn't make it into the computer science circle
either.) In their eyes, the cheapest puns, word play, and nonsense is grand
literature. (the likes of Larry Wall and unix coders.) There is a center of
these nitwits on the net, and that's slashdot.com. (and I can tell you that
Christopher Browne is an avid member there.)
Ever heard that "coders cannot write"? That's the unix folks, with their
fucking man pages et al.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: ········@hex.net
> Organization: Giganews.Com - Premium News Outsourcing
> Newsgroups: comp.lang.lisp
> Date: Sun, 25 Feb 2001 00:27:12 GMT
> Subject: Re: Is Scheme a `Lisp'?
Xah Lee <···@xahlee.org> writes:
If there must a purpose to this post, then it is that i urge those
conversationalists who insists on their brand of morality of netiquette to
at least double the time they spend on composing messages so that their
posts might have more value in a scholarly point of view, if they are
incapable or otherwise unwilling to broaden their minds into the
philosophies of netiquette. I'm here expanding their brain from the mundane
notion of noise/signal to revolutionary signal/value idea. You fucking
buckets of morons.
scholarship and conversation are not mutually exclusive. many (quite)
scholarly journals support abstraction, caching and recursion in both
form and content. verbosity has its place, too, obviously.
thi
····@goldshoe.gte.com (Dorai Sitaram) writes:
> What you are doing is using arguments for
> Scheme not being Common Lisp to claim, out of the blue,
> that Scheme is not a Lisp!
My purpose in this discussion is not to say there isn't a possible way
of viewing the problem along different lines, but merely to say that
it is often useful in a complex world to find ways to cleave things
along a line for the purposes of discussion.
In this case, we were discussing whether there existed a principled
reason for assuming that Scheme was not a Lisp and I asserted there
was. Incidentally, I would consider it an eqiuvalent statement at the
abstraction level we're entertaining to say that "Scheme is a Lisp,
but Common Lisp is not." What I really intend to e discussing, even
though it wasn't framed this way, is the question of "Are Scheme and
Common Lisp siblings or some more distant relationship such as uncle
or cousin." My feeling is that Scheme is more distant, and I have
tried to offer reasons for that.
It is possible to weaken the definition of Lisp sufficiently so as to
include a great many things.
It's McCarthy who coined the term, so one way of settling this definitively
would be to ask him. He could say what was Lisp and what wasn't, but
that wouldn't be very satisfactory. It would imply that there was no
mechanism that would survive into future generations for detecting other
Lisps or non-Lisps.
Moreover, I've said often of "wisdom" that what it is about is not "being
right" (because I'm not sure there is one uniquely determined "wise" result
to any given problem) but "understanding why a decision is made". It doesn't
much matter to me if people think Lisp is or is not a Scheme as long as they
confront all of the issues making up such a decision and don't just act
superficially on the first few things they confront (usually parens and
lambdas). People I know and respect and consider to be wise will reach the
opposite conclusion that I have, based on the same facts, and I do not think
their decision to be lacking in wisdom.
To me, it's the discussion that matters. If you remove the discussion and
merely assert truth, you are left only with dogma. And I wouldn't have
someone merely agree with me just because they thought I was a nice guy
and think they were being wise for so doing. In a given context, for example,
pressed for time, it might be wise to go with someone's opinion that you
respect because the circumstances (e.g., lack of time) call for that. But
given arbitrary time and resources, I think the identical decision is not
wise. I hope that makes sense. I really think it's critical to avoiding
the creation of religious dogma on these issues.
Now, I don't mean to be being slippery here. Dorai is asking whether proving
CL and Scheme are different proves Scheme isn't a Lisp. That's a fair
question. There is, by informal mutual agreement of the various language
designers during the ISO design, at McCarthy's request, no Lisp which IS
the reference Lisp. McCarthy asked that it be a family, not a language.
So there is no reference model to compare Scheme to, nor is there a sense
of distance that is "too far". Yet other languages are commonly accepted as
non-Lisps. For example, Smalltalk. Or, usually, Dylan. (Though I think
Dylan is in some respects more Lispy than Scheme.)
There being no predefined criterion of what is a Lisp, one instantly knows
there will not be a clear outcome of this debate. So the best one can hope
for is an englightening discussion of what things matter to Lispers. I have
therefore enumerated a lot of the most prominent similarities between
Scheme and Lisp and have asserted that, at least for me, Scheme seems very
distant from Lisp on a number of those so-called "close" details. Moreover,
on a number of those, I think Scheme is closer to other languages.
There is no way of getting numerical about this, so I can't be that precise.
But I wanted to at least motivate a sense that if there were gravity involved,
I think Scheme would fall into the gravity well of another language, not
of Lisp, because it has more kindred spirits there in terms of where it's
going and what kinds of decisions it makes.
There are any of a number of empirical ways to verify this claim of
mine that the two are distant. For example, Scheme has its own
newsgroup, for example, and its members and topics have almost no
overlap with ours. Few people have asserted that Scheme has a right
to be under comp.lang.lisp, so I infer that they don't feel kept from
their rightful homeland. Mostly, in my experience, they either ignore
or spit on the name Lisp, except historically to acknowledge Scheme's
partial parentage from McCarthy's Lisp (though it also shares an Algol
parent, and in fact names that parent prominently in the early Scheme
reports). Also, Scheme and Lisp used to share a conference, Lisp &
Functional Programming, but the two grew apart. Almost no Lisp
programmers submit papers to the FP conferences now. Again, a
self-made split. Or, if there was exclusion here, it was not of my
devising. (I can remember people at the L&FP conferences in the mid
1980's casting open aspersions to Lisp/Common Lisp in their talks as
if the mere mention of the word was dirty enough that they didn't have
to elaborate their sense of associated lack of aesthetic; it was
written in their tone. It was disdainful, and it was quite tolerated
by the Schemers present without any manner of apology, and it actively
put me off to attending the L&FP conferences.) Again in teaching,
Scheme and Lisp have almost no overlap in terms of who teaches what.
People don't teach "Lisp" by teaching "Common Lisp" and "Scheme" as
mere variants; the two are very different and there's little overlap
in teaching style or materials.
Personally, I think closeness of language family is best judged by
people saying what they'd substitute if they had to. I recall someone
I met in Rio de Janeiro commenting to me, when I tried to use Latin
American Spanish to talk to him, "that's ok.. we'd rather have someone
speak Latin American Spanish than Continental Portuguese. it feels
more similar." That doesn't prove conclusively that Brasilian
Portuguese a kind of Spanish nor Continental Portuguese not a kind of
Portuguese, but it does hilight that there are multiple ways to view
the same situation.
> >Not everyone likes any particular genre of fiction. Some like mysteries.
> >Some humor. Some sci-fi. Some westerns. Sometimes there's an overlap.
> >But there is no writer who writes to all genres together. And the writer
> >who succeeds knows his target audience and seeks to serve that audience.
> >So, too, with languages, I think.
>
> But he's still a writer. Mystery writers don't
> unilaterally say that sci-fi writers are so different
> from themselves that they (the sci-fi writers)
> cease to be writers at all.
I'm not saying there's no supercategory that Scheme and Lisp share.
I'm saying there is some meaningful supercategory of CL that Scheme
does not share. Scheme and CL are surely programming languages,
for example. That's more equivalent to your "writer" supercategory.
Further, in CL we know there are not just hierarchies but heterarchies.
Scheme clearly has some lispy-mixin that gives it a few superficial
properties of Lisp. Does everyone who mixes in such a mixin get to
call itself a Lisp? Scheme has algolish-mixin, too. Is it definitely
an algol? Is CL? CL took lexical scoping from Scheme which got it from
Algol. What is the POINT of having language families if you're gonig to
assert that unambiguously everyone who shares properties with a parent IS
the parent? Does no child ever take on an identity strong enoguh to call
its own?
I think of Lisp as just a gang of people who were using a certain language
from the begining of Programming Time. Every now and then we gain or lose
people, not always at a change from one "language" to another. Maclisp to
Common Lisp didn't lose ground--it gained it, I think. But Scheme took
some people from Lisp and headed off some would-be lispers. Those people
aren't just down some blind alley--they are a different constituency.
Those people won't accidentally blunder back to CL unless some employer
makes them. That's what makes them a different language. Not language
semantics. Constituency and interest and direction. They have a set of
people working to fulfill their needs, as we have for ours. We pass in the
night, sit around the campfire, swap stories, learn from each other,
try to build communicational common ground. But we're not on the same path,
even if we're momentarily in the same place.
All just my opinion, as I said. I'm not denying other points of view; I'm
just pushing mine because it's a less-talked-of view and I feel it has
a right to be aired, just to get people thinking. We could just end the
discussion with "of course it's a lisp. don't you see all the parens?"
But what would we have learned?
Dear Kent Pitman,
>...
>Now, I don't mean to be being slippery here. ...
You have been.
You have been evasive, roundabout, wordy, diffusive, pretentious,
impartial-sounding, bigoted, assiduously humbling and humbug.
Do you need me to analyze your previous long-winded post paragraph by
paragraph to make your foolishness appear plain English? I should not think
so.
I (and other people) appreciate your knowledge and experience duly, but you
need not to grumble at times.
Thank you. (^_^)
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Kent M Pitman <······@world.std.com>
> Organization: The World Public Access UNIX, Brookline, MA
> Newsgroups: comp.lang.lisp
> Date: Sat, 24 Feb 2001 16:13:30 GMT
> Subject: Re: Is Scheme a `Lisp'?
"Kent M Pitman" <······@world.std.com> wrote in message
····················@world.std.com...
> ····@goldshoe.gte.com (Dorai Sitaram) writes:
>
> I think of Lisp as just a gang of people who were using a certain language
> from the begining of Programming Time. Every now and then we gain or lose
> people, not always at a change from one "language" to another. Maclisp to
What people, interest groups, or organizations do you estimate as making up
the trunk of the Lisp family right now?
in article ···············@world.std.com, Kent M Pitman at
······@world.std.com wrote on 2/24/01 11:13 AM:
> My purpose in this discussion is not to say there isn't a possible way
> of viewing the problem along different lines, but merely to say that
> it is often useful in a complex world to find ways to cleave things
> along a line for the purposes of discussion.
The way we draw conceptual boundaries is an interesting subject...
In a real sense our concepts and categories are arbitrary. They are real
only to the extent that they are useful. An Eskimo has over a dozen
categories for snow, a skier may have four or five, the average person two:
snow and slush. If it's slushy outside, be sure to wear you rubber boots...
The average hacker sees the Lisp family in general terms, because that suits
his needs. If you are a specialist, your needs are greater, and your
categories are more refined.
My favorite example of the fluidity of conceptual boundaries is a football
play. Surely a football play is a discrete "event", worthy of a
distinguishing category. It starts with a whistle and ends with a whistle.
But the nature of the "event" depends on who you are. If you are a fan, a
"play" is a useful category. But if you are the quarterback, you know that
the touchdown pass you just threw was set up by a whole series of previous
plays. The success of the previous plays caused the cornerback to move in
two steps. Two steps were all you needed. For the quarterback a more
meaningful category for the event would be a "sequence of plays". If you
are the coach, you know that even a "sequence of plays" is an inadequate
parsing of the event. The plays that set up the touchdown were successful
because of the new running back that you recently acquired. The event is
really just a tiny blip within the context of your larger team strategy.
There is also an interesting economy at work here. Concepts focus our
attention. We tend to see only those things that fit into our conceptual
systems. Clearly this is a necessary strategy. The search space of "raw
reality" is intractable. Without conceptual preprocessing and filtering, we
would be hopelessly lost. Because they are necessary and because they are
useful, we are reluctant to modify our conceptual systems. We are reluctant
to "pay" attention to new ways of slicing the conceptual pie. People are
conservative and often hostile toward anything that disrupts the
conventional view.
Saying that Scheme is not a Lisp is not so much a statement of fact as it is
a challenge to relax and reexamine our conceptual boundaries. If you relax
your conceptual boundaries, it may result in new insights and a fresh
synthesis. If you don't, you will only see things that you've seen before.
Cheers,
Glen
(Be sure to wear your rubber boots. Actually in this newsgroup, asbestos
underware might also be more appropriate ...)
�
Glen Foy <······@bellsouth.net> writes:
> An Eskimo has over a dozen categories for snow
According to Geoffrey K. Pullum[1], this is wrong. He bases this on a
speech and a research note by Laura Martin[2] from Cleveland State
University. It all started with a misreading Franz Boas' introduction
to "The Handbook of North American Indians" (1911). That's all.
A few minutes of researched turned up an interesting discussion of the
problem [3].
Alex.
[1] "The Great Eskimo Vocabulary Hoax", Natural Language and
Linguistic Theory, 7, p 275-281, 1989. Also available as part of
"The Great Eskimo Vocabulary Hoax, and Other Irreverent Essays on
the Study of Language".
http://www.amazon.com/exec/obidos/ASIN/0226685349/102-8342819-4456150
[2] http://www.csuohio.edu/a_and_s/admin/academic/deans/lm.htm
[3] http://www.ling.ed.ac.uk/linguist/issues/5/5-1239.html
--
http://www.geocities.com/kensanata/
Coffee should be black as hell, strong as death and sweet as love.
-- Turkish proverb
Alex Schroeder <·········@yahoo.com> writes:
> Glen Foy <······@bellsouth.net> writes:
>
> > An Eskimo has over a dozen categories for snow
>
> According to Geoffrey K. Pullum[1], this is wrong. He bases this on a
> speech and a research note by Laura Martin[2] from Cleveland State
> University. It all started with a misreading Franz Boas' introduction
> to "The Handbook of North American Indians" (1911). That's all.
It's much more fun to go with the claim that "Eskimos have over 150
words for snow, all of them roughly equivalent to `crap.'"
[And I'm quite aware that they prefer being called Inuit...]
--
(reverse (concatenate 'string ··········@" "enworbbc"))
http://vip.hex.net/~cbbrowne/
"I have stopped reading Stephen King novels. Now I just read C code
instead." -- Richard A. O'Keefe
From: ····@goldshoe.gte.com (Dorai Sitaram) to Kent Pitman:
> Thank you very much for the pointer. I carefully read
> it through. You seem to initially use the word
> "political" in an unpejorative sense to describe
> community and subcommunity activity, and I thought you
> were going somewhere with it. But in the end you
> "celebrate" the difference between Common Lisp and
> Scheme by saying that one of them can be excluded from
> the community and need not be considered a Lisp at all.
> That's a tricky syllogism you slip in there.
That's right, Doris.
Kent Pitman is the no-show-class of poetic syllogist. Amorphous writings
that so bends the brain.
You said to Kent:
> Thank you very much for the pointer.
No need to thank him. Let him thank himself. (recall that he's the balance
keeper). He slips his personal bias into his humbly so-so yo-yo
neutral-sounding grand confusion. The pitcher with a bleeding heart.
>I carefully read it through.
No need for that either. Like biting into a sour Apple, you knew it's sour
all the way.
> I appreciate and commend you for the overall tolerant,
> all-surveying tone in the essay, so more's the pity
> that the actual content is exclusionary.
Good call. !!=High five=!!
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: ····@goldshoe.gte.com (Dorai Sitaram)
> Organization: GTE Laboratories Incorporated
> Newsgroups: comp.lang.lisp
> Date: 23 Feb 2001 22:21:55 GMT
> Subject: Re: Is Scheme a `Lisp'?
"Kent M Pitman" <······@world.std.com> wrote in message
····················@world.std.com...
> I think a more defensible claim is "There is reason not to consider
> Scheme a Lisp." It's certainly an undeniable fact that certain people
> do consider Scheme a Lisp
After reading Kent Pitman's article "Lambda, the Ultimate Political
Party" I've gained insight into reasons why someone might argue that
Scheme is not a Lisp. The question at hand, however, is "What is
Lisp?" not "What do you want Lisp to be?" Lisp is a set of languages
that were set in motion by McCarthy's implementation. It is an
evolving set, it is a tree. The enduring idea that set the growth of
that tree in motion was the decision to represent symbolic information
externally by lists and internally by list structure and to represent
programs in the same way. There were other good ideas but none were
essential enough to set the system apart from existing languages. And
the ideas were always evolving right from the beginning, for example
McCarthy says the appearance of an interpreter coded by S.R. Russel
was unexpected. This evolution is why it is hard to find very many
characteristics that apply to all Lisps (as I've failed to do). Every
new Lisp carries on a branch of ideas, drops others, and adds new
ones. It's also important to understand that each branch involves a
complicated mixture of purposes and needs of the people writing and
using the Lisp. It's also important to understand that the concept
Lisp has very little to do with any potential evaluation of the
language. Saying a language is a Lisp, is a very scant technical
assertion about a language.
So here I've outlined the concept I associate with 'Lisp'. It's
possible that many people have a vaguely similar concept. The
misunderstanding arises when people attribute more similarities among
Lisps than actually exist--hasty generalization. How are the
consequences of this poplular misunderstanding avoided? One option is
not to emphasize that your language is a Lisp; give it a different
name. Another other option is to claim than none of the other
languages are really Lisps and that your favored language is the one
true Lisp.
As far as Scheme goes, I can now look at the language as a branch that
has weakened it's ties to the tree. The only way for the Lisp tree to
continue to grow is through the people and organizations that keep it
alive. The Scheme branch is significant because it has grown to be
the first Lisp experienced by many. This could be influential in
taking more of Lisp in Scheme's direction, which is not what some
people want. While I still consider Scheme a Lisp, I don't thoroughly
understand this break Scheme creates yet, but I respect the opinions
of Erik and Kent, and intend to keep this in mind as I gain more
experience with Lisp.
Erik Naggum <····@naggum.net> writes:
> * David Bakhash <·····@alum.mit.edu>
> > Lastly, it's not wise to label Wall based on something he said
> > once, out of context.
>
> Oh, I know the context a little too well. Larry Wall's anti-Lisp
> stance is legendary.
I did not know this, frankly, and considering the direction of Perl
these days, with respect to language features, I wouldn't have guessed
that Wall was anti-Lisp.
dave
David Bakhash wrote:
>Wall's ignorance with respect to _Common_ Lisp might be based on seeing Scheme code, in
>which case I would actually agree with his statement.
hmm... to me scheme ``looks'' more "lispier" than typical common lisp.
as of speaking beauty: both are the most beautiful languages in the
world.
programs also, by far. scheme programs look worse than common lisp. but
this depends on the extension. drscheme units e.g. look very perlish.
(duck and run :)
for example this random drscheme code:
Lots of unusual sometimes MAGIC characters: % ^ / [ ].
And also note the -P habit to postfix uppercase chars with a special
meaning. certainly. but lisp has only one P, they use for GUI a lot. too
abbrevated in my eyes.
(define convertU
(unit/sig convertS
(import errorS plt:userspace^)
;; slider-cb : slider% event% -> void
;; to use fahr->cel to perform the conversion
(define (slider-cb c s)
(local ((define (in-slider-range x)
(cond
[(<= SLI-MIN x SLI-MAX) x]
[else (error 'convert-gui "result out of range for Celsius
slider")])))
(send sliderC set-value
((compose in-slider-range 2int fahr->cel) (send sliderF
get-value)))))
--
Reini Urban
http://xarch.tu-graz.ac.at/autocad/news/faq/autolisp.html
In article <··················@ruti.visi.com>, David Thornley
<········@visi.com> writes:
>In article <·············@vermin.dsl.snfc21.pacbell.net>,
>Aaron Kushner <····@netcom.com> wrote:
>>Christian Lynbech <···@tbit.dk> wrote:
>>> A former colleague, knowing my fancy for Lisp, used to cite the
>>> following Larry Wall quote (this is from memory, with the usual bunch
>>> of disclaimers):
>>
>>> Lisp programs has all the appeal of toe-nail clippings in
>>> a bowl of soup.
>>
>>The actual quote was:
>>
>> Lisp has all the visual appeal of oatmeal with fingernail clippings
>> mixed in.
>> --Larry Wall in <······················@netlabs.com>
>
>Does anybody have a reason why I should pay any attention to a Perl
>designer and implementor about language or program aesthetics? It's
>like a COBOL fanatic complaining about keyword bloat in a language.
Larry Wall is a pretty smart and generous guy with a penchant for thinking
"outside the box". That's one reason, and i'm sure there are others.
glauber
----- Posted via NewsOne.Net: Free (anonymous) Usenet News via the Web -----
http://newsone.net/ -- Free reading and anonymous posting to 60,000+ groups
NewsOne.Net prohibits users from posting spam. If this or other posts
made through NewsOne.Net violate posting guidelines, email ·····@newsone.net
In article <············@news.netmar.com>, <··········@my-deja.com> wrote:
>In article <··················@ruti.visi.com>, David Thornley
><········@visi.com> writes:
>>
>>Does anybody have a reason why I should pay any attention to a Perl
>>designer and implementor about language or program aesthetics? It's
>>like a COBOL fanatic complaining about keyword bloat in a language.
>
>Larry Wall is a pretty smart and generous guy with a penchant for thinking
>"outside the box". That's one reason, and i'm sure there are others.
>
Those are very good reasons why I should pay attention to him
in general, and I frequently mention his three cardinal virtues
of programming (laziness, impatience, hubris). There are other
reasons. He's very good at being amusing and insightful at the
same time.
However, anybody who would have designed Perl has an aesthetic
sense sufficiently different from mine that it simply does not
apply to me. Sort of like anybody who thought E.T. was a
profound and moving movie, only more so.
And, yes, I regularly use Perl effectively, and I usually enjoy
working on my Perl projects. It's the aesthetics I'm talking
about here.
--
David H. Thornley | If you want my opinion, ask.
·····@thornley.net | If you don't, flee.
http://www.thornley.net/~thornley/david/ | O-
From: ··········@my-deja.com
> Larry Wall is a pretty smart and generous guy with a penchant for thinking
> "outside the box". That's one reason, and i'm sure there are others.
Oh dear Glauber you gullible thing.
You don't listen, do you?
> Larry Wall is a pretty smart and generous guy with a penchant for thinking
> "outside the box".
That's what all votaries perceive of of their cult leaders. What an
archetype you are.
Victims of nasty cults have one commonality: they are not super smart.
Although I don't know you, i hereby speculate that you never in your life
made significant learning of any particular area. (not even Perl!) Have you
ever published some papers of certain significance? Come forward and prove
me wrong! Or, thank me for god for broadening your minds. (i just like the
sound of that.)
If Larry Wall dropped dead some 15 years ago, gosh, the computing world
would be a much powerful, flexible, and beautiful place without monkey
coders and syntax sugar babbling nitwits asking to be kicked on every
street.
Little people: worship me for my "outside of the box" thinking now!
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: ··········@my-deja.com
> Organization: NewsOne.Net - Free Usenet News via the Web - http://newsone.net/
> Newsgroups: comp.lang.lisp
> Followup-To: comp.lang.lisp
> Date: 21 Feb 2001 17:03:10 GMT
> Subject: Re: Perl becoming Lispier
<··········@my-deja.com> wrote in message
·················@news.netmar.com...
> Larry Wall is a pretty smart and generous guy with a penchant for thinking
> "outside the box". That's one reason, and i'm sure there are others.
Well, no offense, but how the hell does that necessarily make him a good
language designer? Some schizophrenic walking the streets may thinkWAY
outside the box and yet I wouldn't necessarily use a language designed by
him. Warren Buffet gives a heck of a lot of money to charitable causes, but
I wouldn't have him design a language either. And Xah seems... Oh well, two
out of three ain't bad, but you get the drift. Your criteria may make Larry
an admirable human being, but it still doesn't necessarily make him a good
language designer.
> glauber
And a "True Glauber" you seem to be...
faa
A crook sung:
······································@perl.org/msg00409.html
(Subject: Re: Transcription of Larry's talk; Date: Wed, 18 Oct 2000 10:27:40
-0700)
Glauber (··········@my-deja.com) choired:
> Here are Larry Wall's musings on the future of Perl, in case you're
> interested in this kind of thing:
> ······································@perl.org/msg00409.html
>
> It looks like Perl 6 is going to have dynamic and static types like Common
> Lisp.
Marco Antoniotti (·······@cs.nyu.edu) reverberated:
> Just to quote out of context.
>
> I think ugly can be beautiful, and that beautiful can get ugly real
> quick. I think in particular of Lisp, which is the most beautiful
> language in the world, and every program in Lisp is real ugly.
My dear readers, we have here an articulate rogue and his automata brooding
and delighting in sensible nonsense.
People, you must understand:
Artistic literary expressions is the bane of clear thinking and logicality.
Larry Wall, is a selfish happy-go-lucky person of little brain. (Linus
Tovalds too) He likes to brag that he is a linguist, but i doubt he has made
any contributions to linguistics at all. (or, if any linguists pay attention
to him.) He likes to elaborate how he designed Perl. The fact is, it's a
stupid hack that got lucky. (like, Linux.) Even popular, stupid hacks can
never hide themselves. That is why, you don't see scholars, or computer
scientists praising Perl, but on the contrary, you have billions upon
billions of ignorant morons praising Perl and sporting a "Linus for
President" button. If you have studied famed crooks, you'll note that often
they have this kind of personality. They start stupidly and by happenstance
noticed that people are gullible. Gradually, they developed to cash in their
ways, keep distorting truth or history, and ride on to become saints. The
above, in fact, speaks much of Unix's history and creators too.
Is Xah Lee a crook too? How can you judge my objectivity? Very easy: Study
study and study. Once you are a historian, mathematician, computer
scientist, or a learned and not-happy-go-lucky man in one way or another,
then you can.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
"Perl: all unix's stupidities in one."
> From: ··········@my-deja.com
> Organization: NewsOne.Net - Free Usenet News via the Web - http://newsone.net/
> Newsgroups: comp.lang.lisp
> Followup-To: comp.lang.lisp
> Date: 16 Feb 2001 21:38:50 GMT
> Subject: Perl becoming Lispier
Xah Lee <···@xahlee.org> writes:
> Is Xah Lee a crook too?
Perhaps Xah Lee is an articulate rogue delighting in brooding upon
sensible nonsense.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
In article <············@content-integrity.com>,
Joe Marshall <···@content-integrity.com> wrote:
>Xah Lee <···@xahlee.org> writes:
>
>> Is Xah Lee a crook too?
>
>Perhaps Xah Lee is an articulate rogue delighting in brooding upon
>sensible nonsense.
>
Xah Lee is either a very strange human or a very impressive computer
program, and I've never been able to figure out which. If he is
written in Common Lisp, then I suppose he's on-topic here.
--
David H. Thornley | If you want my opinion, ask.
·····@thornley.net | If you don't, flee.
http://www.thornley.net/~thornley/david/ | O-
From: ········@visi.com (David Thornley)
> Xah Lee is either a very strange human or a very impressive computer
> program, and I've never been able to figure out which. If he is
> written in Common Lisp, then I suppose he's on-topic here.
You can ascertain that by sending a chick or fem bot to my quarters. In one
way or another, they'll be pleased to tell you that i'm a Man.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: ········@visi.com (David Thornley)
> Newsgroups: comp.lang.lisp
> Date: Wed, 21 Feb 2001 21:00:51 GMT
> Subject: Re: Perl becoming Lispier
········@visi.com (David Thornley) writes:
> Xah Lee is either a very strange human or a very impressive computer
> program, and I've never been able to figure out which. If he is
> written in Common Lisp, then I suppose he's on-topic here.
Why does it have to be one or the other?
> Perhaps Xah Lee is an articulate rogue delighting in brooding upon
> sensible nonsense.
I admire your courage to disrobe a king, but pity you can't see my giant
dick big enough to muffle a million driveling mouths: I'm an articulate
being benign in broaching insensible sense.
have you seen the difference yet?
Even poetry have meanings. Larry Wall's stuff, has none. Sweet nonsense to
trap stupid coders. Sweet sweet nonsense. Sweet sweet sweet nonsense to trap
stupid stupid coders. Stuupid stuuupid coders. Stupider and stupideer.
Xah
···@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
> From: Joe Marshall <···@content-integrity.com>
> Organization: Nuthinbutnews.com
> Newsgroups: comp.lang.lisp
> Date: 21 Feb 2001 10:16:16 -0500
> Subject: Re: Perl becoming Lispier
>
Xah Lee <···@xahlee.org> writes:
> I admire your courage to disrobe a king,
Thank you.
> but pity you can't see my giant dick big enough to muffle a million
> driveling mouths...
I'll pass on that.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----