I'm always interested in how people "came to something." In this case
it's Lisp. How about relaying how you "came to Lisp?"
For me it was in an academic setting. Last semester in college I took
an AI class. It was one of those 400 level "broad introduction" type
of classes. While the Prof. read from the book (for the most part)
during class she would assign problems every two weeks covering some
aspect of AI. These problems would typically be based on search trees
and developing heuristics to trim the tree down to an acceptable
level.
It was more fun than anything else.
As with all classes (at least that's what it seemed like to me) we had
a final independent project. About 1/2 way through the semester we
had to fill out of "project request" which basically asked for a
"class" of project. I scribled "game" and handed it back. All was
well.
Like most things in school I pushed it off until the last minute. The
class met three times a week. On one Wednesday the first student got
in front of the class to give their presentation.
"Holy crap!", I thought. I hadn't even started mine yet! I found my
number in the rotation and I had to give my presentation on Monday. I
left the class a bit shaken that day. Friday rolled around and two
more students gave their presentation.
I went home after that class and started thinking about a game. I
ended up choosing to implement a game of Broadsides by Milton Bradly
(summary: Move sailing ships on a board, sink opposing ships, person
with last ship is winner).
So, at about 2 PM, I downloaded a copy of XLisp 2.0 from an FTP site
and started working.
The version of XLisp that I downloaded didn't support graphics of any
sort (I was doing this during the Windows 3.1 days) so I started
searching for the sourcecode, found it, examined it, and started
hacking additions to XLisp to support VGA grahpics and the mouse (it
turned out to be about 300-400 lines of C to add all the things I
wanted). By 3AM I had my version of XLisp working like a peach and I
crawled into bed.
The next morning (around 9 AM) I started working on the project
proper. It was rough the 1st few hours as I meandered around xlisp
for a bit. False starts, fidgets, etc. But by around 3 PM it all
started to gell. It was my "ah ha" experience.
From 3 PM till about 1 AM it turned from programming to "expressing
ideas." It went from pure act of coding to an act of "describing the
situation" to the interpreter.
By Sunday morning I had the game playing itself. It was quite
disturbing to me to see the program play semi-intelligently against
itself. I watched it over and over again (for about an hour) but
playing games -- game would end and a new one would start.
I could of stopped here -- it was a game, it played itself according
to the rules of the original game but I proceeded to add code to allow
a human player to play as well. This took about two hours to
implement fully.
The AI aspects of the game weren't on the high-order of quality:
hacked minimax routine (four ply at first but trimmed to 2 so you
didn't have to sit for 20 minutes between moves. 2 ply was almost
instantaneous), move generation, book moves (to start the game),
choosing a "bad move" occasionally in the hopes of luring the human
player into a better situation, etc.
The computer captain could be tuned by assigning values to three
weight variables at the head of the program. You could tell the
computer captain to really push it on the map (causing damage is the
most important thing) or to be cautious (avoiding damage is most
important). You typically ended up with a computer player who threw
caution to the wind or ran from fights. Twiddling with the weight
variables could even land you in the middle of this realm (the
computer captian would cause damage if possible but avoid 1:1
exchanges if possible).
By sunday night I had the game done. It was around 2000 lines of Lisp
code, another 300-400 lines of C, and a 5 page paper which described
the algorithms I used.
I gave my presentation Monday morning and, honest to god, mouths hit
the floor. I had a few fellow students actually get mad at me. My
ego was pretty inflated at the time. I think the prof still uses the
game as an example here and there. I got a 97% on it -- she took
points off for a spelling error in one of the comments. :)
I still have the final paper at home someplace.
Anyway, that was my first *real* exposure to Lisp programming. A
panic ridden hectic weekend -- looking back on it it was great.
And to be honest it's all been downhill since. But in a good way. ;)
Damond
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
>
I was once looking around at some misc stuff (talking about lambda
calculus, along with some other math related stuff), then they gave a few
examples that were in scheme... little reaction (as then I had thought is
was just a mathematical representation language...).
later while looking at info I noticed a description of rep, so I decided to
look at it. what I saw was interesting.
over time (along with comments from some people) I learned more about it...
it seemed more interesting the more I saw of it. got better tools, and
learned the difference between cl and scheme.
as of yet I am still more on the scheme side of things than the cl side of
things though.
all this has been over the past few months.
all the while I have been focusing attention on other projects (currently
on my os). current objectives are to figure how to unify my os project and
my fiddling with scheme... I figure cl might be a little harder to
implement, but I am not sure...
I have at current read r5rs, but not yet the ansi spec. I have implemented
a basic scheme->assembler compiler as well, which I am using as the basis
for compilation related fiddling...
sometimes I wonder if I should come up with names for my projects, but for
now there is no need.
how about I use my initials: bgb os, bgb scheme->assembler compiler, ...
From: Christopher C. Stacy
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <uit77jnaf.fsf@theworld.com>
I started programming three decades ago, self-taught as a child.
I learned FORTRAN, BASIC, and survey/dabbled in COBOL, PL/I,
assemblers, and a few others. Then after a couple of years I
discovered and thought that was the greatest thing. My first
exposure to LISP was late in high school on the MIT systems
(via the ARPANET), and LISP quickly replaced APL as the language
of choice. In the meantime, of course, I've learned lots of
other languages, most recently including JAVA a few of years ago.
LISP remains "the best" (for most purposes) in my book.
·······@syncreticsoft.com (Damond Walker) writes:
> How about relaying how you "came to Lisp?"
I "came to lisp" because it was the operating system of the machine I
used for Prolog programming!
(as part of my masters thesis, I was developing a question-answering
in Prolog, and the (cool!) tool I used for that was Xerox Quintus
Prolog, which ran on Xerox Lisp Machines...)
--
(espen)
My first exposure to Lisp was in a programming languages course circa 1974
(using Siklosky's "Let's Talk Lisp"). I was baffled by it and intrigued
that I'd encountered a language that I couldn't master.
Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold of
the first anniversary issue of Byte magazine), with 2K of static RAM and 10K
of dynamic (yes, 12K, as in "kilo" bytes total RAM) and ported various Tiny
Basics to it. Probably in Dr. Dobb's, I found out about Fritz van der
Wateren's Lisp for the 6800, purchased a copy (it came printed in a booklet
with commented 6800 assembler code) and sight-read it into the Z80 (the 6800
version was 4K in size, the Z80 transliteration was 5K).
Once running well (the final GC glitch (a sight-reading typo) was found
about 6 months later :-), I wrote a simple editor and debugger in lisp and
sent an article in to DDJ ('78, '79?). I had mono at the time, so I dropped
out of school for a term and had lots of spare time to kill. The article
was printed on an IBM Selectric typewriter with 11 solenoids, which I'd
salvaged from a Wang word processor.
I typed in the Lisp compiler from John R. Allen's "Anatomy of Lisp" (lots of
typos in the edition of the book I had) and got it running, emitting Z80
binary. I had enough of the 12K[*] left over to hold the source code for an
"iota" function (see APL), to compile it and run it.
pt
[*] My recollection is a bit hazy. At some point, I coaxed the dynamic RAM
up to 23K [sic - I was using bargain bin TMS 22-pin dynamic RAM chips for
which I had incomplete specs; it turned out that my cpu timing was marginal
for the RAM, but would work if I added entropy to the wire wrapping job]. I
might have built the Lisp compiler only after I had doubled the memory :-).
On Mon, 08 Apr 2002 18:30:19 GMT, "Paul Tarvydas" <········@attcanada.ca>
wrote:
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold of
> the first anniversary issue of Byte magazine), with 2K of static RAM and 10K
> of dynamic (yes, 12K, as in "kilo" bytes total RAM) and ported various Tiny
> Basics to it. Probably in Dr. Dobb's, I found out about Fritz van der
> Wateren's Lisp for the 6800, purchased a copy (it came printed in a booklet
> with commented 6800 assembler code) and sight-read it into the Z80 (the 6800
> version was 4K in size, the Z80 transliteration was 5K).
>
> Once running well (the final GC glitch (a sight-reading typo) was found
> about 6 months later :-), I wrote a simple editor and debugger in lisp and
> sent an article in to DDJ ('78, '79?). I had mono at the time, so I dropped
This is probably one of the smallest Lisp Machines ever built :)
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
[http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/]
"Paul Tarvydas" <········@attcanada.ca> wrote
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold
of
> the first anniversary issue of Byte magazine), with 2K of static RAM and
10K
> of dynamic (yes, 12K, as in "kilo" bytes total RAM) ...
It' funny, I also wire-wrapped a Z80 board with a 2K static RAM. No DRAM but
a 2K EPROM, a PIO and an extension connector for an 8+4bit A/D and a
photodiode amplifier for astronomy uses. (A 1024 point FFT took 20 minutes
vs 600 ns in an FPGA!)
Now I write in VHDL and use a $40K PCB CAD software instead of wrapping ;-)
No Lisp on this one though. Just a forth compiler I wrote.
My first Lisp was Le-Lisp on a TRS80 model I (16K RAM that I extended to 48K
by soldering DRAM chips over the existing ones except for the chip selects
which got decoded by some TTL chips)
Le-Lisp was my first high level language after hexadecimal, Z80 assembly,
forth and the TRS 80 basic.
You can imagine the cultural shock! I was really impressed. A few years
later, I used Lisp on a TI Explorer while in my engineering school (Sup�lec
France) and in the universities (Paris and Montreal). Today, I use Common
Lisp for all my software, mostly industrial stuff and web applications,
using C only for low level stuff like device drivers and VHDL for the
hardware.
Marc
"Marc Battyani" <·············@fractalconcept.com> wrote
>
> "Paul Tarvydas" <········@attcanada.ca> wrote
>
>> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold
of
>> the first anniversary issue of Byte magazine), with 2K of static RAM and
10K
>> of dynamic (yes, 12K, as in "kilo" bytes total RAM) ...
>
> It' funny, I also wire-wrapped a Z80 board with a 2K static RAM. No DRAM
but
> a 2K EPROM, a PIO and an extension connector for an 8+4bit A/D and a
> photodiode amplifier for astronomy uses. (A 1024 point FFT took 20 minutes
> vs 600 ns in an FPGA!)
BTW I found it in the lab. For those interested in microcomputers archeology
here are 2 pictures of it:
The components side:
http://www.fractalconcept.com/Z80-front.jpg
The wire-wrap side:
http://www.fractalconcept.com/Z80-back.jpg
The funny thing is that the current Intel architecture is still almost the
same ;-)
Marc
> Now I write in VHDL and use a $40K PCB CAD software instead of wrapping
;-)
>
> No Lisp on this one though. Just a forth compiler I wrote.
>
> My first Lisp was Le-Lisp on a TRS80 model I (16K RAM that I extended to
48K
> by soldering DRAM chips over the existing ones except for the chip selects
> which got decoded by some TTL chips)
>
> Le-Lisp was my first high level language after hexadecimal, Z80 assembly,
> forth and the TRS 80 basic.
> You can imagine the cultural shock! I was really impressed. A few years
> later, I used Lisp on a TI Explorer while in my engineering school
(Sup�lec
> France) and in the universities (Paris and Montreal). Today, I use Common
> Lisp for all my software, mostly industrial stuff and web applications,
> using C only for low level stuff like device drivers and VHDL for the
> hardware.
>
> Marc
"Marc Battyani" <·············@fractalconcept.com> writes:
[...]
> BTW I found it in the lab. For those interested in microcomputers archeology
> here are 2 pictures of it:
> The components side:
> http://www.fractalconcept.com/Z80-front.jpg
>
> The wire-wrap side:
> http://www.fractalconcept.com/Z80-back.jpg
>
> The funny thing is that the current Intel architecture is still almost the
> same ;-)
Look at an seventy years old car and then at a new. I think you get
the point. :)
Regards,
Julian
--
Meine Hompage: http://julian.re6.de
Ich suche eine PCMCIA v1.x type I/II/III Netzwerkkarte.
Ich biete als Tauschobjekt eine v2 100MBit Karte in OVP.
From: Nels Tomlinson
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <3CB67181.2020306@gci.net>
That's interesting. I just got a Tandy 102. I really wanted one of
these back when they were new, or one of the little Epson notebooks that
competed with them, but they were WAY to high-priced for me back then.
Yesterday, I got the Tandy for $5.
I'm comtemplating kludging together a little lisp to fit in it. It has
about 24k RAM and an 8085. I've gone looking for info on implementing
lisp, and haven't found a lot so far. If you have any of your old
stuff, such as z80 code or a version of that old DDJ article, I'd admire
to see it.
Just to keep this on topic, I think that my first introduction to lisp
was when I tried to use an old symbolic math program called mumath,
which was written in a lisp (can't remember which, or what happened to
mumath). In order to adjust mumath's parameters, one had to set various
variables. I found it painful to deal with those parentheses in edit on
a pc. Eventually I found a shareware (or public domain?) lisp in a
download directory on the University of Alaska's Honeywell mainframe,
and started playing with that, using Wordstar for an editor. I wrote
some little programs, but I stuck to Fortran for serious work. I was
doing everything on University pc's (Fujitsu and IBM), since they were
reluctant to give undergrads an account on the engineering Vax, and
Honeywell's Fortran IV was painfully buggy.
I got interested in lisp again a couple years ago when I got started
playing with Maxima, which is another symbolic math program written in
lisp. This time, I'm taking it a little more seriously, and want to
learn to use it effectively. Maybe one of these days I'll get there.
Paul Tarvydas wrote:
> My first exposure to Lisp was in a programming languages course circa 1974
> (using Siklosky's "Let's Talk Lisp"). I was baffled by it and intrigued
> that I'd encountered a language that I couldn't master.
>
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold of
> the first anniversary issue of Byte magazine), with 2K of static RAM and 10K
> of dynamic (yes, 12K, as in "kilo" bytes total RAM) and ported various Tiny
> Basics to it. Probably in Dr. Dobb's, I found out about Fritz van der
> Wateren's Lisp for the 6800, purchased a copy (it came printed in a booklet
> with commented 6800 assembler code) and sight-read it into the Z80 (the 6800
> version was 4K in size, the Z80 transliteration was 5K).
>
> Once running well (the final GC glitch (a sight-reading typo) was found
> about 6 months later :-), I wrote a simple editor and debugger in lisp and
> sent an article in to DDJ ('78, '79?). I had mono at the time, so I dropped
> out of school for a term and had lots of spare time to kill. The article
> was printed on an IBM Selectric typewriter with 11 solenoids, which I'd
> salvaged from a Wang word processor.
>
> I typed in the Lisp compiler from John R. Allen's "Anatomy of Lisp" (lots of
> typos in the edition of the book I had) and got it running, emitting Z80
> binary. I had enough of the 12K[*] left over to hold the source code for an
> "iota" function (see APL), to compile it and run it.
>
> pt
>
> [*] My recollection is a bit hazy. At some point, I coaxed the dynamic RAM
> up to 23K [sic - I was using bargain bin TMS 22-pin dynamic RAM chips for
> which I had incomplete specs; it turned out that my cpu timing was marginal
> for the RAM, but would work if I added entropy to the wire wrapping job]. I
> might have built the Lisp compiler only after I had doubled the memory :-).
>
>
"Nels Tomlinson" <·············@gci.net> ha scritto nel messaggio ·····················@gci.net...
> Just to keep this on topic, I think that my first introduction to lisp
> was when I tried to use an old symbolic math program called mumath,
> which was written in a lisp (can't remember which,
Mumath was a language built on top of mulisp, basically it was
mulisp with infix syntax. Mumath was used to implement the
computer algebra system musimp.
> or what happened to mumath).
Musimp has been rewritten in mulisp, and now is called
Derive. It lives as a cheap computer algebra system for
windows and as the engine of some TI calculators.
P.
The first time I used Lisp was in the early 1970s, on
an old IBM 7094. The program was entered with punch cards.
This was Lisp 1.5, IIRC (using McCarthy et al. as the manual).
Paul
In article <····························@posting.google.com>, Damond Walker wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
Pretty uninteresting story... I figured out how to use setq for
configuring Emacs, first; the info pages mentioned something called
``Common Lisp'', but I didn't care what it was, just guessed it
would be something horribly complicated. Then I'd learn more of
Emacs Lisp and began to like it, somehow. At some point, I got
flamed in gnu.emacs.help by a certain E.N., because I made
it quite clear that I thought that everybody who didn't know that
C is the greatest of all languages, must be either a newbie or
a total moron. I was quite impressed, asked him, what /his/
favorite language was, and decided to find out more about it.
I learned a bit of Common Lisp, liked it and started to learn
a whole bunch of other languages, too. After becoming quite
disillusioned about a lot of hype languages, I returned to Common
Lisp and started studying it thoroughly. I am still busy...
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
As with most folks, I first met Lisp in a college-level AI course. Of
course, we didn't move much beyond the standard "write append using only
cons" stage of Lisp development. And, of course, this was done on a CDC
Cyber 175 using (I kid you not) UT Lisp. This odd MACLisp-like
implementation actually had four fields in each cons cell, the car, the
cdr, the cxr, and a six-bit bonus field that I don't remember the name of
(It had to do with the fact that the machine had 18-bit addresses and
60-bit words - Seymour Cray had a wicked sense of humor :-). Although the
language (and recursion) made immediate sense to me, I didn't see the charm
of it.
The next time I met Lisp, it was while working in IC-Design tools. Many of
the early IC design tools used Lisp as their underlying language (mainly
tools from the MIT and CMU) - in fact a friend of mine got a job at Analog
Devices back when they were writing custom CAE tools on Lisp Machines. I
really liked the use of S-exprs as interchange formats and wanted to start
looking at Lisp again - this was during the AI boom and it seemed that
doing IC design tools in Lisp was a great way to do things. Also studying
computer architecture at the time, I noticed the work at MIT on the Scheme
chip (although Scheme is NOT Lisp) and all of that got me looking at Lisp
again.
Being a slow beginner, I took a graduate-level AI course where we used
Franz Lisp and, at that point, officially fell in love with the language.
Never being able to get the companies I worked for to try Lisp on their own
products I got my hands on implementations on a catch-as-catch-can basis -
I got a copy of InterLisp VAX from ISI while I was at Tektronix; while
working for Mentor Graphics I got a copy of Apollo's initial lisp (a
bastardized version of PSL);` got a copy of Lucid when they put themselves
on the Apollo. I also found an old Tektronix 4044 AI workstation (actually
a Smalltalk machine, but it also had a Lisp subsystem built in) that I
learned Flavors on.
When the first trial and free versions of Common Lisp were available for
download, I got them all. CLOS made immediate intuitive sense (and God
knows I didn't miss double dispatch from my Smalltalk days at ParcPlace
Systems :-).
In any case, I've been hacking around with Lisp ever since. I do all of my
own coding in Lisp when I'm not working for my day job. It's a good life.
faa
"Damond Walker" <·······@syncreticsoft.com> wrote in message
·································@posting.google.com...
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
I started programming in 1977, my first year of university. Programming was
hardly the big thing then, video terminals had just been introduced and all
people programming, me in Basic and the older computer science students were
all in one room. Just by talking with other people, being curious in what
they were doing, and showing what I was doing, I had a conversation with
someone who showed me a text book with a Lisp compiler in it. I looked at
the few pages of code and was just baffled. I could barely follow it. My
first experience with Lisp. Anyways, computer science was not my area, I
just did the first introductory course to computing and continiued on. Over
the next few years I would hear mention of it, its connection with AI, its
expressive power. But I found I had no use of programming back then.
I was not until later after working as a programmer, first Cybil (a CDC
version of Pascal), then C, and then C++ that I introduced myself to Lisp.
I joined the ACM and got the magazine that profiled Lisp's uses and
contributions. Since I am always looking for better ways to do things, the
G2 article especially got my interest since I was working on Real-time Data
Acquisition and Control software at the time. I decided to just go ahead
and learn Lisp. I had heard all the jokes about Lisp at the time, but I
really never paid them much attention, Lisp had supporters and was obviously
important in coumputer science, and I was determined to fix my first
illiterate experience with Lisp.
To my surprise Lisp solved many of the programming problems that I had to
deal with everyday. Simple things like built in list manipulation, which I
seemed to be doing over and over again in C. Then I got to like the syntax,
especially with the new indenting styles. The rest is history. I have been
pleased at how well CL has been thought out and honed by actual use. Its
lacks the clutter of many other languages and allows me to get to the
central ideas directly. I think of it a my formal description language,
allowing me to state the problem and the solution all in one language.
Wade
·······@syncreticsoft.com (Damond Walker) writes:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
After I graduated in 1986 I was looking for a job which combined my
interests in AI and Computer Graphics. I spotted an ad in a national
newspaper for a small start-up company looking to recruit Lisp
programmers to develop a CBT authoring system.
I started work as a junior developer three weeks later - I had a quick
look at Cambridge (?) Lisp on the BBC Micro in those intervening weeks
but this didn't prepare me for my first day when I was shown my desk
on which sat the monitor for my Symbolics 3610 and its accompanying
manuals.
I've been lucky enough to stay with Lisp at other companies since that
time.
Mark
I had been programming for years, and had glanced at Lisp a number of times,
but it always just looked like a lot of parenthesis and I had been told that
it was just for AI. So I never gave it much thought.
However, over the years, I developed a VERY big list of things I wanted from
a programming language. I was entertaining the idea/fantasy that I would
someday make such a language, or perhaps a tool that would overlay the
aspects I wanted on top of C. Dynamic code generation was near the top of
the list, morphing classes, seamless interchangeable data types (vector,
tree, set, etc.). And so on.
Ironically, several years ago I developed a high speed graphic application
that used self modifying code to pre-calculate the ideal inner loop and then
build and run that loop. And, some of the sources that helped guide me were
different newsgroup postings, etc. from John Foderaro. I had no idea he
worked with Lisp, I just thought he was some self modifying code guru.
Anyway, last year I saw an article reference on Slashdot. Paul Grahams
"Beating the Averages". http://www.paulgraham.com/avg.html The article
resonated with me, since our company has only two programmers. Plus his
description of Lisp was fascinating. I followed much of it, but couldn't
figure out what he meant by "lexical closures".
So I bought Paul Graham's "ANSI Common Lisp" book, and was amazed. Almost
every item on my fantasy list for a programming language was in Lisp. So
now I'm in love with the language. I've written little things, and am
working on a side project. I've gotten a bunch more books. And, of course,
I read this newsgroup. It is my professional dream that one day I'll
develop and market a product written in Lisp. But to-day I return to C
(sigh).....
Chris Perkins
http://www.medialab.com
lisp has many of the good features I wanted, but a few ones have yet to be
seen (though if I wanted I could offer them as extensions in my system...).
>
> So I bought Paul Graham's "ANSI Common Lisp" book, and was amazed. Almost
> every item on my fantasy list for a programming language was in Lisp. So
> now I'm in love with the language. I've written little things, and am
> working on a side project. I've gotten a bunch more books. And, of
> course,
> I read this newsgroup. It is my professional dream that one day I'll
> develop and market a product written in Lisp. But to-day I return to C
> (sigh).....
>
c is one of those inescapable ones, mostly as some things needed to be done
in my type of projects aren't really as possible in lisp.
I am using for my lisp (actually scheme, but close enough) code my own
compiler which luckily I can customize for some of the lowlevel stuff in an
os (ie: assembly code). most of my os is still in c, but there are a few
scheme fragments around. my plan (beyond improving the compiler) is to make
it capable of outputing code for itself, to run in the kernel (and thus, I
will have a self modifying kernel...).
unlike other os projects I seem to have forgon most of the more "basic" os
issues, ie: I don't have processes...
currently some lisp issues have not been resolved either (my mm is wasteful
with consing, and in my compiler I lack a good idea on how to handle tail
calls).
for all that want a cl os, I don't feel up to writting cl on my own, and
scheme seems close enough.
(maybe though I should work more on my stuff than usenet postings
though...).
On Fri, 5 Apr 2002 16:54:53 -0500, cr88192 <·······@hotmail.com> wrote:
> lisp has many of the good features I wanted, but a few ones have yet to be
> seen (though if I wanted I could offer them as extensions in my system...).
Which features are you missing?
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
[http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/]
>
>> lisp has many of the good features I wanted, but a few ones have yet to
>> be seen (though if I wanted I could offer them as extensions in my
>> system...).
>
> Which features are you missing?
>
well, a system by which access to code/data could be restricted by
giving/taking tags, and by which a predicate could be specified to
allow/deny access based on those tags.
I know there were others, I just can't think of them now...
(can't really write, am in a bad mood, just now after 3 hours am I stable
enough to try to write...). what exists of my life is comming apart, ever
had the experience where you hate yourself because of how you feel, you
can't leave because of it, and staying isn't really possible because of the
pain involved. part wishes they would just leave so that the pain would
stop, but at the same time you don't want them to leave because of the loss.
even when I try to be all that was wanted of me that is still not good
enough, and now I feel more like a target; I wonder if there is anything I
can do to fix things, but I don't know (she is doing all that she complains
of in others...). I feel that things are breaking down, that this is near
the end (where part of me actually hopes for that...).
maybe everything will be better later, I am probably just misinterpreting
things.
sorry about being off topic, just there is no one really to tell.
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
cr88192 <·······@hotmail.com> writes:
> well, a system by which access to code/data could be restricted by
> giving/taking tags, and by which a predicate could be specified to
> allow/deny access based on those tags.
If you restrict the code to not being able to create pointers from
integer values, then you'll be fine with simply passing references
where you want them to be passed. If you want to have multiple "views"
of a single object, I don't think you can in Lisp. You'll just have to
create wrapper objects and have the references in them change based on
the changing access permissions you'd like to give.
> [...]
> sorry about being off topic, just there is no one really to tell.
An unfortunate situation, but I guess you can't change others unless
they are willing. I hope things get better soon.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Rahul Jain wrote:
> cr88192 <·······@hotmail.com> writes:
>
>> well, a system by which access to code/data could be restricted by
>> giving/taking tags, and by which a predicate could be specified to
>> allow/deny access based on those tags.
>
> If you restrict the code to not being able to create pointers from
> integer values, then you'll be fine with simply passing references
> where you want them to be passed. If you want to have multiple "views"
> of a single object, I don't think you can in Lisp. You'll just have to
> create wrapper objects and have the references in them change based on
> the changing access permissions you'd like to give.
>
not quite, it is not so easy to describe though.
consider:
(allow (defun foo (x) (* x x)) (and (has :system) (not (has :script)))
and elsewhere:
(progn ;can access foo
(apply :script
(foo 5))) ;error, as here foo is inaccessible here
ok, these semantics will need some work, but I hope this portrays my idea...
>> [...]
>> sorry about being off topic, just there is no one really to tell.
>
> An unfortunate situation, but I guess you can't change others unless
> they are willing. I hope things get better soon.
>
we have been together for nearly 2 years now...
about 1 year ago there was an agrument, then things were better for a few
months. that soon wore off, but things were not too bad. more recently
there have been more problems, then she was nice (for one day, probably
relating to me talking about leaving before that), and since she has been
quite a bit worse (about a month now)...
when I complain to her about it she says there is no problem. I have wanted
to leave but she has not wanted me to leave (for some reason I can't quite
figure out, if she cared about me she would probably treat me better).
anymore I am running out of options (not like I want to anyways).
I hope I am not too harsh on her.
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
cr88192 <·······@hotmail.com> writes:
> not quite, it is not so easy to describe though.
> consider:
> (allow (defun foo (x) (* x x)) (and (has :system) (not (has :script)))
>
> and elsewhere:
> (progn ;can access foo
> (apply :script
> (foo 5))) ;error, as here foo is inaccessible here
>
> ok, these semantics will need some work, but I hope this portrays my idea...
Heh, you hit on the second part of the system, controlling access to
global information. Global variables and functions can be protected by
preventing access to the symbols that name them. I'm actually
developing something to do this for DefDoc (as though I'll ever
actually do it :P) which involves both a customized reader and a
package that wraps all of the CL package in security-checking code.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
>
>>> [...]
>>> sorry about being off topic, just there is no one really to tell.
>>
>> An unfortunate situation, but I guess you can't change others unless
>> they are willing. I hope things get better soon.
>>
> we have been together for nearly 2 years now...
> about 1 year ago there was an agrument, then things were better for a few
> months. that soon wore off, but things were not too bad. more recently
> there have been more problems, then she was nice (for one day, probably
> relating to me talking about leaving before that), and since she has been
> quite a bit worse (about a month now)...
> when I complain to her about it she says there is no problem. I have
> wanted to leave but she has not wanted me to leave (for some reason I
> can't quite figure out, if she cared about me she would probably treat me
> better). anymore I am running out of options (not like I want to anyways).
> I hope I am not too harsh on her.
>
sorry to everyone, I portrayed her badly...
I talked to her earlier and things were a bit misinterpreted.
this is just an example of how my screwed up emotional state puts blame on
people...
I should have better self control, and I should not feel bad about things
that are not wrong. I am just a crappy person that treats everyone around
me badly.
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
I was debating whether or not to respond to this off topic post, and then
saw your self-response. As penance for my off-topicness, I might point
out that the newsgroup 'alt.love' is the more appropriate venue for such
matters.
In article <··············@corp.supernews.com>,
cr88192 <·······@hotmail.com> wrote:
>
>sorry to everyone, I portrayed her badly...
>I talked to her earlier and things were a bit misinterpreted.
>this is just an example of how my screwed up emotional state puts blame on
>people...
>I should have better self control, and I should not feel bad about things
>that are not wrong. I am just a crappy person that treats everyone around
>me badly.
You really need to stop convincing yourself that you are somehow a crappy
person and the way you feel is somehow incorrect. In a very real sense,
your relationship with your SO (g/f, wife, fiancee, etc.) is what you make
of it. Part of the reason communication is so important is that your
partner is very likely not to know what you think is obvious from your
point of view. As a result, it is important to stand up and advocate your
point of view. If all you do is justify the way she treats you, think
it's shitty, and that all you have to do is persevere, then you'll get
treated according to those expectations you set. Worse, it doesn't do
you or her any favors to have that kind of ill will build up.
Of course, the risk of all this is that if you're both honest with what
you want, the relationship will fall apart because you can't meet each
other's expectations. If that's the case, than it _should_ fall apart
and you both _should_ move on to a relationship that can meet your
expectations. That risk can pretty easily paralyze people into inaction
and coping, rather than action and solcing. You shouldn't need to put up
with that kind of relationship. After all, you're smart enough to want to
know more about Lisp. :-)
In a way, it's like debugging in general. There's the easy patch fix that
makes the problem look gone. Then there's the hard, difficult fix that
actually fixes the underlying issues. If there's any area of life in
which it's worth the effort to make the real fix, this is it.
-Mike
--
http://www.mschaef.com
well, I appologize to everyone for my general off topicness.
> I was debating whether or not to respond to this off topic post, and then
> saw your self-response. As penance for my off-topicness, I might point
> out that the newsgroup 'alt.love' is the more appropriate venue for such
> matters.
>
I will check it out, searching for "appropriate" places to discuss
emotional issues is an interesting idea...
>>
>>sorry to everyone, I portrayed her badly...
>>I talked to her earlier and things were a bit misinterpreted.
>>this is just an example of how my screwed up emotional state puts blame on
>>people...
>>I should have better self control, and I should not feel bad about things
>>that are not wrong. I am just a crappy person that treats everyone around
>>me badly.
>
> You really need to stop convincing yourself that you are somehow a crappy
> person and the way you feel is somehow incorrect. In a very real sense,
> your relationship with your SO (g/f, wife, fiancee, etc.) is what you make
> of it. Part of the reason communication is so important is that your
> partner is very likely not to know what you think is obvious from your
> point of view. As a result, it is important to stand up and advocate your
> point of view. If all you do is justify the way she treats you, think
> it's shitty, and that all you have to do is persevere, then you'll get
> treated according to those expectations you set. Worse, it doesn't do
> you or her any favors to have that kind of ill will build up.
>
communication is difficult sometimes.
she is my girlfriend...
> Of course, the risk of all this is that if you're both honest with what
> you want, the relationship will fall apart because you can't meet each
> other's expectations. If that's the case, than it _should_ fall apart
> and you both _should_ move on to a relationship that can meet your
> expectations. That risk can pretty easily paralyze people into inaction
> and coping, rather than action and solcing. You shouldn't need to put up
> with that kind of relationship. After all, you're smart enough to want to
> know more about Lisp. :-)
>
I don't really know what she wants, she has never said.
part of what I want I am not sure even really exists for me.
computers and math seem to be the only things in life which really seem
consistent to me.
> In a way, it's like debugging in general. There's the easy patch fix that
> makes the problem look gone. Then there's the hard, difficult fix that
> actually fixes the underlying issues. If there's any area of life in
> which it's worth the effort to make the real fix, this is it.
>
for me the problems and their existance is unclear. the problem is that my
reality changes based on when I am asked. there happines, sadness, and
fear; all are very distinct "realities". at some times I bounce between
them in a rather erratic manner.
I should have the self control to be consistent in this respect, but I do
not. those posts were made somewhere around "sadness".
really in life it is very difficult to be productive or carry on a social
life. it is not easy to describe how it is effected.
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
In article <··············@corp.supernews.com>,
cr88192 <·······@hotmail.com> wrote:
>well, I appologize to everyone for my general off topicness.
>>
>I will check it out, searching for "appropriate" places to discuss
>emotional issues is an interesting idea...
There are all sorts of groups for relationship/emotional issues, mainly in
the alt.* and soc.* hierarchies. Also, various webforums too.
>I should have the self control to be consistent in this respect, but I do
>not.
Don't beat yourself up too badly.
-Mike
--
http://www.mschaef.com
Hi.
"cr88192" <·······@hotmail.com> skrev i en meddelelse
···················@corp.supernews.com...
> computers and math seem to be the only things in life which really seem
> consistent to me.
Please do a search on Aspergers Syndrome, ------ depressions are a major part
of Aspergers, and a lot of people who think as you express, can have trouble
that can be cured with different medication as if it's just a standard
depression. You se ,medical experts in the field acturly say "computers was
inventet by Aspergers for Aspergers", and treadment of depressions are
different, while depressions for people with "Aspie charecter" ,are caused
different than "standard" depressions.
Do you take things very literally and have "special interest" ,trouble in social
relasions and have a weak self feeling ; do a search about Aspergers Syndrome.
P.C.
Have a nice day.
In article <··············@corp.supernews.com>, cr88192 wrote:
> (can't really write, am in a bad mood, just now after 3 hours am I stable
> enough to try to write...). what exists of my life is comming apart, ever
> had the experience where you hate yourself because of how you feel, you
...
Reading this and the couple other posts of yours in this thread seriously
sounds like you are having trouble with depression. Whether major/clinical
depression or "just" passing depression from problems, it can tear you up
and should NOT be taken lightly. Look for more information, and seek help.
Really.
> sorry about being off topic, just there is no one really to tell.
Alt.support.depression tends to be a pretty good place for that. Try it.
--
Robert Braddock
>
> Reading this and the couple other posts of yours in this thread seriously
> sounds like you are having trouble with depression. Whether major/clinical
> depression or "just" passing depression from problems, it can tear you up
> and should NOT be taken lightly. Look for more information, and seek help.
> Really.
>
>> sorry about being off topic, just there is no one really to tell.
>
I am fine now, I am just like that sometimes. I try not to let it effect
things too much.
as far as I know I have allways been like this, and really what does it
matter to anyone besides me?... I have been fine recently.
sometimes (like then) I just go off about something and end up making a
fool of myself. as long as I don't talk about something non-technical then
nobody seems to notice...
sometimes I wonder if my girlfriend has ever noticed, or if she has a
problem with it. I try what I can to avoid screwing things up.
for all I know it doesn't really exist as I have often thought I have had
things that I didn't, and I can't seem to identify the variation.
I can force myself to look cheery when dealing with people anyways, and
most of the time that works well enough.
I don't mean to discredit you in any way...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
[off topic]
> I am fine now, I am just like that sometimes. I try not to let it effect
> things too much.
> as far as I know I have allways been like this, and really what does it
> matter to anyone besides me?... I have been fine recently.
Not that I'm pushing you here, but this is a dead on classic thinking
pattern. You must at least wuestion it, and keep in mind that you _may_ not
be able to trust your self-worth instincts.
> for all I know it doesn't really exist as I have often thought I have had
> things that I didn't, and I can't seem to identify the variation.
Well, then you should feel reassured, because here, you aren't the one
saying you might "have something" ;) Really though, if you have some friends
who are personally close, you would probably be best advised to overtly
discuss this with them a little bit and ask them to maybe spend a little
time looking for relevant information. (I say this because on the one hand,
there is a lot of misinformation out there about these things and you can't
just go to a doctor and assume s/he's remotely competant, and because
depression is more common than people tend to think: a good fraction of
people have or do deal with it in their or someone close's lives.)
> I can force myself to look cheery when dealing with people anyways, and
> most of the time that works well enough.
If you have to do this with any frequency, and it isn't based on the people
specifically, that's a very bad warning. Think about it this way: "putting
on a happy face" is _pretending_ to be happy. What that does is (a) insures
that you don't get actually happy during that time, and (b) helps you
mentally distance your "self" from the idea/feeling of being happy, and (c)
sets you up for an eventual crash where you realize that the "happy you" is
not the "real you" and that you haven't spent enough time with the "real
you" to know what it is, _and_ as if that wasn't enough, (d) prevents others
from knowing about any problems or being prepared for such a crash, leaving
even those who would help confused and unable to react.
> I don't mean to discredit you in any way...
No worries. I'm not making a professional diagnosis--just saying, "These are
solid signs for something that people don't tend to catch even when it's
beating them on the head."
(Oh, and the fact that you might even feel that your counterstatement might
be taken by me as something akin to discrediting points to an overly
effective sense of guilt, which -- while it would be really nice if more
people exhibited it -- is a key factor in depression (it's part of how
depression puts your mind against itself).)
Regards,
Robert Braddock
I can not readily reply by email here...
>
>> I am fine now, I am just like that sometimes. I try not to let it effect
>> things too much.
>> as far as I know I have allways been like this, and really what does it
>> matter to anyone besides me?... I have been fine recently.
>
> Not that I'm pushing you here, but this is a dead on classic thinking
> pattern. You must at least wuestion it, and keep in mind that you _may_
> not be able to trust your self-worth instincts.
>
otherwise I would probably end up over promoting myself or something, or
make myself look like I have too much ego...
>> for all I know it doesn't really exist as I have often thought I have had
>> things that I didn't, and I can't seem to identify the variation.
>
> Well, then you should feel reassured, because here, you aren't the one
> saying you might "have something" ;) Really though, if you have some
> friends who are personally close, you would probably be best advised to
> overtly discuss this with them a little bit and ask them to maybe spend a
> little time looking for relevant information. (I say this because on the
> one hand, there is a lot of misinformation out there about these things
> and you can't just go to a doctor and assume s/he's remotely competant,
> and because depression is more common than people tend to think: a good
> fraction of people have or do deal with it in their or someone close's
> lives.)
>
I don't really have friends, I can't really seem to get along with
people... yet I can't really get away from people either, I am stuck with
people whom I can't really associate.
if I could control myself better and maybe prevent myself from acting like
a spaz then maybe things would be better.
all there is is my girlfriend, and I try to keep myself together for her...
psychologists say I have autism... or at least they did one time I went to
one (3rd grade I think). I don't know if this is anyhow realavent, maybe it
is that.
>> I can force myself to look cheery when dealing with people anyways, and
>> most of the time that works well enough.
>
> If you have to do this with any frequency, and it isn't based on the
> people specifically, that's a very bad warning. Think about it this way:
> "putting on a happy face" is _pretending_ to be happy. What that does is
> (a) insures that you don't get actually happy during that time, and (b)
> helps you mentally distance your "self" from the idea/feeling of being
> happy, and (c) sets you up for an eventual crash where you realize that
> the "happy you" is not the "real you" and that you haven't spent enough
> time with the "real you" to know what it is, _and_ as if that wasn't
> enough, (d) prevents others from knowing about any problems or being
> prepared for such a crash, leaving even those who would help confused and
> unable to react.
>
not like I can really do much else. I could only really stop if I was alone
altogether.
I continue on, trying to keep myself going as best I can, trying to avoid
flaking out, trying to avoid "destructive" thoughts.
I can't really seem to keep up, I do bad in school, and it is my own
actions that are making me do bad, yet I fail to do better.
>> I don't mean to discredit you in any way...
>
> No worries. I'm not making a professional diagnosis--just saying, "These
> are solid signs for something that people don't tend to catch even when
> it's beating them on the head."
>
either way it doesn't really effect much.
I don't know of a fix, I can't seem to really control it.
> (Oh, and the fact that you might even feel that your counterstatement
> might
> be taken by me as something akin to discrediting points to an overly
> effective sense of guilt, which -- while it would be really nice if more
> people exhibited it -- is a key factor in depression (it's part of how
> depression puts your mind against itself).)
>
?...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
>> pattern. You must at least question it, and keep in mind that you _may_
>> not be able to trust your self-worth instincts.
> otherwise I would probably end up over promoting myself or something, or
> make myself look like I have too much ego...
See what you said there? You're trusting you're self worth instincts, which
_should_ make you have too much ego. What if those instincts are just
broken--what if they don't work like experience has taught you? What if the
reservations you have about making your self too important are an insidious
trick by your mind working against itself? Do you really think that you,
with obvious strong reservations about over promoting yourself, _could_ be
in any _actual_ danger of displaying too much ego, compared to others?
> I don't really have friends, I can't really seem to get along with
> people... yet I can't really get away from people either, I am stuck with
> people whom I can't really associate.
Eeek. Don't be alone--find a support group or something. Especially if you
might have something like autism, that people will readily take seriously.
Really. No, REALLY.
> if I could control myself better and maybe prevent myself from acting like
> a spaz then maybe things would be better.
...And if I had wings I could flap them to blow the papers off my desk. If
you weren't built that way, you weren't built that way. Don't feel like it's
your fault you're made the way you are. That's like blaming someone for
being tall. Yes, of course you should try to keep yourself in control, but
that does _not_ mean your efforts should be judged by the standards for
people who aren't made like you.
> psychologists say I have autism... or at least they did one time I went to
> one (3rd grade I think). I don't know if this is anyhow realavent, maybe it
Yeah, it's pretty relevant, I'd think. I don't know anything about autism
though, just about depression. Still, concerns about depression apply.
>>> I can force myself to look cheery when dealing with people anyways, and
>>> most of the time that works well enough.
[...snipping some stuff I said in between...]
> not like I can really do much else. I could only really stop if I was alone
> altogether.
It isn't quite so simple though. Armed with knowledge that you need to avoid
doing the happy face thing, you can take some steps to avoid situations that
will make you more susceptible to the slow damage the happy-face is so prone
to cause. Also, you can make a specialized effort to educate at least some
of the people you associate with. Tell them that the happy face is a
significant burden, and they can't expect it all the time. Even just
understanding what I said about it already is a significant step above being
an unsuspecting tool of the depressive influence.
> I can't really seem to keep up, I do bad in school, and it is my own
> actions that are making me do bad, yet I fail to do better.
How familiar this sounds to me! Do you also feel like you aren't really
doing even the things that you genuinely want to do? If so, then run, don't
walk, and get someone else involves in figuring out what's going on for you.
Support groups are a very good resource if you can find any. No one really
understands depressed people like depressed people.
> either way it doesn't really effect much.
> I don't know of a fix, I can't seem to really control it.
There's not just an "it" here. For example, you're relationship/attitude
with/towards "it" is equally important. Then there's your attitude towards
your attitude towards "it" -- and that's two more things without even
breaking up "it."
Small steps, small progress. Play with giant steps and you'll have to climb
up out of the footprint to even get to where you started.
Hope this helps you some. I think I've said about as much as I can fairly
get away with in a programming group. If you want to continue, I think we
should switch to email. I'm at ······@concordant-thought.com if you can't
get it from the message headers.
--
Robert Braddock
·······@syncreticsoft.com (Damond Walker) writes:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
As an undergrad I had a brief brush with Lisp in a tiny course. It
mostly required me to fiddle around with lists, and, as such the
most remarkable thing about the language was probably the abundance of
parentheses.
Years later, after countless battles with C++ compilers (by this time
having discovered in Python a great tool for developing ideas) I began
thinking that, surely, it must be possible to have a language
implementation which allows you to develop interactively, while
admitting the possibility of compiling the whole lot when you are
finished. Similarly I lamented not being able to have the _option_ of
specifying variable types. While looking forward to the day when
someone somewhere develops such a language, I searched around to see
whether anyone was working on anything like what I had in mind, and
stumbled across Dylan. I didn't really get around to doing anything
with Dylan (and it didn't seem to be thriving), but when I came back
to look at it again, I noticed, to my surprise, that it was derived
from Lisp. This led me to alu.org.
What I found there made my chin drop to the floor.
Actually, around the python community there are vibes to the effect
of `this is better in Lisp' or `we got this from Lisp': I suspect they
encouraged me to have a look at Lisp too.
In a way Lisp has messed up my enjoyment of programming: on the one
hand I get almost no opportunity to use it, play with it, or try to
learn it properly; on the other it has made me hate programming in
anything else.
From: Michael Hudson
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <upu1eb0ft.fsf@python.net>
Jacek Generowicz <················@cern.ch> writes:
> In a way Lisp has messed up my enjoyment of programming: on the one
> hand I get almost no opportunity to use it, play with it, or try to
> learn it properly; on the other it has made me hate programming in
> anything else.
:)
I'm fairly sure that in the introduction to a fairly well known Lisp
book there's a paragraph along the lines of
Be careful about learning Lisp; it may make programming in lesser
languages seem painful.
I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
in there.
Anybody know what I'm talking about?
Cheers,
M.
--
Counting lines is probably a good idea if you want to print it out
and are short on paper, but I fail to see the purpose otherwise.
-- Erik Naggum, comp.lang.lisp
From: Shahen
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <3caf1a85$1@news.eol.ca>
>
> I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
> in there.
>
> Anybody know what I'm talking about?
>
I am new to LISP, but found this in the introduction of Graham's book:
The reward for your efforts will be an equivocal one: you will feel as
suffocated programming in C++ as an experienced C++
programmer would feel programming in BASIC.
Graham, ANSI Common Lisp, p. 2
Michael Hudson <···@python.net> writes:
> I'm fairly sure that in the introduction to a fairly well known Lisp
> book there's a paragraph along the lines of
>
> Be careful about learning Lisp; it may make programming in lesser
> languages seem painful.
>
> I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
> in there.
>
> Anybody know what I'm talking about?
You're talking about Chapter 1 of Paul Graham's "On Lisp":
"[...] the greatest danger of Lisp is that it may spoil you. Once
you've used Lisp for a while, you become so sensitive to the fit
between language and application that you won't be able to go back to
another language without always feeling that it doesn't give you quite
the flexibility you need."
I've found this to be true, but I'm not sure the reasons for this are
technical. I enjoy Python as much as Lisp, and I don't feel frustrated
by a lack of flexibility in Python. But my enjoyment of Lisp is
qualitatively different.
I've never heard anyone mention this topic in relation to programming,
and I've wondered about it for a while. My curiosity has now got the
better of me. So here's a casual question for anyone interested.
On dreams:
Assuming you have programming-related dreams (as I do), did you notice
that your dreaming patterns changed when you started using Lisp? (Or
some other language?)
Between shallow sleep and full waking consciousness, I often grapple
clumsily with programming problems. Most of the thoughts and
situations are ludicrously illogical, which makes them difficult to
describe. Common themes are, for example, tracing "pointers" through
decrepit factories and warehouses, falling off the end of an array of
blocks or crates, navigating through complex mazes of grids, finding
elevator floors mapped to different levels of indirection, and so
on. They're usually mind-bogglingly stupid and annoying real world
metaphors mapped to logical problems or vice-versa. (Occasionally they
are beautiful and brilliant, but that's the exception to the rule).
When I'm using Lisp, I find that these dream-like thoughts became
quite different. They are still illogical on waking, but they're much
more harmonious. Themes of order and symmetry replace the usual
struggle with annoyances. Sleep is more restful and satisfying.
Obviously, for whatever reason, Lisp creates less mental friction for
me than other languages.
Whatever the cause, it is *not* the result of greater familiarity with
Lisp. I know other languages much better than I know Lisp.
I've heard many people wax lyrical about the "QWAN", but I've never
heard anyone else describe being snugly cradled between the parens at
night. Perhaps it's just an oddity of mine. Any comments?
Patrick W <······@yahoo.com.au> writes:
> When I'm using Lisp, I find that these dream-like thoughts became
> quite different. They are still illogical on waking, but they're much
> more harmonious. Themes of order and symmetry replace the usual
> struggle with annoyances. Sleep is more restful and satisfying.
> Obviously, for whatever reason, Lisp creates less mental friction for
> me than other languages.
Sounds to me like you've discovered that Lisp is a language meant to
be molded into whatever you feel like having. Therefore, the only
mental friction is that of your own mind resisting doing what it wants
or understanding the base language enough to implement what it
wants. Seems rational to me that this would cause less mental
friction. :)
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
> On dreams:
heh.. i often have dreams in which the world is written in lisp.. one
night i fixed my car (an old old old car..) .. which of course, was
written in lisp..
D. Goel <·····@glue.umd.edu> wrote in message news:<···············@fosters.umd.edu>...
> > On dreams:
>
> heh.. i often have dreams in which the world is written in lisp.. one
> night i fixed my car (an old old old car..) .. which of course, was
> written in lisp..
Heh. Lucky you. They don't make 'em like they used to.
I wish my car was written in Lisp. It wouldn't be half as bulky,
sluggish, ugly, square-built, and expensive to run.
I suspect mine's written in Java.
"Patrick W" <······@yahoo.com.au> wrote in message
·································@posting.google.com...
> I wish my car was written in Lisp. It wouldn't be half as bulky,
> sluggish, ugly, square-built, and expensive to run.
Write a meta-circular interpreter. Then BOTH your car AND your cdr will be
written in Lisp.
--
Biep
Reply via http://www.biep.org
From: Michael Hudson
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <u3cy6b3ex.fsf@python.net>
Patrick W <······@yahoo.com.au> writes:
> Michael Hudson <···@python.net> writes:
>
> > I'm fairly sure that in the introduction to a fairly well known Lisp
> > book there's a paragraph along the lines of
> >
> > Be careful about learning Lisp; it may make programming in lesser
> > languages seem painful.
> >
> > I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
> > in there.
> >
> > Anybody know what I'm talking about?
>
> You're talking about Chapter 1 of Paul Graham's "On Lisp":
>
> "[...] the greatest danger of Lisp is that it may spoil you. Once
> you've used Lisp for a while, you become so sensitive to the fit
> between language and application that you won't be able to go back to
> another language without always feeling that it doesn't give you quite
> the flexibility you need."
Thank you, that's the one.
Cheers,
M.
--
>> REVIEW OF THE YEAR, 2000 <<
It was shit. Give us another one.
-- NTK Know, 2000-12-29, http://www.ntk.net/
funny, my dreams often consist of code related issues, but often as well
about math and my personal life...
sadly me personal life is not going like my dreams (or at least not my
newer ones). my life seems to be mirroring those of a few months ago, but
things are bent a little different.
my mind is divided, and my dreams in much the same way. code can not hurt
as much as reality, so that is probably a factor.
often my dreams consist of more tree-like representations of things
(stepping along and reorganizing a tree, or building a new one...). but
really I can't give clear examples.
sometimes it is a hybrid, the people are represented by structures that
describe their nature (?...). sometimes the interactions of the people are
represented in a code like form...
I don't know if this makes any sense...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
Patrick W wrote:
> Assuming you have programming-related dreams (as I do), did you notice
> that your dreaming patterns changed when you started using Lisp? (Or
> some other language?)
I program in Perl/ASP at work. Once when I was working on a project at work
I would actually sit up in the middle of the night and see Perl code on and
describing my bedroom and my wife. It was a rather troubling experience
until I realized I was sleeping. I then fell back into the bed and went to
sleep.
Since I have started working with Lisp I never have troubling dreams about
Perl. I have beautiful dreams with Lisp describing the dream. I actually
see the Lisp code that describes the contents of the dream. Often when I
get tired I will see Lisp code on top of the things I see.
I also see Lisp code describing events. Like when my cat jumps across the
room I actually see the Lisp code to describe her jump and landing.
I personally like dreaming in Lisp. I never remember the details when I
wake up. I just remember that I had a good time. And I often sleep better
when I dream in Lisp.
--
Lorance Stinson <·······@worldpbx.com> http://www.worldpbx.com/
Codito, Ergo Sum (I Code, therefore I am)
Damond Walker wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
It seems like a had the advantage of not coming to Lisp via an AI class
doing lots of list operations. I'm a student of Computational
Linguistics, but Lisp is not on topic here anymore. The languages taught
are Prolog (which I don't like too much, but it may be due to the fact
that I still did not comprehend it), Perl, Java, C, and C++.
My first experience with computers was a CP/M system at age 11, for
which I had no documentation other than a book about Basic
programming. I spent countless hours doing this. Then, for many years I
did not use computers at all (no one bought one for me), until I started
to study Industrial Management and used a computer for writing scripts
and explore the internet. After a few months I got fed up with Windows
and dove into the Linux world. Along with Linux came the most
fascinating application I knew so far: Emacs. And I found out how much I
was interested in working with computers. So I switched my major and
started to do something I like.
Then, one day I stumbled upon an article about a Lisp anniversary (must
have been the 40th), which basically said that Lisp was one of the
oldest programming languages still in use. That made me curious. I
started to search the web for Lisp, and then the library of our
department (full of good Lisp books, mostly from the 80s, barely read in
the last years), and what I found got me hooked. For me, a programming
language is a means to translate my thoughts into something the computer
can understand, and Lisp seems to fit better to the way I think than any
other language I know. I'm still a beginner to Lisp, but I can honestly
say that this is the first time after writing Basic as a child that I
really enjoy programming.
The people using Lisp also seem to be of a different kind than those
using the mainstream languages. This is the only newsgroup related to
programming I read for more than a few days. That has to mean something,
because I'm bored easily.
Felt good talking about it. Back to lurking now.
--
Wolfgang Mederle
$BONMOT
On 4 Apr 2002 07:27:55 -0800, ·······@syncreticsoft.com (Damond Walker)
wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
I came to Lisp in a fairly typical and possibly unglamorous way.
In 1990 I attended an introductory programming class at the computer
science department of the University of Milano, Italy. At the first lesson
the instructor announced that we would have used a programming language
called Scheme, and a textbook titled "Structure and Interpretation of
Computer Programs" (the class covered the first 3 chapters).
At the time I had never heard of neither Scheme nor the book. But I did
superficially know about Lisp's stereotypes.
I immediately and instinctively liked the language for a number of reasons,
not all of which I am able to formalize. I was particularly impressed by
the equivalence between code and data, and by the typical development
environments' interactivity, integration and ability to evaluate
arbitrarily simple expressions.
Interestingly, although I was aware of the stereotypes and jokes about
parentheses, they were _never_ an issue for me. I think I was able to
correctly use them in a matter of hours, even without a computer-based
editor. Indeed, although I bought TI PC-Scheme 3.03 for MS-DOS just a few
days after the start of the class, I got my new laptop only a couple of
months later because of a delivery delay.
SICP told that Scheme was a member of a larger family of languages[*], and
I began learning more about Lisp, its history and its community. I
eventually run across Common Lisp, and liked it.
At the time of the Scheme class I shared the common view--no pun
intended--that its beauty comes from its conceptual simplicity and
cleanliness. But when I found Common Lisp, I liked it even more: its design
tradeoffs and the wisdom with which it approaches real world issues looked
beautiful to me.
Lisp was the only language with which I felt really productive, and I
decided to learn it as well as I could, and use it for all my programming
projects.
Paolo
[*] It actually made some stronger statements, but you get the picture :)
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
[http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/]
On 4 Apr 2002 07:27:55 -0800, ·······@syncreticsoft.com (Damond Walker)
wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
It was part of my introductory Computer Science class at MIT (1977).
(6.031 for those who care). The course was roughly divided into two
parts, the first using Algol-60 and the second using MacLisp.
The real revelation came when we had just finished the last project with
Algol: It was a simple desktop calculator, where one could type
expressions with variables using infix notation. It was a fair bit of
work, what with the required parsing, etc., and it only supported the
standard four arithmetic operations along with exponentiation.
Then we started on the Lisp part of the course. The first week we ended
up writing a symbolic algebraic differentiator, with integration
following the next week. It was much easier to program, and also solved
a much more intriguing and difficult task. That was my real revelation
about the power of using Lisp.
-Tom.
--
Thomas A. Russ, USC/Information Sciences Institute ···@isi.edu
···@sevak.isi.edu (Thomas A. Russ) writes:
> On 4 Apr 2002 07:27:55 -0800, ·······@syncreticsoft.com (Damond Walker)
> wrote:
>
> > I'm always interested in how people "came to something." In this case
> > it's Lisp. How about relaying how you "came to Lisp?"
>
> It was part of my introductory Computer Science class at MIT (1977).
> (6.031 for those who care). The course was roughly divided into two
> parts, the first using Algol-60 and the second using MacLisp.
And also a virtual assembler called 'm' that had a cute little
idealized instruction set made for teaching assembly / machine code.
I'm pretty sure you mean 'delphi lisp' which was far from a maclisp.
I took 6.031 the same year and i think it was delphi on the delphi
unix 11/45...
Delphi lisp had the interesting property that it could be invoked with
a -s or -t (for 'stack' or 'tree' semantics) which had some sort of
different effect on how closures worked, i think. (I have the class
notes still in hardcopy somewhere, and i remember one-page
descriptions of S- and T-evaluators on the tests or problem sets.)
This lisp also swapped. not paged. so when you weren't in you were
out. supporting 20 people in the room meant that sometimes one person
had an out of control process that was taking the whole processor. it
would type MEMORY WAIT on the (hardcopy) consoles of all the people in
the room while they waited for one pig to finish his computation.
angry people would get up and wander around looking for the person who
_didn't_ have MEMORY WAIT typed on their console.
If this isn't what you experienced, maybe it was not 1977? Or maybe
you took it in the fall and I took it in the spring. Even on the
transition off of the pdp11 onto the pdp10, though, I'd written a
simulator for a lisp dialect i made up (called Ulisp, since it was a
derivative of an emulator i'd written for the pdp11 unix (delphi) lisp
to run on the pdp10 ...). I think my teaching dialect was used for
one semester before the switch to scheme. it ran in maclisp but was
not maclisp.
> the real revelation came when we had just finished the last project with
> algol: it was a simple desktop calculator, where one could type
> expressions with variables using infix notation. it was a fair bit of
> work, what with the required parsing, etc., and it only supported the
> standard four arithmetic operations along with exponentiation.
>
> then we started on the lisp part of the course. the first week we
> ended up writing a symbolic algebraic differentiator, with
> integration following the next week. it was much easier to program,
> and also solved a much more intriguing and difficult task. that was
> my real revelation about the power of using lisp.
i agree with this part.
Kent M Pitman <······@world.std.com> writes:
> I'm pretty sure you mean 'delphi lisp' which was far from a maclisp.
> I took 6.031 the same year and i think it was delphi on the delphi
> unix 11/45...
It very likely wasn't Maclisp, then.
> Delphi lisp had the interesting property that it could be invoked with
> a -s or -t (for 'stack' or 'tree' semantics) which had some sort of
> different effect on how closures worked, i think. (I have the class
> notes still in hardcopy somewhere, and i remember one-page
> descriptions of S- and T-evaluators on the tests or problem sets.)
Initially this sounded quite bizarre, but the longer I think about it,
them more some hazy memories are returning to me. It seems so long and
so many parentheses ago...
> If this isn't what you experienced, maybe it was not 1977? Or maybe
> you took it in the fall and I took it in the spring.
I'm pretty sure it was in Spring 1977. There was a 1-week, somewhat
optional machine language segment, but otherwise it was just Lisp and
Algol.
-Tom.
--
Thomas A. Russ, USC/Information Sciences Institute ···@isi.edu
Damond Walker wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
This was in late 1981. I had run out of my grant, but still had access
to college facilities, including a mainframe account on an ICL 2980.
I had no job and no job experience. Then I heard on the BBC World
Service some computer-composed music, and it sounded awful. I was
sure I could do better myself. The first thing I had to decide was
which language to write it in, and the supported languages were Fortran
and Basic, both of which I had learned, and COBOL and Pascal. I choose
Basic because it had the best string handling, and was interactive.
(There were other languages on the machine, but they were unsupported,
so I didn't consider them. Snobol4 was one (no Lisp), and would have
been a better choice, but there was no documentation.) So I wrote my
music composition program in Basic. Then one of my colleagues
recognized
that what I was doing was Artificial Intelligence, and told me about
Lisp. He had an account on a machine in Cambridge (England, not MA),
to which a connexion could me made via an acoustic coupler, which did
run Lisp but in batch mode, so you would type
(CDR '(A B C))
and submit it as a job. You could query the system and watch the
job move to the front of the queue, when it would return
(B C)
He also had a copy of Kernighan and Richie, and another colleague
had Winston and Horn. I compared them and remember deciding that C
looked terribly old-fashioned, and so bough my own copy of W&H.
I still have it. (I now get paid to write C. It insults my
intelligence less than Java, so I don't mind.)
The music composition program helped me get my first job and access
to a Burroughs 6800, and I heard rumours that someone once put a Lisp
on it but it had been archived. I tracked this down and had it put
back on the machine. It was Portable Standard Lisp.
After that, I had access to Poplog, but the Lisp for that was little
more than a toy at the time, and so programming was done in Pop11 and
Prolog instead. I also had very occasional access to Franz Lisp, and
later implemented my own Redlisp interpreter, based loosely on Maclisp,
in Turbo Pascal. Shortly after that I was using PC Scheme (cue: Is
Scheme a Lisp?) before finally using Allegro Common Lisp in 1992.
A bit of a saga I know, but it's what you asked for.
> Damond
--
Le Hibou
You know you've been hacking too long if, when someone
asks you if you have a son, you reply, "No, but I've
got a Symbolics 3630".
"Donald Fisk" <················@enterprise.net> ha scritto nel messaggio ······················@enterprise.net...
> Shortly after that I was using PC Scheme (cue: Is
> Scheme a Lisp?)
Well, the front cover of the manual says:
"PC Scheme
a simple, modern Lisp"
P.
* "Pierpaolo BERNARDI" <··················@hotmail.com>
| Well, the front cover of the manual says:
|
| "PC Scheme
| a simple, modern Lisp"
Why are the Scheme people authoritative on whether Scheme is a Lisp?
If you ask almost any person if they are honest, they will answer "yes",
the dishonest probably more often than the honest. If you want a correct
and useful answer, you have to find out what they mean: Do they simply
answer the question honestly, or do they give an answer that they think
will cause you to act in a particularly beneficial way towards them? All
these jokes about used car salesmen who call themselves "Honest Joe" and
_still_ people buy it when someone who clearly has something to gain from
being a Lisp says they are?
So why is nobody _else_ authoritative on whether Scheme is a Lisp?
I think "Your introductoin to Scheme" should go in comp.lang.scheme.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum <····@naggum.net> writes:
> * "Pierpaolo BERNARDI" <··················@hotmail.com>
> | Well, the front cover of the manual says:
> |
> | "PC Scheme
> | a simple, modern Lisp"
>
> Why are the Scheme people authoritative on whether Scheme is a Lisp?
>
> If you ask almost any person if they are honest, they will answer "yes",
> the dishonest probably more often than the honest. If you want a correct
> and useful answer, you have to find out what they mean: Do they simply
> answer the question honestly, or do they give an answer that they think
> will cause you to act in a particularly beneficial way towards them? All
> these jokes about used car salesmen who call themselves "Honest Joe" and
> _still_ people buy it when someone who clearly has something to gain from
> being a Lisp says they are?
>
> So why is nobody _else_ authoritative on whether Scheme is a Lisp?
>
> I think "Your introductoin to Scheme" should go in comp.lang.scheme.
I probably disagree.
If Pierpaolo is saying that he came to CL by way of Scheme, then the
discussion belongs here, regardless of whether Scheme is a Lisp or not.
(If, by contrast, he is using Scheme only, then I'm agnostic about the
issue. I don't think it's horrible if some Scheme people comment on
this thread... It's perhaps even useful for us to see whether there
are different patterns of how Scheme and Lisp people find out about
these respective areas.)
Also, since no one is doing advocacy in this thread, and people are
merely describing their personal experience, I think we should be
maximally tolerant in this thread in order to encourage people to jump
in without fear they will have their personal experience challenged.
It might really be that the Scheme data is "bad data" to some of us
for some purposes, but I'm not so sure it's "bad data" for all
participating in this forum. Even if you think those of us saying
"Scheme is not a Lisp" "won" the recent debate on that [and I don't
personally think these debates tend to have such definitive results],
there are still people in this community who stand on the "losing"
side. Those people aren't compelled by some mysterious force of law
or enforced shame to change their opinion to go with the majority.
Consequently, some of them may want the Scheme data even if others
don't. And I don't see major harm to any of us if we allow that,
especially since [as so often noted here] we can't prevent speech we
don't like anyway. [Surely you don't want to change that rule? :-)]
It is easier after-the-fact for those of us doing analysis to ignore a
few remarks by a few people if that in context of some subsequent
discussion seems appropriate than it is after-the-fact for us to get
people to contribute who might have been stifled by being unsure about
whether their experience was relevant.
This is what I usually call "brainstorming rules", where you basically
just let everyone speak in a fashion that monotonically increases the
set of information offered and you don't do any filtering, sifting, or
contradicting until later.
(Hopefully Thomas Russ doesn't think my response to him was contradicting
him... I just wanted to make sure we had his data correct...)
Kent M Pitman <······@world.std.com> writes:
> (If, by contrast, he is using Scheme only, then I'm agnostic about the
> issue. I don't think it's horrible if some Scheme people comment on
> this thread... It's perhaps even useful for us to see whether there
> are different patterns of how Scheme and Lisp people find out about
> these respective areas.)
>
> Also, since no one is doing advocacy in this thread, and people are
> merely describing their personal experience, I think we should be
> maximally tolerant in this thread in order to encourage people to jump
> in without fear they will have their personal experience challenged.
As a note, I don't agree with your statement that no one is doing
advocacy in this thread. I'll phrase this as, I for one would like
advocacy to be not in this thread, as I'm interested in people's
stories.
> It might really be that the Scheme data is "bad data" to some of us
> for some purposes, but I'm not so sure it's "bad data" for all
> participating in this forum.
Here's one voice agreeing to that last -- I am interested in Scheme in
the context of the various lisps (I am not a CL programmer; most of my
lisp programming is actually elisp for personal use).
In fact,that's pretty much my story as it is coming so far to lisp, so
it's even marginally on-topic to the thread. I bought a used book on
Franz lisp in high school and read the book multiple times but had no
access to a software environment, so it was all theoretical; lent the
book to someone at work and never since regained it =)
At school, the class at Stanford which is devoted to teaching Lisp
hasn't been taught in many years, so it's covered for a week or two in
the basic programming course, and lisp1.5 (I believe it's called that;
basically map,append,cons,car,cdr, and maybe one or two other
functions) is used for a comparative concepts in programming languages
class. Since then, I've begun doing more and more customization and
scripting of emacs.
--
If nature has made any one thing less susceptible than all others of
exclusive property, it is the action of the thinking power called an
idea, which an individual may exclusively possess [only] as long as he
keeps it to himself.... -- Thomas Jefferson
"Kent M Pitman" <······@world.std.com> ha scritto nel messaggio ····················@shell01.TheWorld.com...
> If Pierpaolo is saying that he came to CL by way of Scheme, then the
> discussion belongs here, regardless of whether Scheme is a Lisp or not.
I have said nothing about where I came from.
> (If, by contrast, he is using Scheme only, then I'm agnostic about the
> issue. I don't think it's horrible if some Scheme people comment on
> this thread... It's perhaps even useful for us to see whether there
> are different patterns of how Scheme and Lisp people find out about
> these respective areas.)
I use CL only, thank you very much.
> Also, since no one is doing advocacy in this thread, and people are
> merely describing their personal experience, I think we should be
> maximally tolerant in this thread in order to encourage people to jump
> in without fear they will have their personal experience challenged.
How depressing that you have to write this.
P.
I was introduced to CL in a college course. I liked it, and eventually
it opened up my eyes to what a great language Scheme is. I use Scheme
almost exclusively now, but still check in on c.l.l to see what's going
on with CL.
Just kidding!
Kent M Pitman <······@world.std.com> writes:
> It's perhaps even useful for us to see whether there are different
> patterns of how Scheme and Lisp people find out about these respective
> areas.
One pattern I notice is that nobody finds Scheme by being introduced to
CL first (as in my joke above), while a lot of people find CL by being
introduced to Scheme first.
There's a useful conclusion to draw from this. If you throw up your
hands and say it's hopeless for someone who learns Scheme first to then
learn CL, you're closing a door through which many people enter the CL
community.
--
<·······@[(if (brl-related? message) ; Bruce R. Lewis
"users.sourceforge.net" ; http://brl.sourceforge.net/
"alum.mit.edu")]>
In article <···············@biohazard-cafe.mit.edu>,
Bruce Lewis <·······@users.sourceforge.net> wrote:
>I was introduced to CL in a college course. I liked it, and eventually
>it opened up my eyes to what a great language Scheme is. I use Scheme
>almost exclusively now, but still check in on c.l.l to see what's going
>on with CL.
>
>Just kidding!
>
>Kent M Pitman <······@world.std.com> writes:
>
>> It's perhaps even useful for us to see whether there are different
>> patterns of how Scheme and Lisp people find out about these respective
>> areas.
>
>One pattern I notice is that nobody finds Scheme by being introduced to
>CL first (as in my joke above), while a lot of people find CL by being
>introduced to Scheme first.
Strange as it may seem, I was aware of Common Lisp --
CLtL1 anyway -- before I was of Scheme. However
I didn't have much programming experience in either at
the time so it would be wrong to imply I "left" either
language for the other.
I am still evaluating them. :-)
* Bruce Lewis <·······@yahoo.com>
| There's a useful conclusion to draw from this. If you throw up your
| hands and say it's hopeless for someone who learns Scheme first to then
| learn CL, you're closing a door through which many people enter the CL
| community.
Sure, they "discover" Common Lisp, but keep writing Scheme in it. Some
"think Scheme" even though they are actually learning and using Common
Lisp. It is important to inform those who discover Common Lisp that it
is not just "a better Scheme". Those who are not challenged in their
belief that they can just keep writing Scheme may spread their "take" on
Common Lisp faster than those who have figured it out, especially to
other Scheme freaks. Scheme is a like a mind-altering drug or some cult
that warps people's ability to think straight, and the resistance to it
is well-deserved, but precisely for that reason, people need to discover
that knowing Scheme is not beneficial to learning a real Lisp.
For instance, the following quote from O'Reilly's Write for Us page�
relates to deservedly bad experience with Scheme, not to Common Lisp,
which is largely if not completely unknown.
However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based training.
It is good that Scheme victims discover Common Lisp, just as with users
of any other programming language, but most of the others discover that
Common Lisp is a _different_ language from what they are used to, adjust
accordingly, and proceed to _learn_ it. Scheme victims seem to lack the
appriciation that Common Lisp is an entirely a new language, and just
think they know it, without ever getting the point. Just like Java and C
have very little in common besides the superficial syntactic similarity,
Scheme and Common Lisp have very little in common besides the superficial
syntactic similarity. This is just like the racial slur "you people all
look the same to me", where a group of people look "similarly different".
In some people's minds, there is no need distinguish between them as long
as you are not among them. Common Lisp suffers greatly from being
similarly different from "normal" languages as the villainous Scheme.
-------
� http://www.oreilly.com/oreilly/author/writeforus_1101.html
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum <····@naggum.net> writes:
> * Bruce Lewis <·······@yahoo.com>
> | There's a useful conclusion to draw from this. If you throw up your
> | hands and say it's hopeless for someone who learns Scheme first to then
> | learn CL, you're closing a door through which many people enter the CL
> | community.
>
> Sure, they "discover" Common Lisp, but keep writing Scheme in it.
This seems to me a simple matter of proper education. I doubt it's a
fundamental property of the universe.
> Scheme is a like a mind-altering drug or some cult
> that warps people's ability to think straight, and the resistance to it
> is well-deserved,
My bet is that the same is said for Lisp. Education is itself a
mind-altering drug and it warps people's ability to think in the way
they would have thought absent it. If it warrants resistance, it is
not for the per se reason that it alters minds.
> but precisely for that reason, people need to discover
> that knowing Scheme is not beneficial to learning a real Lisp.
Well, Scheme intuitions are likely to mislead you in Lisp. But
right-handed driving intuitions may mislead one in driving in the UK.
I'm not sure that's the same as saying "learning to drive in the UK is
without value". I think the important thing is to make sure that
people visiting from the UK know that they are not still in the UK.
(Heck, I have to make sure people visiting from California know they
are not still in California when they try to navigate Boston
traffic...)
> For instance, the following quote from O'Reilly's Write for Us page�
> relates to deservedly bad experience with Scheme, not to Common Lisp,
> which is largely if not completely unknown.
>
> However, we're NOT looking for: Any books on LISP, LaTeX, or
> Web-based training.
Could this just mean one is in the pipe? Does anyone know why this would
be there? If it is a bad experience, can we find out what?
There presumably have been successful books in this subject area. Perhaps
they are worried that all that needs to be known about this area is already
available in print. Perhaps we could see if the "ostrich with its head in
the sand" or the "hear no evil, see no evil, speak no evil" monkeys are
still available for a cover...
> It is good that Scheme victims discover Common Lisp, just as with users
> of any other programming language, but most of the others discover that
> Common Lisp is a _different_ language from what they are used to, adjust
> accordingly, and proceed to _learn_ it. Scheme victims seem to lack the
> appriciation that Common Lisp is an entirely a new language, and just
> think they know it, without ever getting the point.
(All the more reason there should be a book.)
> Just like Java and C
> have very little in common besides the superficial syntactic similarity,
> Scheme and Common Lisp have very little in common besides the superficial
> syntactic similarity. This is just like the racial slur "you people all
> look the same to me",
But as with racial situations like this, there's an inverse problem
that occurs when people accuse people of making this slur without
checking. Both sides are often guilty of this. People of color green
often accuse people of color blue of being 'all alike' and it invites
people of color blue to assume all people of color green are out to
get them. The solution is to stop going on the basis of the name, and
to do the much harder thing of working (from _both_ sides) with people
as individuals. I think there is a parallel to your remark here.
> where a group of people look "similarly different".
> In some people's minds, there is no need distinguish between them as long
> as you are not among them.
Yes, this is so. But it cannot be the case that this set of people is named
by the name "Scheme programmers", nor even "people who prefer to program
in Scheme", since I can point to counterexamples.
> Common Lisp suffers greatly from being
> similarly different from "normal" languages as the villainous Scheme.
>
> -------
> � http://www.oreilly.com/oreilly/author/writeforus_1101.html
Thanks for the page reference.
I'll see if I can follow up with O'Reilly to find out what the issue
is here. If I can get a contact address. I got a 404 when I clicked
on the "O'Reilly Contacts" item at the bottom of that page. Maybe
they don't want a book on web training because it would challenge the
job security of their webmaster. ;)
Kent M Pitman <······@world.std.com> writes:
> Erik Naggum <····@naggum.net> writes:
>
> > For instance, the following quote from O'Reilly's Write for Us page�
> > relates to deservedly bad experience with Scheme, not to Common Lisp,
> > which is largely if not completely unknown.
> >
> > However, we're NOT looking for: Any books on LISP, LaTeX, or
> > Web-based training.
>
> Could this just mean one is in the pipe? Does anyone know why this would
> be there? If it is a bad experience, can we find out what?
>
> There presumably have been successful books in this subject area. Perhaps
> they are worried that all that needs to be known about this area is already
> available in print. Perhaps we could see if the "ostrich with its head in
> the sand" or the "hear no evil, see no evil, speak no evil" monkeys are
> still available for a cover...
I think it might be the fear of a saturated market. I'm guessing
that's the case with LaTeX -- both because I personally think that
subject is covered quite well in the English language, and because of
this book: "LaTeX par la pratique",
<http://www.oreilly.fr/catalogue/latex.html>.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> Erik Naggum <····@naggum.net> writes:
>
> > * Bruce Lewis <·······@yahoo.com>
> > | There's a useful conclusion to draw from this. If you throw up your
> > | hands and say it's hopeless for someone who learns Scheme first to then
> > | learn CL, you're closing a door through which many people enter the CL
> > | community.
> >
> > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
>
> This seems to me a simple matter of proper education. I doubt it's a
> fundamental property of the universe.
That's a pretty arrogant thing to say. As someone who writes Scheme code
in Common Lisp (apparently) I take umbrage at your claim that 1) this is
self-evidently the wrong thing to do and 2) that I do so because I haven't
had a "proper education". Tell me, what do you consider a "proper
education"? I've read the hyperspec, CLTL1&2, Norvig, both Graham books,
Quiennec, and about ten years worth of c.l.l., not to mention every paper
of yours that I could lay my hands on. What would you have me do instead?
E.
···@jpl.nasa.gov (Erann Gat) writes:
> In article <···············@shell01.TheWorld.com>, Kent M Pitman
> <······@world.std.com> wrote:
>
> > Erik Naggum <····@naggum.net> writes:
> > ...
> > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
> >
> > This seems to me a simple matter of proper education. I doubt it's a
> > fundamental property of the universe.
>
> That's a pretty arrogant thing to say. As someone who writes Scheme code
> in Common Lisp (apparently) I take umbrage at your claim that 1) this is
> self-evidently the wrong thing to do and 2) that I do so because I haven't
> had a "proper education".
I think we're talking about different things.
I was taking the remark more literally. People really do things like:
(defun f (x)
(defun g (x) ...)
... use g ...)
This kind of thing works in Scheme but doesn't mean what Scheme people
think in CL.
Certainly there are compatible styles one can adopt, but one can also try
to pretend CL has Scheme semantics and get in trouble.
Even just relying on tail calling when you've been told it's not reliably
there in CL is an example.
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> ···@jpl.nasa.gov (Erann Gat) writes:
>
> > In article <···············@shell01.TheWorld.com>, Kent M Pitman
> > <······@world.std.com> wrote:
> >
> > > Erik Naggum <····@naggum.net> writes:
> > > ...
> > > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
> > >
> > > This seems to me a simple matter of proper education. I doubt it's a
> > > fundamental property of the universe.
> >
> > That's a pretty arrogant thing to say. As someone who writes Scheme code
> > in Common Lisp (apparently) I take umbrage at your claim that 1) this is
> > self-evidently the wrong thing to do and 2) that I do so because I haven't
> > had a "proper education".
>
> I think we're talking about different things.
That's possible. I'm just going on what I've been told here, to wit: that
using symbols for everything is the (Common) Lisp way, and using values
directly is the Scheme way. I thought that "doing things the Scheme way"
and "writing Scheme in [Common Lisp]" meant the same thing.
E.
In article <···············@shell01.TheWorld.com>,
Kent M Pitman <······@world.std.com> wrote:
>···@jpl.nasa.gov (Erann Gat) writes:
>
>> In article <···············@shell01.TheWorld.com>, Kent M Pitman
>> <······@world.std.com> wrote:
>>
>> > Erik Naggum <····@naggum.net> writes:
>> > ...
>> > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
>> >
>> > This seems to me a simple matter of proper education. I doubt it's a
>> > fundamental property of the universe.
>>
>> That's a pretty arrogant thing to say. As someone who writes Scheme code
>> in Common Lisp (apparently) I take umbrage at your claim that 1) this is
>> self-evidently the wrong thing to do and 2) that I do so because I haven't
>> had a "proper education".
>
>I think we're talking about different things.
>
>I was taking the remark more literally. People really do things like:
>
> (defun f (x)
> (defun g (x) ...)
> ... use g ...)
>
>This kind of thing works in Scheme but doesn't mean what Scheme people
>think in CL.
>
>Certainly there are compatible styles one can adopt, but one can also try
>to pretend CL has Scheme semantics and get in trouble.
>
>Even just relying on tail calling when you've been told it's not reliably
>there in CL is an example.
We are talking about a real novice here, who should be
given _some_ learning time before being tested.
It is quite easy for a person, even a Schemer, to learn
that DEFUN doesn't act like an "internal DEFINE"
(indeed, quite a few Schemers such as me abjure the use
of internal DEFINEs in their own language, preferring
to use a more explicitly lexicalizing operator like LET
or LETREC); or that tail-call elimination is not
guaranteed in CL. A Schemer would in fact be very
alive to this, and make sure that he got his lexicals
and loops right in the CL environment. All novice
problems should be so easily self-correctable.
I think a much more pervasive and uncorrectable malaise
is intended when the bad influence of Scheme is cited.
*
To those who do want to write Scheme in CL, may I
suggest that if the reason is to simply have your code
run in CL, you are better off writing Scheme in Scheme
and then using something like
http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html --
less stylistic nerves (your own and your
CL-knowing critic's) may be frayed that way.
In article <············@news.gte.com>, ····@gte.com wrote:
> To those who do want to write Scheme in CL, may I
> suggest that if the reason is to simply have your code
> run in CL, you are better off writing Scheme in Scheme
> and then using something like
> http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html --
> less stylistic nerves (your own and your
> CL-knowing critic's) may be frayed that way.
FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
doing) is that IMO it is much easier to write Scheme in CL than it is in
Scheme.
E.
On Fri, 12 Apr 2002, Erann Gat wrote:
[snip]
> FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
> doing) is that IMO it is much easier to write Scheme in CL than it is in
> Scheme.
Perhaps you are using only that subset of Scheme which is not painful to
write in CL...You Outcast :)
It be interesting to know if you were using a kind of Scheme + CL
extensions that was langauge focused or "just" library focused. I.e.,
whether it was Scheme subset + CLOS (in which case, a Scheme + GOOPS might
work for you) or Scheme subset + format. Etc.
Cheers,
Bijan Parsia.
Bijan Parsia <·······@email.unc.edu> writes:
> whether it was Scheme subset
^^^^^^^^^^^^^
You got to be kidding :)
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
On 12 Apr 2002, Marco Antoniotti wrote:
>
> Bijan Parsia <·······@email.unc.edu> writes:
>
> > whether it was Scheme subset
>
> You got to be kidding :)
Well, yes :)
...and no. Common things to leave out of a...er...toy scheme
implementation are, well, continuations and tail recursion. At least,
everywhichway continuations and some forms of tail recursion. I understand
that these are *very* hard to do well on some architectures (e.g., the
JVM), at least, with decent
performance. (http://www.gnu.org/software/kawa/Restrictions.html)
Schemes sometimes lag behind the R*RS document.
I did mean that he might be using a super and subset. If you don't count
the extentions to a Scheme that are required to make an useful
environment, then it's a superset. If you leave out call/cc, it's a
subset.
Cheers,
Bijan Parsia.
* ···@jpl.nasa.gov (Erann Gat)
| FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
| doing) is that IMO it is much easier to write Scheme in CL than it is in
| Scheme.
If true, this explains why Scheme freaks so seldom learn Common Lisp
well. Common Lisp would just be a "better Scheme" to them, and just like
C programmers keep programming in C forever because all the "modern"
languages all have a basic C-like syntax. Perhaps a significant change
in the syntax is _necessary_ to make people change their habits, as they
would no longer be visually tempted to think it is the same as they know.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * ···@jpl.nasa.gov (Erann Gat)
> | FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
> | doing) is that IMO it is much easier to write Scheme in CL than it is in
> | Scheme.
>
> If true, this explains why Scheme freaks so seldom learn Common Lisp
> well.
I wonder, am I a Scheme freak? I started learning Lisp in 1979 on an
Apple II using P-lisp. (I know this only because I recently stumbled
across my copy of P-lisp -- on a 5-inch floppy -- while rummaging through
some old boxes.) I first encountered Scheme around 1983 or so (I don't
recall exactly), and it kind of rubbed me the wrong way at first because I
couldn't wrap my brain around call/cc. The only significant Scheme code I
ever wrote was my master's thesis work, which was only about 100 lines of
code (using MacScheme running on a Mac Plus). Shortly thereafter I met
Macintosh Common Lisp, which instantly became my programming environment
and language of choice, and remains so to this day. In the late 1980's I
had a brief flirtation with T and Oaklisp, but eventually came back to
Common Lisp. I've read (and enjoyed) CLTL1&2, Norvig, the Hyperspec,
Quiennec, both Graham books, and pretty much everything posted to c.l.l.
in the last fifteen years.
During this entire time I've followed a programming style that was more
object-oriented than symbolic. Nonetheless, the majority of my work has
been designing and writing interpreters for domain specific languages, an
endeavor which I had always thought of as symbolic programming, but which
doesn't seem (to my surprise) to be considered so around here.
Since subtlety often seems to be lost on you, Erik, let me say explicitly
that this is a rhetorical question, that I don't care in the least whether
you think I'm a Scheme freak or not, and that what I'm really trying to
communicate (obliquely) is that I think your claim that relying on symbols
is "the (Common) Lisp way" is rubbish. "Symbolic programming" as it has
been defined here in recent discussions is but one of many programming
paradigms that (Common) Lisp supports. But it's not the only one, and
it's not the defining paradigm of the language. (It's not even clear to
me that it's a particularly good idea.)
E.
···@jpl.nasa.gov (Erann Gat) writes:
> During this entire time I've followed a programming style that was more
> object-oriented than symbolic. Nonetheless, the majority of my work has
> been designing and writing interpreters for domain specific languages, an
> endeavor which I had always thought of as symbolic programming, but which
> doesn't seem (to my surprise) to be considered so around here.
I think the idea of a Common Lisp style is meaningful with relation to
a specific other language, say Scheme or Java. But not so much in
isolation. When we all have the same facilities, we won't all program
in the same style, even if we'd all learned to program along the same
path. People are idiosyncratic, and we have odd, individual thought
patterns. No one will play pictionary with me and my brother, because
we have enough of the same idiosyncratic patterns of thought that
we'll be able to know what the other one is drawing sometimes after 2
lines are on the paper -- and even the full explanation of why the
picture means what it does, doesn't necessarily make sense to anyone
else. We also have a similar programming style, but it's difficult
sometimes to explain how it's similar. Strictly speaking, his code in
C++ and my code in Lisp often look very different -- I might solve the
problem using, say, mutually recursive functions and tagbody/go, and
he might use a mixture of C++-style OOP and imperative style. But I
can see that we both broke the problem up similarly, because we
noticed the same patterns, even if we expressed them in different
styles.
I think what I'm trying to say is that if your style is most easily
expressed in CL, but looks different than most other people's CL,
you're probably not writing in Scheme style or CL style, but Erann Gat
style.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
* Erann Gat
| Since subtlety often seems to be lost on you, Erik, let me say explicitly
| that this is a rhetorical question, that I don't care in the least whether
| you think I'm a Scheme freak or not, and that what I'm really trying to
| communicate (obliquely) is that I think your claim that relying on symbols
| is "the (Common) Lisp way" is rubbish.
Oh, great, still not recovering. Everything is so _personal_ to you.
Seek professional help and get over whatever debilitating trauma you
think you have been through and learn to deal _intelligently_ with the
things you disagree with, will you? You are becoming a charicature.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum <····@naggum.net> writes:
> Oh, great, still not recovering. Everything is so _personal_ to you.
> Seek professional help and get over whatever debilitating trauma you
> think you have been through and learn to deal _intelligently_ with the
> things you disagree with, will you? You are becoming a charicature.
Incidentally, I've followed this thread noticing one rather
interesting thing.
Despite the claims of Erik and others that they hate to see language
advocacy of Scheme on c.l.l--that they think Scheme is a thing which
is better addressed elsewhere, it was those folks who brought it up,
so that they might attack it. And even attack Erann in its name for
"Schemelike thinking", when he isn't even particularly a Scheme fan.
Blech.
In article <················@naggum.net>, Erik Naggum <····@naggum.net>
wrote:
> * ···@jpl.nasa.gov (Erann Gat)
> | FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
> | doing) is that IMO it is much easier to write Scheme in CL than it is in
> | Scheme.
>
> If true, this explains why Scheme freaks so seldom learn Common Lisp
> well. Common Lisp would just be a "better Scheme" to them, and just like
> C programmers keep programming in C forever because all the "modern"
> languages all have a basic C-like syntax. Perhaps a significant change
> in the syntax is _necessary_ to make people change their habits, as they
> would no longer be visually tempted to think it is the same as they know.
Which would make Dylan a good thing.
But I think you're wrong. I program on a nearly daily basis in all of
C, C++, Java and Perl, all of which have nominally "C" syntax. I'm
under no illusion that they are all the same language, and I have no
trouble in programming idiomatically in each.
-- Bruce
In article <····················@192.168.1.50>,
Erann Gat <···@jpl.nasa.gov> wrote:
>In article <············@news.gte.com>, ····@gte.com wrote:
>
>> To those who do want to write Scheme in CL, may I
>> suggest that if the reason is to simply have your code
>> run in CL, you are better off writing Scheme in Scheme
>> and then using something like
>> http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html --
>> less stylistic nerves (your own and your
>> CL-knowing critic's) may be frayed that way.
>
>FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
>doing) is that IMO it is much easier to write Scheme in CL than it is in
>Scheme.
It's clear you are not one who'd use internal DEFUN or
assume tail-call elimination or commit any of the other
boo-boos alleged of those who have learned Scheme
before CL. So if all you are saying is that you
like to use values directly instead of always
indirecting through symbols bound to them, I don't
think that marks you as someone who "writes Scheme in
CL".
I am sure CL usage is quite accepting and encouraging
even of the direct manipulation of values. I'd be
surprised if there were even a tacit stylistic
admonition against it.
In article <············@news.gte.com>, ····@gte.com wrote:
> It's clear you are not one who'd use internal DEFUN or
> assume tail-call elimination or commit any of the other
> boo-boos alleged of those who have learned Scheme
> before CL. So if all you are saying is that you
> like to use values directly instead of always
> indirecting through symbols bound to them, I don't
> think that marks you as someone who "writes Scheme in
> CL".
Well, according to Erik, it marks me as doing things the "Scheme way". Of
course, Erik, also distinguishes between "Scheme is a Lisp" and "Scheme is
a member of the Lisp family of languages", so maybe "writing Scheme in CL"
and "doing things the Scheme way [in CL]" don't mean the same thing
either.
> I am sure CL usage is quite accepting and encouraging
> even of the direct manipulation of values.
Erik disagrees. According to him, this is the Scheme Way.
> I'd be surprised if there were even a tacit stylistic
> admonition against it.
Then you must not have read the recent thread on packages.
E.
In article <····················@192.168.1.50>,
Erann Gat <···@jpl.nasa.gov> wrote:
>In article <············@news.gte.com>, ····@gte.com wrote:
>
>> It's clear you are not one who'd use internal DEFUN or
>> assume tail-call elimination or commit any of the other
>> boo-boos alleged of those who have learned Scheme
>> before CL. So if all you are saying is that you
>> like to use values directly instead of always
>> indirecting through symbols bound to them, I don't
>> think that marks you as someone who "writes Scheme in
>> CL".
>
>Well, according to Erik, it marks me as doing things the "Scheme way". Of
>course, Erik, also distinguishes between "Scheme is a Lisp" and "Scheme is
>a member of the Lisp family of languages", so maybe "writing Scheme in CL"
>and "doing things the Scheme way [in CL]" don't mean the same thing
>either.
>
>> I am sure CL usage is quite accepting and encouraging
>> even of the direct manipulation of values.
>
>Erik disagrees. According to him, this is the Scheme Way.
Well, I can't speak for another, but clearly, direct
manipulation of values obtains in Scheme also. I think
the criticism of Scheme was that that was all
that Scheme had -- that Scheme was, in effect, a
one-trick pony. The differentiation of the languages,
as I saw it, proceeded along these lines:
o In CL, one can do symbol-based indirection
without any setup.
o It's a very natural thing for humans to do --
since we tend to traffic in symbols standing for
something else all the time.
o It's an approach not immediately available in Scheme
-- not without user- or library-created tables. (BTW,
I don't find this charge too distressing, because as
Kent said recently (but of CL), "that's why they
call it a _programming_ language.")
>> I'd be surprised if there were even a tacit stylistic
>> admonition against it.
>
>Then you must not have read the recent thread on packages.
It (the admonition) may have slipped my view. All I
saw was a celebration of "symbol processing" as
something extra or, if you will, "value-added".
* Erann Gat
| Erik disagrees. According to him, this is the Scheme Way.
I can speak for myself, thank you. I wish you could figure out when to
shut the fuck up. You are just an annoying idiot, and whether _you_
write in Scheme style or JCL style does not concern me, but whether there
is a meaningful distinction that warrants intelligent discourse, does.
Quit being so goddamn personal. If you have defend yourself all the
time, at least talk to a shrink, and do not attack _me_ all the time.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * Erann Gat
> | Erik disagrees. According to him, this is the Scheme Way.
>
> I can speak for myself, thank you.
I wonder. You wrote:
But in general, using symbols to name things is the (Common) Lisp way,
and using the values directly is the Scheme way.
And then you go on to say:
> You are just an annoying idiot,
...
> do not attack _me_ all the time.
Hm, let's think about this again...
> You are just an annoying idiot,
...
> do not attack _me_ all the time.
Hmmm...
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
> You are just an annoying idiot,
You are beginning to remind me of certain people I encountered while
growing up in the Deep South (which for you international readers is an
area known for its high concentration of fundamentalist Christians). I
found it astonishing the extent to which I could offend people there
simply by quoting certain parts of the Bible to them. (II Kings 18:27
worked particularly well.) It's very entertaining watching you work
yourself into a lather simply because I cite your writings. But
ultimately it's a waste of time, and I'd just as soon stop.
E.
* Erann Gat
| I wonder.
Geez, for a few days, now, we had an abuse-free zone here because you
nutjobs seemed to be able to focus on something other than attacking me,
but I guess it is impossible for lunatics like you and Thomas Bushnell to
actually discuss anything at all unless I agree with your point of view.
Why is this? Why is it so goddamn important to you that I agree with you
that you stop thinking and stop discussing _anything_ if I say something
contrary to your opinions? Talk about not handling disagreement, guys!
So can you guys _please_ seek some professional help to get over your
disturbing dependency on having my approval on everything you say? If I
think you are lunatics, accept that this is my well-founded opinion from
observing your behavior towards me and just get on with your lives and do
something _intelligent_ to make me change my mind if it bothers you so
much, OK? If I should happen to think you are a Scheme freak, what _is_
it to you? Why does it even _matter_ than you fall in this category? I
mean, I did not think about you at all (why should I? you are nothing
more than an unimportant lunatic who are unable to listen to what I say),
yet you feel somehow "labeled" and "hurt" out of some paranoid delusion
that you were included in some negative attitude you saw. Dude. Chill.
Why _are_ you guys so upset about what I think? If it is true and you do
not like it, fighting my _saying_ it does not help you at all, it only
tells people that you are unwilling to _think_ about it and prefer to act
all emotional about it and think that pouting or behaving like babies who
have soiled themselves will change my mind. It won't. Deal with it.
GET BACK ON TRACK and discuss whatever has relevance to you _and_ this
forum, will you? If I am the most important thing you have to discuss,
there is something _seriously_ wrong with you. Get the hell over it!
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> Geez, for a few days, now, we had an abuse-free zone here
No, we didn't. And the fact that you think we have is the heart of the problem.
> Why _are_ you guys so upset about what I think?
Why do you think I'm upset about what you think? I'm not.
> If it is true and you do
> not like it, fighting my _saying_ it does not help you at all,
That's right. So consider the possibility that it might be something else
that I'm upset about (assuming I'm upset about anything).
> GET BACK ON TRACK and discuss whatever has relevance to you _and_ this
> forum, will you?
Here's the relevance it has to me: in exploring the surprising (to me)
affinity that people have for packages, I discovered that there is a whole
style of programming (which is called here "symbolic programming") of
which I was only dimly aware, and which some people whose views are
respected, notably you, believe is absolutely central to the entire notion
of programming in Lisp. All this comes as a surprise to me, for reasons
I've discussed in excruciating detail elsewhere and won't belabor here.
So I'm now trying to decide if this idea has any merit. One way of doing
this is to explore what other people think of it. Is this a widespread
view? Or are you the only one who believes it? To conduct such an
exploration one must necessarily ask of others in one way or another,
"What do you think of this thing that Erik has said?" That's what's going
on here. People I respect, for reasons passing understanding, have told
me that it's worthwhile paying attention to what you say, and I believe
them. So chill, dude.
> If I am the most important thing you have to discuss,
Don't flatter yourself.
E.
* Erann Gat
| Why do you think I'm upset about what you think? I'm not.
So prove it and shut up.
> If I am the most important thing you have to discuss,
| Don't flatter yourself.
So discuss something that is more important to you.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * Erann Gat
> | Why do you think I'm upset about what you think? I'm not.
>
> So prove it and shut up.
>
> > If I am the most important thing you have to discuss,
>
> | Don't flatter yourself.
>
> So discuss something that is more important to you.
>
> ///
ROTFLMAO! Do you realize that you've just told me to shut up and not shut
up at the same time? Do you even bother to think about what you post?
Let's try this one more time:
You wrote:
But in general, using symbols to name things is the (Common) Lisp way,
and using the values directly is the Scheme way.
I am interested in knowing what CL people think about this statement. Is
it a valid distinction? Is it worthwhile? Is it beneficial to do things
"the (Common) Lisp way" as defined above? If so, why?
For completeness let me reiterate that the reason I ask is that I've been
programming Common Lisp "the Scheme way" for many years, and I'm
interested in finding out if I've been missing something important by
doing so.
So far, the only concrete example I've seen of something that can be done
easily "the Common Lisp way" and not "the Scheme way" is combining
symbolic results from independently developed applications without keeping
track of the source of the results in the combined result. (Editorial
comment: this seems like a pretty marginal advantage to me.)
E.
···@jpl.nasa.gov (Erann Gat) writes:
> In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> > * Erann Gat
> > | Why do you think I'm upset about what you think? I'm not.
> > So prove it and shut up.
> > > If I am the most important thing you have to discuss,
> > | Don't flatter yourself.
> > So discuss something that is more important to you.
> ROTFLMAO! Do you realize that you've just told me to shut up and
> not shut up at the same time?
I never realized that two different times (contexts) were the same.
> Do you even bother to think about what you post?
Do you bother to think about what you read? Remeber, statements are
made in context, not in a void.
> Let's try this one more time:
>
> You wrote:
>
> But in general, using symbols to name things is the (Common) Lisp way,
> and using the values directly is the Scheme way.
>
> I am interested in knowing what CL people think about this statement. Is
> it a valid distinction?
Yes, it is. Symbols are a useful data type.
> Is it worthwhile? Is it beneficial to do things
> "the (Common) Lisp way" as defined above? If so, why?
Yes, because symbols have different behavior from all other data
types.
> For completeness let me reiterate that the reason I ask is that I've been
> programming Common Lisp "the Scheme way" for many years, and I'm
> interested in finding out if I've been missing something important by
> doing so.
If you've ever written an ungygenic (symbolic) macro, you've done
symbolic processing.
> So far, the only concrete example I've seen of something that can be done
> easily "the Common Lisp way" and not "the Scheme way" is combining
> symbolic results from independently developed applications without keeping
> track of the source of the results in the combined result. (Editorial
> comment: this seems like a pretty marginal advantage to me.)
Developing large, complex systems can seem marginal if that's not what
you do... I had thought that you would be someone who would appreciate
namespaces, but considering your inability to understand that language
has context, I suppose I was mistaken.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1304020825530001@192.168.1.50>
In article <··············@photino.sid.rice.edu>, Rahul Jain
<·····@sid-1129.sid.rice.edu> wrote:
> If you've ever written an ungygenic (symbolic) macro, you've done
> symbolic processing.
I write unhygienic macros all the time, but I believe I write them using
"keywords" rather than "symbols". That is, I don't believe I am making
use of any properties of the symbols other than their being uniquified
strings.
> > So far, the only concrete example I've seen of something that can be done
> > easily "the Common Lisp way" and not "the Scheme way" is combining
> > symbolic results from independently developed applications without keeping
> > track of the source of the results in the combined result. (Editorial
> > comment: this seems like a pretty marginal advantage to me.)
>
> Developing large, complex systems can seem marginal if that's not what
> you do... I had thought that you would be someone who would appreciate
> namespaces, but considering your inability to understand that language
> has context, I suppose I was mistaken.
I do appreciate name spaces, but I usually construct them using
environments, which I gather is also part of "the Scheme way".
E.
···@jpl.nasa.gov (Erann Gat) writes:
> In article <··············@photino.sid.rice.edu>, Rahul Jain
> <·····@sid-1129.sid.rice.edu> wrote:
> > If you've ever written an ungygenic (symbolic) macro, you've done
> > symbolic processing.
> I write unhygienic macros all the time, but I believe I write them using
> "keywords" rather than "symbols". That is, I don't believe I am making
> use of any properties of the symbols other than their being uniquified
> strings.
I don't see how this makes any sense. You pay NO attention to the
package of a symbol when using it? You NEVER use two packages that
have different symbols with the same name?
> > Developing large, complex systems can seem marginal if that's not what
> > you do... I had thought that you would be someone who would appreciate
> > namespaces, but considering your inability to understand that language
> > has context, I suppose I was mistaken.
> I do appreciate name spaces, but I usually construct them using
> environments, which I gather is also part of "the Scheme way".
You can't construct symbol name spaces using
environments. Environments are namespaces that map symbols to other
values, not strings to symbols (those are known as packages in CL,
just to make the point explicit).
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1304021539230001@192.168.1.50>
In article <··············@photino.sid.rice.edu>, Rahul Jain
<·····@sid-1129.sid.rice.edu> wrote:
> ···@jpl.nasa.gov (Erann Gat) writes:
>
> > In article <··············@photino.sid.rice.edu>, Rahul Jain
> > <·····@sid-1129.sid.rice.edu> wrote:
>
> > > If you've ever written an ungygenic (symbolic) macro, you've done
> > > symbolic processing.
>
> > I write unhygienic macros all the time, but I believe I write them using
> > "keywords" rather than "symbols". That is, I don't believe I am making
> > use of any properties of the symbols other than their being uniquified
> > strings.
>
> I don't see how this makes any sense. You pay NO attention to the
> package of a symbol when using it?
That's right. The kind of coding I do (or did) is mostly writing little
mini-languages sort of like the LOOP macro except domain-specific for
controlling robots and spacecraft. Like LOOP, I use symbols as keywords.
All I care about the symbol is its print name. Its semantics are provided
by the compiler or interpreter for the mini-language.
Occasionally I do want a thing with properties associated directly with
the thing, but in those cases I make an object, I don't use a symbol. If
I want that object to be uniquely associated with a name I make an
environment. In other words, I don't use symbols as objects, I use
objects (CLOS instances) as objects. Sometimes I use symbols to name
those objects, but the name is not the object, so I'm using symbols only
as keywords.
> You NEVER use two packages that
> have different symbols with the same name?
No, I use two packages that have symbols with the same name all the time.
I just find that all I care about is whether they are string=.
> > > Developing large, complex systems can seem marginal if that's not what
> > > you do... I had thought that you would be someone who would appreciate
> > > namespaces, but considering your inability to understand that language
> > > has context, I suppose I was mistaken.
>
> > I do appreciate name spaces, but I usually construct them using
> > environments, which I gather is also part of "the Scheme way".
>
> You can't construct symbol name spaces using environments.
> Environments are namespaces that map symbols to other
> values, not strings to symbols (those are known as packages in CL,
> just to make the point explicit).
This is pretty incoherent. First you take me to task for not
"appreciating" namespaces (whatever that means). Now you say that 1)
environments are name spaces but 2) you can't use them to construct
"symbol name spaces". But then you go on to say (or at least imply) that
"symbol name space" is just a synonym for package. So your statement is
nothing more than a tautological consequence of the way in which you've
defined "environment" and "symbol name space." It tells me nothing about
why I should prefer one over the other.
E.
···@jpl.nasa.gov (Erann Gat) writes:
> > You can't construct symbol name spaces using environments.
> > Environments are namespaces that map symbols to other
> > values, not strings to symbols (those are known as packages in CL,
> > just to make the point explicit).
>
> This is pretty incoherent. First you take me to task for not
> "appreciating" namespaces (whatever that means).
If you say that having namespaces for symbols is a _bad_ feature, of
course that's the conclusion people are going to make.
> Now you say that 1) environments are name spaces but 2) you can't
> use them to construct "symbol name spaces". But then you go on to
> say (or at least imply) that "symbol name space" is just a synonym
> for package. So your statement is nothing more than a tautological
> consequence of the way in which you've defined "environment" and
> "symbol name space."
It's the way the general community has defined them, not me. Refer to
Joe Marshall's post for a much more detailed and precise description
of the terms and their relationships.
The definition implies that they are two different concepts, and
therefore should be treated differently. Yes it's obvious. That's why
I don't understand your continuing fight against it.
> It tells me nothing about why I should prefer one over the other.
You prefer what is the most convenient represenatation for the data
considering the way you are using it.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1304021632460001@192.168.1.50>
In article <··············@photino.sid.rice.edu>, Rahul Jain
<·····@sid-1129.sid.rice.edu> wrote:
> I don't understand your continuing fight against it.
I'm not fighting against anything. I'm just asking a question.
E.
"Rahul Jain" <·····@sid-1129.sid.rice.edu> wrote in message
···················@photino.sid.rice.edu...
> Environments are namespaces that map symbols to other
> values, not strings to symbols (those are known as packages in CL,
> just to make the point explicit).
To be pedantic, environments map variables to locations.
The long tortuous route from what you type to what
you evaluate is this:
series of characters -> token -> symbol -> identifier
-> variable -> location -> value
CL packages operate at `token -> symbol' time.
Lexical environments operate at the `variable -> location' time.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3227686403949410@naggum.net>
* Erann Gat
| ROTFLMAO! Do you realize that you've just told me to shut up and not shut
| up at the same time? Do you even bother to think about what you post?
Oh, christ. And you who argue that subtlety is not my strong suite.
Would it have helped your puny brain if I had said "shut up about it"?
I begin to believe that you are unable to deal with context and have to
work in timeless absolutes all the time. The number of times you have
been unable to understand a context and respond as if something I have
said is "The Absolute Truth" regardless of what we are talking about has
been a source of irritation for a long time. I think it is something you
are not aware of and cannot help avoiding, but it can be cured if at
least you would _listen_ to somebody other than yourself for _once_.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1304020856390001@192.168.1.50>
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> Oh, christ. And you who argue that subtlety is not my strong suite.
*Understanding* subtlety from other people is not your strong suit (as is
evidenced by my having to explain this very point).
I must confess, though, that in your writings you are a master of
subtlety. Take my new favorite example:
> You are just an annoying idiot
Now there is a subtlety that I can only dream of aspiring to.
I not in passing that despite the fact that you're constantly exhorting me
to "shut up" about personal issues and stick with the technical, that in
the last few responses that you've written to me you have deleted all the
technical content and chosen to respond only to the personal. So you see,
Erik, the problem here isn't me, it's you. I hate getting into these
personal discussions and would much rather stick with technical issues.
But you simply refuse to engage me in a technical discussion, and you also
refuse to take your own very sound advice and simply ignore me. I find
this genuinely puzzling. I can't for the life of me imagine what it is
that you're really hoping to achieve.
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3227731039017412@naggum.net>
* Erann Gat
| Now there is a subtlety that I can only dream of aspiring to.
You really _have_ no concept of context. This is quite interesting.
| I not in passing that despite the fact that you're constantly exhorting
| me to "shut up" about personal issues and stick with the technical, that
| in the last few responses that you've written to me you have deleted all
| the technical content and chosen to respond only to the personal.
Because I want you to quit and stay technical. You keep claiming that
you do not want to engage in these things, yet you always _start_ them!
You always have, too, but typically, you think you start shooting at me
in "self-defense" even though you are never under attack, yourself. Such
self-defense by proxy is an _attack_. You have a choice not to attack
me. You consistently fail to exercise that choice and blame _me_ for
your own behavior. That has to stop, too. You keep obsessing about what
I think or say and spend an inordinate amount of time attacking me even
in replies to other people. What is _wrong_ with you?
| So you see, Erik, the problem here isn't me, it's you.
*sigh* Of course, Erann. You actually _believe_ it has to be just one
culprit and it is so vitally important to your psychological well-being
that it not be you that you actually _believe_ you have no responsbility
for your own actions. What makes some people get so screwed up?
The problem is you, whether (you think) it is (also) me or not. Grasp
this and take charge of what you are responsible for, regardless of
whether you think somebody else should do something "first". Just do not
start attacking me or talk about what you think I mean, For when you do,
you always say something insulting, demaning, and just plain wrong that
has to be countered, because you actually have no clue whatsoever what I
think or believe. I am _not_ the monster you have conjured up, so just
quit lying about it, just quit talking _about_ me in ways that I have to
respond to. I would really appreciate if you nutjubs could just quit
obsessing about me and start to take care of yourself and your own needs.
| I hate getting into these personal discussions and would much rather
| stick with technical issues.
SO JUST DO IT, DAMNIT! Take charge of your own miserable existence and
just do what you think is right, you dimwit. How hard can it be?
| But you simply refuse to engage me in a technical discussion,
This is false. When I respond to your techical points, you have a long
track record of not being able to deal with it and to take _everything_
so personally you talk about what you think I mean in unrelated articles.
This is pathological. You thought, paranoidly, that I was talking about
you and that I thought you were a Scheme freak, but I have actually not
said anything of the sort nor to that effect. I am not concerned with
you at all, you irrelevant idiot, but you keep lying about me. You are
an amazingly annoying jerk, not a Scheme freak. Does that help? Can you
_please_ start coping, yet?
| I find this genuinely puzzling. I can't for the life of me imagine what
| it is that you're really hoping to achieve.
You started to attack me exceedingly viciously in order to change my
behavior, but you have lost. I am simply trying to show you how evil you
are. My goal is that you realize that you are responsible for your own
actions in a flash if insight and understand your own role.
In _could_ happen. You _could_ actually realize that if you abstain from
lying about me so much and you abstain from imagining your monsters and
talking about them endlessly, there would be much less abuse here. But
people like you are so goddamn slow to realize what you do that your
almost religious conviction that you do something right by attacking me
that you will probably never understand what you are doing. This is a
peculiar mental illness, but the failure to accept responsibility for
your own situation and do something constructive about it is not just a
problem vis-a-vis me, it is a general problem you have exhibited here for
a long time, quite unrelated to your obvious problems coping with what I
think and say.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1304021629120001@192.168.1.50>
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> Because I want you to quit and stay technical. You keep claiming that
> you do not want to engage in these things, yet you always _start_ them!
Not so. Go back and look how this current conversation started. I wasn't
even talking to you. All I did was cite something you said. You then
butted in with "I can speak for myself..." and the whole thing devolved
from there. I made several attempts to steer the conversation back to
technical matters, but you deleted those passages every time you
responded.
> SO JUST DO IT, DAMNIT!
I'm trying, but what do you expect me to do when you keep responded only
to the non-technical things I say, and don't respond to my technical
questions?
> | But you simply refuse to engage me in a technical discussion,
>
> This is false.
Then prove it. Answer my question.
> | I find this genuinely puzzling. I can't for the life of me imagine what
> | it is that you're really hoping to achieve.
>
> You started to attack me exceedingly viciously in order to change my
> behavior, but you have lost.
OK, I've lost.
> I am simply trying to show you how evil you are.
OK, I'm evil. Can we move on now?
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3227763757063869@naggum.net>
* Erik Naggum
> SO JUST DO IT, DAMNIT!
* Erann Gat
| I'm trying, but what do you expect me to do when you keep responded only
| to the non-technical things I say, and don't respond to my technical
| questions?
_Are_ you really that stupid? Take hint: Do not post any "non-technical"
crap about me to begin with, and I cannot respond to it. How fucking
hard can this _be_? I respond to your technical questions when you
actually managed to stay clear of your insane ranting about me. You, who
are so hell-bent on going back to check, obviously never even _see_ this.
I really wonder how someone can get so screwed up as you are that you
cannot even manage to focus on your _own_ goals, any more. Unless, that
is, your _only_ goal is to "feel good", in which case you need to see
someone who can do something about that and just stop posting.
| OK, I'm evil. Can we move on now?
I _have_ moved on, Erann. This is all up to you. Quit attacking me.
Quit talking about what I think or believe. It really is that simple.
Why can you not figure this out?
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1404021005490001@192.168.1.50>
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> Quit attacking me.
I don't believe I am. But if you could be more specific about what I've
said that you consider an attack then I will try to be more careful in the
future.
> Quit talking about what I think or believe.
Talking about what others think is an inherent part of academic
discourse. You need to realize that just because someone talks about your
views doesn't mean that you are under attack. If your views are being
misrepresented (which seems hardly possible in this case since all I've
done is cite direct quotes from your postings) the appropriate response is
to clarify your views, not to insist that people stop talking about them,
or to call them idiots.
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3227801257185736@naggum.net>
* Erik Naggum
> Quit attacking me.
* Erann Gat
| I don't believe I am.
So there is no hope for a less hostile, more intelligent Erann Gat who
actually manages to focus on the technical, and we can only expect more
disillusioned whining and destructive rhetoric and context-free quoting
and idiotic attacks that only tell us you refuse to grow a clue. OK.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1404021900500001@192.168.1.50>
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * Erik Naggum
> > Quit attacking me.
>
> * Erann Gat
> | I don't believe I am.
>
> So there is no hope...
That is entirely up to you. As long as you refuse to tell me what I've
said that you perceive as an attack there's nothing I can do about it.
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3227859937198450@naggum.net>
* Erik Naggum
> So there is no hope...
* Erann Gat
| That is entirely up to you.
Q.E.D.
Just take charge of your own life, now. Think for yourself. Here is a
book suggestion for you: ISBN 0-312-28118-8. Think about yourself,
_only_, when you read it. And _please_ figure out this context thing.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1504020802240001@192.168.1.50>
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> Here is a book suggestion for you: ISBN 0-312-28118-8.
The book Erik is recommending here is "Choosing Civility : The Twenty-Five
Rules of Considerate Conduct."
So here's a reading suggestion for you, Erik: "The Emperor's New Clothes"
by Hans Christian Anderson. Pay particular attention to the following
passage:
"We are two very good tailors and after many years of research we have invented
an extraordinary method to weave a cloth so light and fine that it looks
invisible. As a matter of fact it is invisible to anyone who is too stupid and
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
incompetent to appreciate its quality."
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> And _please_ figure out this context thing.
I guess I'm just too stupid and incompetent to see it. Perhaps you should
explain it to me again?
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3227890203073277@naggum.net>
* Erann Gat
| Perhaps you should explain it to me again?
Erann, go see a shrink. And try to _read_ the book I suggested to you in
good faith and spirit, instead of thinking it was just another bit of
insult hurled your way. Your problems with me in all in your own mind.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * Erann Gat
> | Perhaps you should explain it to me again?
>
> Erann, go see a shrink. And try to _read_ the book I suggested to you in
> good faith and spirit, instead of thinking it was just another bit of
> insult hurled your way. Your problems with me in all in your own mind.
No, Erik, my problems with you are all you *your* mind. You think I'm
attacking you. I'm not. You think I interpreted your book recommendation
as "just another bit of insult." I didn't.
The only reason we're having this discussion is that I would like to
understand what I said that you perceived as an attack. But you refuse to
tell me.
I would much prefer to drop this whole thing and go back to talking about
whether using symbols instead of keywords is a good idea or not, but you
refuse to do that too.
Instead you waste everyone's time by offering me psychological advice.
Just stop it and get back to Lisp. And if you can't do that, then take
your own advice and just ignore me. After all, according to you I'm just
an annoying idiot. Why don't you do everyone a favor and killfile me?
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3227997190323124@naggum.net>
* Erann Gat
| I would much prefer to drop this whole thing and go back to talking about
| whether using symbols instead of keywords is a good idea or not, but you
| refuse to do that too.
SO JUST DO IT! What is hell _wrong_ with you, man? You cannot even do
what you "would much prefer" if somebody else manages to derail you, and
more than that: you seem to seek _excuses_ to get derailed to begin with.
ERANN GAT! SNAP OUT OF IT! JUST DO WHAT YOU WOULD MUCH PREFER TO DO!
But the _reason_ you do not do this is that you are lying about what you
would much prefer. You say that only to blame me for your own problems.
I do not wish to engage you in debate, Erann Gat, because you are clearly
clinically insane. I only want you to stop obsessing about me, which
includes, but is not limited to, your talking about me, attacking me,
harrassing me, and making me and my person more important than anything
you could possibly have done in a public forum by virtue of switching to
discuss me at every goddamn opportunity.. That you cease and desist is
evidently too much to ask, but I still want to make it clear to you that
you have a choice. If you just shut the fuck up about me, I shall in turn
endeavor ro refrain from commenting on your idiotic drivel and flamebait
in any other context, but you, like everybody else in any public forum,
have a moral obligation to be intelligent and I cannot guarantee that you
will be free to spout any dis- or misinformation you want. Your ability
to accept criticism of any kind without taking it personally is _absent_,
but this does not mean that you will be free to continue to lie or give
false testimony or misrepresent other people. I shall endeavor to wait
for others to correct your numerous blunders and misunderstandings, but
if none point them out in a timely fashion, I shall have to correct them
even though I fully expect you go to bananas when I do, no matter how I
phrase or present the criticism or "disagreeing" position. Your ability
to take part in any intellectually relevant discussion seems to have been
extinguished by forces unknown, having been replaced by an uncanny taste
for drivel and pointless, antagonistic quibbling and other trolling, but
while massively annoying to any reader of this forum with a real interest
in any (real) Lisp, those who seek real information will not be hampered
in their search as long as you avoid outright dis- and misinformation.
| Instead you waste everyone's time by offering me psychological advice.
Yes, I am sure it wasted on you. But you _seriously_ need it. The fact
that you cannot even do what you claim you "would much prefer" to do when
this is all up to you -- it really is -- is a _very_ clear indication of
mental problems. In general, blaming others for one's own behavior is a
solid indication that the person in question is permanently out to lunch.
| Just stop it and get back to Lisp. And if you can't do that, then take
| your own advice and just ignore me.
*laugh*� What was that about taking your own advice? Geez, you who are
so _unintelligent_ that you "*ROTLFMAO*" when you cannot figure out that
I told you to shut up about one thing and actually discuss what you
wanted to discuss at the same time, you are actually such a monstrously
retarded fool that you manage to write those two sentences in a row.
"Look what he made me do!" does not really work in the real world, Erann.
| After all, according to you I'm just an annoying idiot. Why don't you do
| everyone a favor and killfile me?
Because you spend so much of your time lying about me and attacking me in
unrelated articles and threads. When I do try to respond to some feeble-
minded and confused technical points you try to make, you go _ballistic_
and start lying about me to other people. It is so obvious that you are
clinically insane that all I can hope for is that somebody who is still
close to you may actually make the effort to talk you out of this.
Please seek help, Erann. Talk to someone who you _would_ listen to. Get
help to get out of the rut you have driven yourself into.
The only positive effect of all this is that I get a better understanding
of the Middle East conflicts and why those whole nations of nutjobs have
to continue the way they have for hundreds if not thousands of years. It
would be a goddamn _miracle_ if you could stop your stupid hostilities in
less than 500 years, but there is always hope that you can grow a clue.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1604022253480001@192.168.1.50>
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * Erann Gat
> | I would much prefer to drop this whole thing and go back to talking about
> | whether using symbols instead of keywords is a good idea or not, but you
> | refuse to do that too.
>
> SO JUST DO IT!
Actually, I am. Kent and I are carrying on a discussion on this very
topic in another thread.
I keep trying to steer this thread back onto a technical track, and you
keep derailing me.
Here, I'll try it again: you wrote: "Using symbols to name things is the
Common Lisp way and using values directly is the Scheme way." or some
such thing. It's late and I don't feel like looking up the exact quote.
Based on your voluminous rants against Scheme I presume that you feel that
"the Common Lisp way" i.e. using symbols to name things (as opposed to
using keywords to name things) is better. Why?
> I do not wish to engage you in debate, Erann Gat,
Then why do you do it? (That's a rhetorical question by the way.)
> In general, blaming others for one's own behavior is a
> solid indication that the person in question is permanently out to lunch.
I agree. You really should read what you write. Sometimes it makes a lot
of sense.
> Because you spend so much of your time lying about me and attacking me in
> unrelated articles and threads.
We can keep going around and around on this as long as you want. Every
time you accuse me of attacking you my response will be the same: where?
What have I said that you perceive as an attack?
> The only positive effect of all this is that I get a better understanding
> of the Middle East conflicts and why those whole nations of nutjobs have
> to continue the way they have for hundreds if not thousands of years.
Funny, I was just thinking the same thing.
You know, my grandparents live in Israel. They are ninety five years old,
and they have known more war than peace in their lives. They were
children in Germany during World War I. They had to flee to Palestine as
young adults in the thirties. (My grandfather didn't even know that he
was a Jew until the Gestapo knocked on his door and told him so.) And now
they are stuck there because a bunch of religious nuts are intent on
blowing each other up and they are too old and feeble to get out now. It
makes me sick.
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3228035448841195@naggum.net>
* Erik Naggum
> SO JUST DO IT!
* Erann Gat
| Actually, I am.
Then what _is_ the problem? My God, you are _such_ an asshole.
| Kent and I are carrying on a discussion on this very topic in another
| thread.
You mean the one in which Kent is visibly exasperated by your blockheaded
stupidity and writes "You don't understand what I said."? It looks to me
like Kent is trying to make you think, but you are only playing quibbling
games with him and toying with his words in return. Watching this weird
exchange with Kent that you refer to as a discussion is one good reason
_not_ to engage you in debate, because you do in fact not grasp anything.
| I keep trying to steer this thread back onto a technical track
Really. If you were not lying even to yourself, you would try something
different if you failed to achieve your goals in the way you act, but you
either keep lying or keep failing to get the simple point that has been
laid out for you: Just start to think. I believe you no longer can, but
I keep trying to make you want to show some evidence that you do.
> I do not wish to engage you in debate, Erann Gat,
| Then why do you do it?
Erann, this may come as a shock to you, but "debate" is more than two
guys talking. You probably had a "debate team" at school or you have at
least seen people on TV engage in debate. It is an intellectual exchange
that requires intelligence at work on both sides, also in the audience.
Your intelligence has not been at work for a _long_ time as far as your
output can be the evidence. All you do is hold up your super-hero
deflector shield and produce such fantastically stupid things like this:
| I agree. You really should read what you write. Sometimes it makes a
| lot of sense.
Your failure to grasp _anything_ people say to you if you can find _some_
way to turn it around is monumentally annoying, but I think you are just
too fucking stupid to understand it. Playing a game like that may be fun
for a few minutes, but doing it for months and _years_ must be evidence
of some serious mental problems.
| Funny, I was just thinking the same thing.
Of course you were, Erann. Of course you were.
Seek treatment. Tell your doctor that I made you visit him and that you
are really seeking treatment for me. Any good doctor will understand.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1704020724070001@192.168.1.50>
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * Erik Naggum
> > SO JUST DO IT!
>
> * Erann Gat
> | Actually, I am.
>
> Then what _is_ the problem?
As far as I'm concerned there is no problem. But according to you the
problem is that I'm attacking you.
E.
From: Erik Naggum
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3228066694486708@naggum.net>
* Erann Gat
| I would much prefer to drop this whole thing and go back to talking about
| whether using symbols instead of keywords is a good idea or not [...]
* Erik Naggum
> SO JUST DO IT!
* Erann Gat
| Actually, I am.
* Erik Naggum
> Then what _is_ the problem?
* Erann Gat
| As far as I'm concerned there is no problem. But according to you the
| problem is that I'm attacking you.
And _this_ is what prevents you from doing what you would much prefer to
do??? Erann, you are more than just sick. Seek help and treatment now.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> * Erann Gat
> | I would much prefer to drop this whole thing and go back to talking about
> | whether using symbols instead of keywords is a good idea or not [...]
>
> * Erik Naggum
> > SO JUST DO IT!
>
> * Erann Gat
> | Actually, I am.
>
> * Erik Naggum
> > Then what _is_ the problem?
>
> * Erann Gat
> | As far as I'm concerned there is no problem. But according to you the
> | problem is that I'm attacking you.
>
> And _this_ is what prevents you from doing what you would much prefer to
> do???
Well, yes and no. Actually nothing is preventing me from doing what I
prefer to do. But since you said I was attacking you and I didn't think I
was I would like to know what you perceived as an attack so that I can
refrain from "attacking" you in the future.
> Erann, you are more than just sick. Seek help and treatment now.
More than just sick? Goodness, this sounds serious. Whom should I seek
help and treatment from? Do I need a medical doctor? A psychiatrist?
Freudian or Jungian? Perhaps I should try RBT, or maybe I just need to
find religion. Should I try rebirthing therapy? What about herbal
remedies? Homeopathy? Accupuncture?
And when I seek help and treatment, what exactly should I tell them is the
matter? "There's this guy in Norway who said I need help, though I'm not
sure exactly why. He thinks I'm attacking him, but he won't tell me what
I've done that makes him think so."
Come to think of it, that might not be such a bad idea. My therapist and
I will both get a good laugh.
E.
From: Christopher C. Stacy
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <uads1lm89.fsf@grant.org>
>>>>> On Wed, 17 Apr 2002 14:42:27 -0700, Erann Gat ("Erann") writes:
Erann> More than just sick? Goodness, this sounds serious. Whom should I seek
Erann> help and treatment from? Do I need a medical doctor? A psychiatrist?
Erann> Freudian or Jungian? Perhaps I should try RBT, or maybe I just need to
Erann> find religion. Should I try rebirthing therapy? What about herbal
Erann> remedies? Homeopathy? Accupuncture?
Perhaps you need to clear your bits of body lambda's.
On Wed, 17 Apr 2002 14:42:27 -0700,
Erann Gat <···@jpl.nasa.gov> wrote:
>
> More than just sick? Goodness, this sounds serious. Whom should I seek
> help and treatment from? Do I need a medical doctor? A psychiatrist?
> Freudian or Jungian? Perhaps I should try RBT, or maybe I just need to
> find religion. Should I try rebirthing therapy? What about herbal
> remedies? Homeopathy? Accupuncture?
M-x doctor
:-)
s.
On Tue, 16 Apr 2002, Erann Gat wrote:
[snip]
> Here, I'll try it again: you [Erik] wrote: "Using symbols to name
> things is the Common Lisp way and using values directly is the Scheme
> way." or some such thing. It's late and I don't feel like looking up
> the exact quote. Based on your voluminous rants against Scheme I
> presume that you feel that "the Common Lisp way" i.e. using symbols to
> name things (as opposed to using keywords to name things) is better.
> Why?
[snip]
Hmm. I don't see why you make that presumption on that basis. It seems to
me that the problem seen with Scheme is its ecology (to use Kent's term).
This might seem to change the question, "In what circumstances/for what
tasks are using symbols rather than keywords better?"
But this too, seems misleading. For just about any example, especially
contrived ones, you'll be able to say, "Oh, but that's doable by...",
which may be true. But that doesn't tell you of the impact on some
people's general understanding of their problem having the choice to use
symbols rather than keywords makes. It's even harder to present the impact
of being embedded in a culture where that choice is prominent vs. one
where it's forbidden. Indeed, choosing one way or another with likely
communicate something, justify other choices, etc.
I offer two examples, that are merely straw examples, but might help. Take
static typing vs. dynamic typing. Given sufficently powerful type
systems/compilers, the marginal gains in, say, performance will be often
negligable (especially if you have optional type annotations).
Restrictions on expressivity (in the sense of classes of programs that are
legal) can be minimized (e.g., with polymorphic types). And, of course,
both sides agree that being able to find and express the best alogrithms
is the best way toward clarity and performance. But dynamic typers find
mandatory type delcarations a burden that frustrates and binds them to
little good end. Whereas static typers find that much of their programming
just *is* type design. So, 1) there are real tradeoffs, 2) much of the
apprent differences can be elided in various ways, and 3) yet there are
*huge* ecological differences. CL type annotations point to one version of
a middle ground.
Take having a MOP and having the implementation of your object system
available. (Roughly, CL vs. Smalltalk, or better, vs. Python). Of course,
you can simulate all sorts of relations (containment) for example, by
adding dictionaries to slots and building in your own
dispatcher. Sometimes that's *just* what you want and works well. But
often, over time, it gets hairier and hairier and you actually forgo
possible improvements, etc. You might find that a MOP-centered culture
considers things differently, and communicates the structure of problem
states in a "better" manner. Sure, you can always do this with
dictionaries, but the feel is very different.
Perhaps modules are another example. See Kent's response to your
"request" for T Modules in CL.
Cheers,
Bijan Parsia.
···@jpl.nasa.gov (Erann Gat) writes:
> In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
>
> > Because I want you to quit and stay technical. You keep claiming that
> > you do not want to engage in these things, yet you always _start_ them!
>
> Not so. Go back and look how this current conversation started. I wasn't
> even talking to you. All I did was cite something you said. You then
> butted in with "I can speak for myself..." and the whole thing devolved
> from there. I made several attempts to steer the conversation back to
> technical matters, but you deleted those passages every time you
> responded.
Since you cite very often out of context, your citations are usually
quite annoying provocations.
With respect to my lost time, you intelligent trollers (Bushnell,
BSG[1] is the second one that comes to my mind) are a much larger
annoyance than Thaddeus L Olczyk, Israel Ray Thomas, or some anonymous
Dr. X ("Hi, is this the Disco here?") who are so obviously stupid that
they are more or less ignored by everyone. I guess that to get
reasonably rid off you, I will avoid reading the whole threads you
provoke (starting from your message, of course) in the future.
Bye, Nicolas.
[1] What does BSG mean, by the way?
[2] I hope that I manage to set up Gnus appropriately. Any tips are
gratefully accepted...
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1404020952330001@192.168.1.50>
In article <··············@ortler.iwr.uni-heidelberg.de>, Nicolas Neuss
<·············@iwr.uni-heidelberg.de> wrote:
> ···@jpl.nasa.gov (Erann Gat) writes:
>
> > In article <················@naggum.net>, Erik Naggum
<····@naggum.net> wrote:
> >
> > > Because I want you to quit and stay technical. You keep claiming that
> > > you do not want to engage in these things, yet you always _start_ them!
> >
> > Not so. Go back and look how this current conversation started. I wasn't
> > even talking to you. All I did was cite something you said. You then
> > butted in with "I can speak for myself..." and the whole thing devolved
> > from there. I made several attempts to steer the conversation back to
> > technical matters, but you deleted those passages every time you
> > responded.
>
> Since you cite very often out of context, your citations are usually
> quite annoying provocations.
Here's the passage in question:
But in general, using symbols to name things is the (Common) Lisp way,
and using the values directly is the Scheme way.
and the context can be found at
http://groups.google.com/groups?selm=3227419925997748%40naggum.net&output=gplain
I'm sorry, but I really don't see how citing that can be considered a
provokation. Perhaps you would be so kind as to explain it to me?
> [1] What does BSG mean, by the way?
STFW. Brotherhood of Saint Gregory.
E.
From: Eduardo Muñoz
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <uk7raj6sl.fsf@jet.es>
···@jpl.nasa.gov (Erann Gat) writes:
> > Since you cite very often out of context, your citations are usually
> > quite annoying provocations.
>
> Here's the passage in question:
NO, the passage in question is this:
http://groups.google.com/groups?selm=gat-1204021042320001%40192.168.1.50&output=gplain
(Erann Gat writes:)
Well, according to Erik, it marks me as doing things the "Scheme way". Of
course, Erik, also distinguishes between "Scheme is a Lisp" and "Scheme is
a member of the Lisp family of languages", so maybe "writing Scheme in CL"
and "doing things the Scheme way [in CL]" don't mean the same thing
either.
When you're talking about something that you do,
believe or think (or whatever) why do you need to
bring someone else opinion about it?.
This is a technical forum. It goes like this:
1 You ask a question
2 Get an answer (if lucky)
3 You study the answer assuming it's right
4 Ask for clarification if needed
5 Repeat
Don't need to imagine or talk or whine about other
people opinion or thinking.
--
Eduardo Mu�oz
From: Erann Gat
Subject: Re: The Common Lisp Way (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <gat-1404021848100001@192.168.1.50>
In article <·············@jet.es>, "Eduardo =?iso-8859-1?q?Mu=F1oz?="
<···@jet.es> wrote:
> ... why do you need to bring someone else opinion about it?.
Because that's the subject of my question.
E.
"Erann Gat" <···@jpl.nasa.gov> wrote in message
·························@192.168.1.50...
> So you see, Erik, the problem here isn't me, it's you.
This is the one thing nobody has ever been able to get across to him, so I
am afraid you are wasting your time (even though eliciting some funny
reading along the way).
If you don't want to be bothered, do as I did. Kill files are a very
useful way to excercise ones option not to read stuff that would waste ones
time.
--
Biep
Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote in message
···················@ID-63952.news.dfncis.de...
> "Erann Gat" <···@jpl.nasa.gov> wrote in message
> ·························@192.168.1.50...
> > So you see, Erik, the problem here isn't me, it's you.
>
> This is the one thing nobody has ever been able to get across to him, so I
> am afraid you are wasting your time (even though eliciting some funny
> reading along the way).
>
> If you don't want to be bothered, do as I did. Kill files are a very
> useful way to excercise ones option not to read stuff that would waste
ones
> time.
>
Starting a brand new thread out of flames that died down a long time ago is
a good way to get people to exercise their kill file option and a bad usenet
post.
--
Coby Beck
(remove #\Space "coby 101 @ bigpond . com")
"Coby Beck" <·····@mercury.bc.ca> wrote in message
·······················@news3.calgary.shaw.ca...
> Starting a brand new thread out of flames that died down a long time ago
> is a good way to get people to exercise their kill file option
> and a bad usenet post.
Oops! Your are right. I have been away for a long time, and forgot to
check the dates on the articles. It just seemed one of the posts in the
(still active) thread.
Sorry!
--
Biep
* "Biep @ http://www.biep.org/" <·········@my-web-site.com>
| If you don't want to be bothered, do as I did.
Yeah, do as you do, be a fucking moron. We sure need more of your kind.
Dickweed like you _always_ show up when the show is over, and _always_ to
attack me completely out of the blue. What is _wrong_ with you?
I sure am glad you have put me in your killfile, so I do not have to read
your retarded response. How the world needs to get rid of you idiots!
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum schrieb:
> * Erann Gat
cl, cl, cl, cl,
scheme, scheme, scheme
- It is boring.
- It is all the same story.
- It fills up some threads to the endless ...
So isn't it possible to creat an extra news-group with
cl vs scheme
or
scheme vs cl
*?*
Or what is it to combine schemes-best-sides with clisp-best-sides and
create a new lisp-dialekt ?
(make produce (E E)
(sit-down
(take (* knowledge 2 &rest))
kitchen-corner)
(handler-bind ((#'flame-power))
((#'time-wasted))
&rest @forms)
(format *news-group-output* "~&~A~&" condition))
(�_�)
_____________________________________
/ \
E&E Lisp
- it is no scheme, it is no clisp -
\_____________________________________/ TM
Sounds good, eh ?
We all need this, we will use this and pay nothing, right ?
(but these threads are more read-worth, I guarantee).
Also think about this:
You will mark a top-hill in the history of Lisp -
(if necessary (for historical reasons) let it only run on transparent
macs
(including some symbolix routines for future extensions))
... and so you could do something the world has never seen before ...
Oh and please, take this posting with a smile.
stefan
In article <····················@192.168.1.50>,
···@jpl.nasa.gov (Erann Gat) wrote:
> Here's the relevance it has to me: in exploring the surprising (to me)
> affinity that people have for packages, I discovered that there is a whole
> style of programming (which is called here "symbolic programming") of
> which I was only dimly aware
I may be wrong, but I think I picked up a fine distinction between
"symbolic programming" (which is pretty much any non-numeric
programming, done in any language), and "symbol programming", which is
specifically the passing around of CL symbols (which live in packages,
and have function and value slots and property lists).
-- Bruce
Bruce Hoult <·····@hoult.org> writes:
> I may be wrong, but I think I picked up a fine distinction between
> "symbolic programming" (which is pretty much any non-numeric
> programming, done in any language),
Erm, then would programming using just characters as values be
symbolic programming? No. I have no clue how you picked up this
misconception, but symbolic programming is programming using symbols
as data.
> and "symbol programming", which is specifically the passing around
> of CL symbols (which live in packages, and have function and value
> slots and property lists).
"Symbol programming" is a term I've never seen before. Not only does
it sound funny, it implies nothing to do with CL...
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
> Bruce Hoult <·····@hoult.org> writes:
>
> > I may be wrong, but I think I picked up a fine distinction between
> > "symbolic programming" (which is pretty much any non-numeric
> > programming, done in any language),
>
> Erm, then would programming using just characters as values be
> symbolic programming? No. I have no clue how you picked up this
> misconception, but symbolic programming is programming using symbols
> as data.
What is a "symbol" according to you?
"Symbolic programming" is a rather broad term which is generally used
to contrast with "numeric programming".
> > and "symbol programming", which is specifically the passing around
> > of CL symbols (which live in packages, and have function and value
> > slots and property lists).
>
> "Symbol programming" is a term I've never seen before. Not only does
> it sound funny, it implies nothing to do with CL...
He (Bruce) made that term up to emphasize the fine line that he is
detecting. Right, Bruce?
--
-Matthias
Matthias Blume <········@shimizu-blume.com> writes:
> Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
> > Erm, then would programming using just characters as values be
> > symbolic programming? No. I have no clue how you picked up this
> > misconception, but symbolic programming is programming using symbols
> > as data.
> What is a "symbol" according to you?
A data object that has some name and that name is what identifies that
object. Namespaces are, of course, needed for practical concerns.
> "Symbolic programming" is a rather broad term which is generally used
> to contrast with "numeric programming".
What is object-oriented programming then?
Are you claiming that using any data that is not purely (structures
of) numbers is symbolic?
> > "Symbol programming" is a term I've never seen before. Not only does
> > it sound funny, it implies nothing to do with CL...
> He (Bruce) made that term up to emphasize the fine line that he is
> detecting. Right, Bruce?
There's no fine line, that I can see.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
In article <··············@photino.sid.rice.edu>, Rahul Jain
<·····@sid-1129.sid.rice.edu> wrote:
> Matthias Blume <········@shimizu-blume.com> writes:
>
> > Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
>
> > > Erm, then would programming using just characters as values be
> > > symbolic programming? No. I have no clue how you picked up this
> > > misconception, but symbolic programming is programming using symbols
> > > as data.
>
> > What is a "symbol" according to you?
>
> A data object that has some name and that name is what identifies that
> object. Namespaces are, of course, needed for practical concerns.
You didn't say anything about names having to be strings, nor that the
name->symbol map be accessible during the parsing process. On a strict
reading of this definition, if I define a class with a "name" slot, and
make an index that allows me to retrieve instances of the class according
to the value of the name slot (analogous to a package), then those
instances are symbols. So, for example, I could make "symbols" whose
names were, say, jpg images, or numbers, or other "symbols". Was that
your intent? (If so, then I'm doing symbol[ic] programming after all.
Whee! ;-)
E.
···@jpl.nasa.gov (Erann Gat) writes:
> You didn't say anything about names having to be strings, nor that the
> name->symbol map be accessible during the parsing process. On a strict
> reading of this definition, if I define a class with a "name" slot, and
> make an index that allows me to retrieve instances of the class according
> to the value of the name slot (analogous to a package), then those
> instances are symbols.
Well... those are all useful in making the concept practical, and the
"name" slot simply gives a concrete representation of the name, the
symbol itself IS the name/identifier.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
> Well... those are all useful in making the concept practical, and the
> "name" slot simply gives a concrete representation of the name,
Let me just check if I got this right:
You wrote, answering the question of "what is a symbol":
A data object that has some name and that name is what identifies that
object.
Now you write:
[ ... ] the symbol itself IS the name/identifier.
Taken together, this gives:
[A symbol is] a data object that has itself and [it] itself is what
identifies [it].
Sounds like "symbols" could be about anything...
Matthias
Matthias Blume <········@shimizu-blume.com> writes:
> Let me just check if I got this right:
>
> You wrote, answering the question of "what is a symbol":
>
> A data object that has some name and that name is what identifies that
> object.
This name is only used for communicating to the user what symbol is
being referred to.
> Now you write:
>
> [ ... ] the symbol itself IS the name/identifier.
>
> Taken together, this gives:
>
> [A symbol is] a data object that has itself and [it] itself is what
> identifies [it].
Yes, if you ignore the context and try to play word games, that can
happen.
> Sounds like "symbols" could be about anything...
Symbols are objects that are used as uniqified identifiers... symbolic
identifiers.
What do YOU define symbols to be?
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
> Symbols are objects that are used as uniqified identifiers... symbolic
> identifiers.
Aha, symbols are symbolic identifiers. What is a symbolic identifier?
(In my code, I often use small integers as unique identifiers. Are
small integers symbols? You might say they are not "symbolic", but
then, what *is* "symbolic" according to you?)
> What do YOU define symbols to be?
I don't know. That's why I am asking. Given that symbols seem to be
such a fundamental and important concept around here, one should
be able to expect that there is a widely agreed-upon, precise
definition for that concept.
Matthias
In article <··············@photino.sid.rice.edu>,
Rahul Jain <·····@sid-1129.sid.rice.edu> wrote:
> > Sounds like "symbols" could be about anything...
>
> Symbols are objects that are used as uniqified identifiers... symbolic
> identifiers.
>
> What do YOU define symbols to be?
That's how I would define symbols, but apparently that is the false
Scheme definition, not the Common Lisp one, and corresponds only to
"keywords" in CL.
-- Bruce
Bruce Hoult wrote:
> In article <··············@photino.sid.rice.edu>,
> Rahul Jain <·····@sid-1129.sid.rice.edu> wrote:
>
>> > Sounds like "symbols" could be about anything...
>>
>> Symbols are objects that are used as uniqified identifiers... symbolic
>> identifiers.
>>
>> What do YOU define symbols to be?
>
> That's how I would define symbols, but apparently that is the false
> Scheme definition, not the Common Lisp one, and corresponds only to
> "keywords" in CL.
Why does the above sentence only apply to CL keywords?
Are symbols in other packages not unique or not usable as identifiers?
ciao,
Jochen
--
http://www.dataheaven.de
Matthias Blume wrote:
> Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
>
>> Well... those are all useful in making the concept practical, and the
>> "name" slot simply gives a concrete representation of the name,
>
> Let me just check if I got this right:
Let me just quote the Common Lisp HyperSpec:
In the description of the system class SYMBOL you can find the following
sentence:
"Symbols are used for their object identity to name various entities in
Common Lisp, including (but not limited to) linguistic entities such as
variables and functions."
Matthias Blume wrote (quoting Rahul):
> You wrote, answering the question of "what is a symbol":
The above quote would be an appropriate answer to that question.
Rahul wrote:
> A data object that has some name and that name is what identifies that
> object.
This is a correct statement. Probably with the addition "In the context of
a package in that this symbol is accessible."
Matthias Blume wrote (quoting Rahul):
> Now you write:
>
> [ ... ] the symbol itself IS the name/identifier.
This is a correct statement too. The symbol is uniquely identified and can
therefore serve as an identifier for another thing (by building up the
needed relations).
Matthias Blume now concludes:
> Taken together, this gives:
>
> [A symbol is] a data object that has itself and [it] itself is what
> identifies [it].
This is complete (constructed) nonsense. The first sentence talked about
the possibility to find a particular symbol by a name and the second
sentence talked about using the uniqueness of this symbol to name/identify
other things (and obviously even the symbol itself).
Jochen Schmidt
--
http://www.dataheaven.de
Jochen Schmidt <···@dataheaven.de> writes:
> Matthias Blume wrote:
>
> > Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
> >
> >> Well... those are all useful in making the concept practical, and the
> >> "name" slot simply gives a concrete representation of the name,
> >
> > Let me just check if I got this right:
>
> Let me just quote the Common Lisp HyperSpec: [ ... ]
I did not want to know what I Common Lisp symbol is. I already know
that. I wanted to know what the general concept of "symbol" is,
according to Rahul.
> This is complete (constructed) nonsense. The first sentence talked about
> the possibility to find a particular symbol by a name and the second
> sentence talked about using the uniqueness of this symbol to name/identify
> other things (and obviously even the symbol itself).
But even that is still extremely vague as even numbers have those properties.
Basically, my point is that "symbols" can, indeed, be just about
anything, and "symbolic programming" can be done in just about any
language. Lisp's "symbol" type is in no way necessary for that.
Matthias
Matthias Blume wrote:
>> This is complete (constructed) nonsense. The first sentence talked about
>> the possibility to find a particular symbol by a name and the second
>> sentence talked about using the uniqueness of this symbol to
>> name/identify other things (and obviously even the symbol itself).
>
> But even that is still extremely vague as even numbers have those
> properties.
>
> Basically, my point is that "symbols" can, indeed, be just about
> anything, and "symbolic programming" can be done in just about any
> language. Lisp's "symbol" type is in no way necessary for that.
That is easy to say because Goedel already showed long time ago that you
can encode mathematical entities by numbers ("Goedelisierung"). But this is
the same kind of discussion as those "Turing-Equvialence" discussions to
compare languages.
You can probably agree that it is possible to program objectoriented in
languages like C but that the paradigm is much more useful if the language
_supports_ the right language facilities.
ciao,
Jochen
--
http://www.dataheaven.de
Jochen Schmidt <···@dataheaven.de> writes:
> Matthias Blume wrote:
>
> > But even that is still extremely vague as even numbers have those
> > properties.
> >
> > Basically, my point is that "symbols" can, indeed, be just about
> > anything, and "symbolic programming" can be done in just about any
> > language. Lisp's "symbol" type is in no way necessary for that.
>
> That is easy to say because Goedel already showed long time ago that you
> can encode mathematical entities by numbers ("Goedelisierung"). But this is
> the same kind of discussion as those "Turing-Equvialence" discussions to
> compare languages.
I was not talking about Geodel numberings. Forget numbers. Strings,
to name another example, can be used as symbols as long as you don't
look at the contents but only compare for equality. It is not a very
good (because expensive) way of doing symbols, but it would work.
> You can probably agree that it is possible to program objectoriented in
> languages like C but that the paradigm is much more useful if the language
> _supports_ the right language facilities.
Der Vergleich hinkt.
As far as symbolic programming is concerned, many languages, including
quite a few that do not have a built-in symbol type like Lisp's, have
excellent support for symbolic programming. In fact, what one really
needs for symbolic programming is good support for algebraic data
structures. Symbols are easy as about any type with an equality
predicate will do. I almost exclusively deal with programs that do
heavy symbolic programming, and many of the "symbols" in these
programs are, indeed, represented by small integers. (Usually, we
hide these concrete representations behind an abstraction boundary so
that incidental (wrt. symbol-ness) properties cannot be exploited, but
with the same amount of discipline that one needs when using Lisp
symbols symbolically, not even that is necessary.)
--
-Matthias
"Matthias Blume" <········@shimizu-blume.com> ha scritto nel messaggio ···················@blume-pcmh.research.bell-labs.com...
> As far as symbolic programming is concerned, many languages, including
> quite a few that do not have a built-in symbol type like Lisp's, have
> excellent support for symbolic programming. In fact, what one really
> needs for symbolic programming is good support for algebraic data
> structures. Symbols are easy as about any type with an equality
> predicate will do. I almost exclusively deal with programs that do
> heavy symbolic programming, and many of the "symbols" in these
> programs are, indeed, represented by small integers. (Usually, we
> hide these concrete representations behind an abstraction boundary so
> that incidental (wrt. symbol-ness) properties cannot be exploited, but
> with the same amount of discipline that one needs when using Lisp
> symbols symbolically, not even that is necessary.)
It may be trivial to remark this, but... one important property of
lisp symbols is the way they interact with the printer/reader.
That is, they are easy to print and read back, while in, say, ML to
be able to do this you have to implement by yourself a mapping
from the external representation to 'symbols'.
This is nothing fundamental, but one shouldn't underestimate the
impact of having available in lisp such a pervasive and trivially
externalizable data structure.
P.
"Pierpaolo BERNARDI" <··················@hotmail.com> writes:
> "Matthias Blume" <········@shimizu-blume.com> ha scritto nel messaggio ···················@blume-pcmh.research.bell-labs.com...
>
> > As far as symbolic programming is concerned, many languages, including
> > quite a few that do not have a built-in symbol type like Lisp's, have
> > excellent support for symbolic programming. In fact, what one really
> > needs for symbolic programming is good support for algebraic data
> > structures. Symbols are easy as about any type with an equality
> > predicate will do. I almost exclusively deal with programs that do
> > heavy symbolic programming, and many of the "symbols" in these
> > programs are, indeed, represented by small integers. (Usually, we
> > hide these concrete representations behind an abstraction boundary so
> > that incidental (wrt. symbol-ness) properties cannot be exploited, but
> > with the same amount of discipline that one needs when using Lisp
> > symbols symbolically, not even that is necessary.)
>
> It may be trivial to remark this, but... one important property of
> lisp symbols is the way they interact with the printer/reader.
> That is, they are easy to print and read back, while in, say, ML to
> be able to do this you have to implement by yourself a mapping
> from the external representation to 'symbols'.
>
> This is nothing fundamental, but one shouldn't underestimate the
> impact of having available in lisp such a pervasive and trivially
> externalizable data structure.
I must add that Java recognized this property (up to a certain point)
and added the `intern' method to `String' (If memory does nto fail me,
it is `intern').
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
···@jpl.nasa.gov (Erann Gat) writes:
> instances are symbols. So, for example, I could make "symbols" whose
> names were, say, jpg images, or numbers, or other "symbols". Was that
> your intent? (If so, then I'm doing symbol[ic] programming after all.
> Whee! ;-)
I don't think the idea of "jpg symbols" is all too far-out. It depends
on the application.
--
(espen)
Rahul Jain <·····@sid-1129.sid.rice.edu> writes:
> > > Erm, then would programming using just characters as values be
> > > symbolic programming? No. I have no clue how you picked up this
> > > misconception, but symbolic programming is programming using symbols
> > > as data.
>
> > What is a "symbol" according to you?
>
> A data object that has some name and that name is what identifies that
> object.
What is a "name"? A string?
> > "Symbolic programming" is a rather broad term which is generally used
> > to contrast with "numeric programming".
>
> What is object-oriented programming then?
Orthogonal concept.
> Are you claiming that using any data that is not purely (structures
> of) numbers is symbolic?
No. The distinction is not absolute, of course. Some numeric
programs have symbolic parts and vice versa.
> > > "Symbol programming" is a term I've never seen before. Not only does
> > > it sound funny, it implies nothing to do with CL...
>
> > He (Bruce) made that term up to emphasize the fine line that he is
> > detecting. Right, Bruce?
>
> There's no fine line, that I can see.
Fair enough. He can.
-Matthias
In article <··············@trex8.cs.bell-labs.com>,
Matthias Blume <········@shimizu-blume.com> wrote:
> > > and "symbol programming", which is specifically the passing around
> > > of CL symbols (which live in packages, and have function and value
> > > slots and property lists).
> >
> > "Symbol programming" is a term I've never seen before. Not only does
> > it sound funny, it implies nothing to do with CL...
>
> He (Bruce) made that term up to emphasize the fine line that he is
> detecting. Right, Bruce?
Right.
btw, the term "symbol processing" *has* been used by people here,
repeatedly, in the past month. Make the distinction between "symbolic
programming" and "symbol processing" if you prefer, but I thought that
"symbol programming" sounded just striking enough to be worth using.
-- Bruce
Espen Vestre <·····@*do-not-spam-me*.vestre.net> writes:
> ···@jpl.nasa.gov (Erann Gat) writes:
>
> > instances are symbols. So, for example, I could make "symbols" whose
> > names were, say, jpg images, or numbers, or other "symbols". Was that
> > your intent? (If so, then I'm doing symbol[ic] programming after all.
> > Whee! ;-)
>
> I don't think the idea of "jpg symbols" is all too far-out. It depends
> on the application.
Not in CL because it's defined not to work this way. But certainly in
the abstract. the fact that i think one doesn't look at the symbol
name is what allows symbol-name to return non-strings.
* ···@jpl.nasa.gov (Erann Gat) wrote:
> Here's the relevance it has to me: in exploring the surprising (to
> me) affinity that people have for packages, I discovered that there
> is a whole style of programming (which is called here "symbolic
> programming") of which I was only dimly aware
I've just learned how to use packages, but I don't mind them, as I
had to learn to work with "packages ala Perl" [Perl modules]
already. :-)
* Bruce Hoult <·····@hoult.org> writes:
> I may be wrong, but I think I picked up a fine distinction between
> "symbolic programming" (which is pretty much any non-numeric
> programming, done in any language), and "symbol programming", which
> is specifically the passing around of CL symbols (which live in
> packages, and have function and value slots and property lists).
I think that "symbolic programming" is not expressed well as
"any non-numeric programming, done in any language".
It seems more accurate to say that "symbolic programming" involves
using symbols to represent arbitrary expressions and then
manipulating those symbols directly as a component of the
computation. Examples of this would include CL macros and
(destructuring-bind ...) forms.
A computation done in terms of symbolic processing would involve
manipulating the expressions themselves from their initial state
into the final state prior to evaluating the expressions for their
value bindings. Symbolic computations may legitimately yield
results which have no value bindings, such as '(/ X 0), since they
do not necessarily evaluate for bindings.
This is not to say that symbols *never* have bindings to values,
but that the symbolic portion of the computation doesn't *care* if
they do or not.
The alternative would appear to be using strings to represent
simple values [i.e. strings as variable value place holder names]
and manipulating the value that the variable represents directly.
Since the value itself is being manipulated at each stage of the
computation, it is not possible for the non-symbolic computation to
yield a result which has no value binding, as attempting to
manipulate an unbound variable yields an error.
It is possible to do symbolic programming in any Turing complete
language, but most of them lack the expressiveness of CL.
-jon
--
------------------
Jon Allen Boone
········@delamancha.org
In article <··············@validus.delamancha.org>,
Jon Allen Boone <········@delamancha.org> wrote:
> * Bruce Hoult <·····@hoult.org> writes:
> > I may be wrong, but I think I picked up a fine distinction between
> > "symbolic programming" (which is pretty much any non-numeric
> > programming, done in any language), and "symbol programming", which
> > is specifically the passing around of CL symbols (which live in
> > packages, and have function and value slots and property lists).
>
> I think that "symbolic programming" is not expressed well as
> "any non-numeric programming, done in any language".
>
> It seems more accurate to say that "symbolic programming" involves
> using symbols to represent arbitrary expressions and then
> manipulating those symbols directly as a component of the
> computation. Examples of this would include CL macros and
> (destructuring-bind ...) forms.
>
> A computation done in terms of symbolic processing would involve
> manipulating the expressions themselves from their initial state
> into the final state prior to evaluating the expressions for their
> value bindings. Symbolic computations may legitimately yield
> results which have no value bindings, such as '(/ X 0), since they
> do not necessarily evaluate for bindings.
This sounds far too narrow a definition to me.
First, why do the symbols need to represent an "expression"? Second,
why do you need to "[evaluate] the expressions for their value bindings".
This sounds like a definition of symbolic mathematics (integration,
differentiation, etc), not of "symbolic programming" in general.
As a counter-example, I would consider the "add-a-gram" puzzle discussed
here a few months ago to be an example of symbolic programming, but it
doesn't fall within your definition.
http://www.itasoftware.com/careers/programmers-archive.php
http://groups.google.com/groups?threadm=Dsp48.41330%24Ln2.9198307%40typho
on.ne.mediaone.net
-- Bruce
* I wrote:
> I think that "symbolic programming" is not expressed well as "any
> non-numeric programming, done in any language".
>
> It seems more accurate to say that "symbolic programming"
> involves using symbols to represent arbitrary expressions and then
> manipulating those symbols directly as a component of the
> computation. Examples of this would include CL macros and
> (destructuring-bind ...) forms.
>
> A computation done in terms of symbolic processing would involve
> manipulating the expressions themselves from their initial state
> into the final state prior to evaluating the expressions for their
> value bindings. Symbolic computations may legitimately yield
> results which have no value bindings, such as '(/ X 0), since they
> do not necessarily evaluate for bindings.
* Bruce Hoult <·····@hoult.org> responds:
>
> This sounds far too narrow a definition to me.
That could be.
> First, why do the symbols need to represent an "expression"?
I'm guessing that "expression" here is a loaded term that has a
meaning for you that I did not intend. Perhaps I should have used
the term "sentence" as it is used in formal logic.
> Second, why do you need to "[evaluate] the expressions for their
> value bindings".
Valid sentences (or expressions) are derived according to a rule
set that determines their structure (or form). You may manipulate
the form of the sentence without determining the value associated
with any particular component of the sentence. In some cases, there
may not be a defined value. Not all valid sentences have inherent
values, although by convention there are some that do.
> This sounds like a definition of symbolic mathematics
> (integration, differentiation, etc), not of "symbolic programming"
> in general.
It's true that there is a mathematical connection, as this is an
attempt to explain my recollection of computational theory. It's
been too long since I reviewed my basics. *sigh*
> As a counter-example, I would consider the "add-a-gram" puzzle
> discussed here a few months ago to be an example of symbolic
> programming, but it doesn't fall within your definition.
>
> http://www.itasoftware.com/careers/programmers-archive.php
I visited this link and the "obvious to me" solution does indeed
involve symbolic computation. I suppose we have a terminology
conflict since I do see that as covered by my definition whereas you
do not. Again, it would seem that the problem hinges on the term
"expression". Is it any better if I say "sentence"?
-jon
--
------------------
Jon Allen Boone
········@delamancha.org
Jon Allen Boone <········@delamancha.org> writes:
> I'm guessing that "expression" here is a loaded term that has a
> meaning for you that I did not intend. Perhaps I should have used
> the term "sentence" as it is used in formal logic.
All computer programs ever do (even the "numerical" ones) is to
manipulate "sentences" in the formal logic sense.
Matthias
* I wrote:
> I'm guessing that "expression" here is a loaded term that has a
> meaning for you that I did not intend. Perhaps I should have used
> the term "sentence" as it is used in formal logic.
and
* Matthias Blume <········@shimizu-blume.com> responds:
>
> All computer programs ever do (even the "numerical" ones) is to
> manipulate "sentences" in the formal logic sense.
I disagree, because I do not consider evaluation to be the same as
manipulation. Consider:
x = 5;
x++;
These are examples of sentences in C. These sentences are not
manipulated. Rather, they are evaluated. The value is manipulated,
but the sentence itself is not.
-jon
--
------------------
Jon Allen Boone
········@delamancha.org
Jon Allen Boone <········@delamancha.org> writes:
> * I wrote:
> > I'm guessing that "expression" here is a loaded term that has a
> > meaning for you that I did not intend. Perhaps I should have used
> > the term "sentence" as it is used in formal logic.
>
> and
>
> * Matthias Blume <········@shimizu-blume.com> responds:
> >
> > All computer programs ever do (even the "numerical" ones) is to
> > manipulate "sentences" in the formal logic sense.
>
> I disagree, because I do not consider evaluation to be the same as
> manipulation. Consider:
>
> x = 5;
> x++;
>
> These are examples of sentences in C. These sentences are not
> manipulated. Rather, they are evaluated. The value is manipulated,
> but the sentence itself is not.
The "sentences" I was talking about are not (necessarily) the same
sentences that your program consists of. They rather represent the
state of the machine. Evaluation *is* manipulation of sentences.
This is best illustrated when looking at minimal (but Turing-complete)
languages such as the pure untyped lambda-calculus. Evaluation there
corresponds to performing enough beta reductions so that a normal form
is reached. In less minimal languages such as C, it is a bit harder
to see what the sentences are that get manipulated. In fact, for
imperative languages this used to be quite a challenge.
I recommend reading a book on programming language semantics to get an
idea of what I am talking about. Here are some that I can think of:
"Semantics of Programming Languages" by C. Gunter
"Theories of Programming Languages" by J. C. Reynolds
"Denotational Semantics: The Scott-Strachey Approach to Programming
Language Theory" by J. E. Stoy
--
-Matthias
Matthias Blume <········@shimizu-blume.com> and I are discussing
the notion that [as he put it]:
> All computer programs ever do (even the "numerical" ones) is to
> manipulate "sentences" in the formal logic sense.
Later, he further responded with:
> The "sentences" I was talking about are not (necessarily) the same
> sentences that your program consists of. [interesting explanation
> deferred]
Which, though interesting, is beside my point.
I will attempt to summarize my point. Regardless of what the
language environment does in the background, I am attempting to
distinguish between two different program text issues that affect
the work that needs to be done by the programmer.
Given a programmer and an original sentence expressed in the
language that the programmer is using:
If the programmer has to transform the sentence into a new form in
order to express the desired computation, this is *not* symbolic
programming in the chosen language.
If the programmer can make use of the programming language itself
to perform the transformation of the sentence into the proper form
that expressed the desired computation, then this *is* symbolic
programming in the chosen language.
So, symbolic programming, to me, is descriptive of the way that
the program itself [as written by the programmer] attempts to solve
the computational problem in the chosen language.
Turing-equivalence yields the result that symbolic programming
could be done in any Turing complete language.
Now, to continue with Matthias' interesting side-line:
> The "sentences" I was talking about are not (necessarily) the
> same sentences that your program consists of. They rather
> represent the state of the machine. Evaluation *is* manipulation
> of sentences.
It's clear to me that I don't fully grasp what your saying so I
will minimize my opportunity for expressing my ignorance by
promising to read at least one of the books you recommend below in
order to obtain a better grasp on your point. :-)
> This is best illustrated when looking at minimal (but
> Turing-complete) languages such as the pure untyped
> lambda-calculus. Evaluation there corresponds to performing enough
> beta reductions so that a normal form is reached. In less minimal
> languages such as C, it is a bit harder to see what the sentences
> are that get manipulated. In fact, for imperative languages this
> used to be quite a challenge.
I can accept your point about how the language environment itself
works. And, I don't disagree with your point in any fundamental
sense, if you are saying that it is possible to view the process of
writing/compiling/executing an arbitrary program as symbolic
programming [at some, possibly very low, level].
However, Bruce Hoult called symbolic programming "all non-numeric
programming" and I seem to recall that the Church-Turing thesis
implies that in a fundamental sense all computation is - in essence
- numeric in nature. Which would imply that symbolic programming is
non-existent.
If I'm not totally off base, it would seem that there is an
inconsistency in the way that the two of you are defining symbolic
programming. In any case, I've chosen my own definition for
pragmatic purposes.
> I recommend reading a book on programming language semantics to get
> an idea of what I am talking about. Here are some that I can think
> of:
>
> "Semantics of Programming Languages" by C. Gunter
>
> "Theories of Programming Languages" by J. C. Reynolds
>
> "Denotational Semantics: The Scott-Strachey Approach to
> Programming Language Theory" by J. E. Stoy
I /will/ read at least one of these, but it will probably have to
wait until I've finished _ANSI Common Lisp_, _On Lisp_,
_Object-Oriented Programming in Common Lisp_ and _The Art of the
Metaobject Protocol_. So, I'm guessing it'll be a while... :-)
-jon
--
------------------
Jon Allen Boone
········@delamancha.org
In article <··············@validus.delamancha.org>,
Jon Allen Boone <········@delamancha.org> wrote:
> > As a counter-example, I would consider the "add-a-gram" puzzle
> > discussed here a few months ago to be an example of symbolic
> > programming, but it doesn't fall within your definition.
> >
> > http://www.itasoftware.com/careers/programmers-archive.php
>
> I visited this link and the "obvious to me" solution does indeed
> involve symbolic computation. I suppose we have a terminology
> conflict since I do see that as covered by my definition whereas you
> do not. Again, it would seem that the problem hinges on the term
> "expression". Is it any better if I say "sentence"?
Ok, good, fine, it's just a terminology difference. We're both agreed
that the solution of this example involved symbolic
computation/processing/programming (take your pick).
But does it involve Common Lisp "symbol processing"? That is to say,
does a reasonable (concise, efficient, clear, idiomatic) solution to the
problem make significant use of the CL "symbol" data type, and in
particular of its attached data value, function value, and property list?
And if that resonable CL program does make significant use of the symbol
data type, is the translation to, say, Perl or Dylan or Scheme
necessarily less concise and efficient and clear and idiomatic?
The previous discussion of this problem brought forth a lot of
solutions, which someone collected, but I don't recall *anyone* using a
symbol-heavy solution. Hash tables with string-valued keys and linked
data structures (whether cons cells or objects or some custom class)
seemed to be the order of the day no matter what language was being used.
-- Bruce
Bruce Hoult <·····@hoult.org> writes:
> As a counter-example, I would consider the "add-a-gram" puzzle discussed
> here a few months ago to be an example of symbolic programming, but it
> doesn't fall within your definition.
Where are you used symbolic identifiers in this puzzle? You're using
strings of characters as strings of characters. The words in the
puzzle don't have symbolic meaning at all, we are only interested in
the characters that make them up.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
In article <··············@photino.sid.rice.edu>,
Rahul Jain <·····@sid-1129.sid.rice.edu> wrote:
> Bruce Hoult <·····@hoult.org> writes:
>
> > As a counter-example, I would consider the "add-a-gram" puzzle discussed
> > here a few months ago to be an example of symbolic programming, but it
> > doesn't fall within your definition.
>
> Where are you used symbolic identifiers in this puzzle? You're using
> strings of characters as strings of characters. The words in the
> puzzle don't have symbolic meaning at all, we are only interested in
> the characters that make them up.
OK, so now we have a counter-claim, that this problem is *not* an
example of symbolic processing, contrary to the understanding that Jon
Allen Boone and I just thought we reached.
Perhaps we need to settle this definitional matter before we go on.
Kent? Erik? Anyone?
-- Bruce
"Bruce Hoult" <·····@hoult.org> wrote in message
································@copper.ipg.tsnz.net...
>
> OK, so now we have a counter-claim, that this problem is *not* an
> example of symbolic processing, contrary to the understanding that Jon
> Allen Boone and I just thought we reached.
>
> Perhaps we need to settle this definitional matter before we go on.
> Kent? Erik? Anyone?
>
I'm not sure it's possible to come to a clear definition.
Face it, given the level of abstraction that programmers
work on, it's symbols `all the way down'. There is no
inherent `three-ness' to #b11, after all. Pedantically,
all programming is symbolic processing.
The main problem is pinning down the meta-level symbols
need to work on so we can attach a meaningful SP label
to it.
-----------
I hope this makes things unclear, :-)
Geoff
Bruce Hoult <·····@hoult.org> writes:
> In article <··············@photino.sid.rice.edu>,
> Rahul Jain <·····@sid-1129.sid.rice.edu> wrote:
>
> > Bruce Hoult <·····@hoult.org> writes:
> >
> > > As a counter-example, I would consider the "add-a-gram" puzzle discussed
> > > here a few months ago to be an example of symbolic programming, but it
> > > doesn't fall within your definition.
> >
> > Where are you used symbolic identifiers in this puzzle? You're using
> > strings of characters as strings of characters. The words in the
> > puzzle don't have symbolic meaning at all, we are only interested in
> > the characters that make them up.
>
> OK, so now we have a counter-claim, that this problem is *not* an
> example of symbolic processing, contrary to the understanding that Jon
> Allen Boone and I just thought we reached.
>
> Perhaps we need to settle this definitional matter before we go on.
> Kent? Erik? Anyone?
I've mostly only been skimming, so I may lack some context here.
IMO, symbolic processing involves the use of a datatype called symbol,
which uses certain named tokens recognized by their _identity_ as
substitutes or ways of aggregating other information.
I don't personally think SYMBOL-NAME is part of the set of things that one
should think of as part of symbol processing, but there is disagreement on
this point. I think SYMBOL-NAME is, as a matter of style, an introspective
operation for use primarily in debugging, since most uses of it for other
purposes effectively destroy any sense of identity that the symbol has.
That is, I don't think what LOOP does is symbol processing.
I think that a good test of whether symbol processing is being done is
whether substitution of a different symbol makes a difference. So if you
can replace FOO with #:FOO in something and it doesn't change the meaning,
then you aren't reasoning about symbols, you are reasoning about strings
using a strange representation. Just as in BASIC when you have only floats
as a numeric datatype and you do A[1] meaning "the 1st element of A" not
"the element of A at distance 1.0 from the beginning" (sigh) you are doing
integer arithmetic even though you aren't using integers. (I actually worked
for years in BASIC before noticing this awful truth.)
Some Lisp programs shown in some books do pattern matching by things like
(match '(foo ?x bar))
andt his is a problem for my definition of symbol processing because ?x
is not treated in a symbolic fashion. taking what I'll call the symbolcdr
of ?x destroys its package information. However, the real question is what
is going on with the other names in the list, the ones without the ? marker.
If matching is by string, then you're really using symbols as string
designators, imo. If it's by identity, then you're doing symbol processing.
But others will disagree. I don't think this is an issue where one person
owns the terminology any more than any one person owns the definition of the
term alist and can say that ((a . b) ...) is a "better" alist than ((a b) ...).
It just turns out that people differ in their use of alists.
To me, the real usefulness of symbol processing is that you're only looking
at identities, so if you go allowing names to matter, then you're destroying
the ability to do the fast comparison that symbols promise.
I have often felt that object-oriented programming should be called
identity-oriented programming. I don't think string-equalness is an identity
issue.
I dunno if this helps at all.
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> That is, I don't think what LOOP does is symbol processing.
Can you cite a canonical example of what you *do* consider symbol processing?
> To me, the real usefulness of symbol processing is that you're only looking
> at identities, so if you go allowing names to matter, then you're destroying
> the ability to do the fast comparison that symbols promise.
>
> I have often felt that object-oriented programming should be called
> identity-oriented programming. I don't think string-equalness is an identity
> issue.
Is there a difference on your view between symbol processing and
object-oriented (by your definition) programming? Do you consider CLOS
instances symbols?
E.
Kent M Pitman <······@world.std.com> writes:
[ ... ]
> That is, I don't think what LOOP does is symbol processing.
>
> I think that a good test of whether symbol processing is being done is
> whether substitution of a different symbol makes a difference. So if you
> can replace FOO with #:FOO in something and it doesn't change the meaning,
> then you aren't reasoning about symbols, you are reasoning about strings
> using a strange representation.
I was about to reply to this, but now I notice that the logic in the
above sentence seems to be upside down:
The above means:
If the name matters, then it is symbol processing, if it doesn't,
then it is string processing.
This seems to contradict the other things that you said. Did you
accidentally through in one too many "not"s ?
Matthias
Matthias Blume <········@shimizu-blume.com> writes:
> Kent M Pitman <······@world.std.com> writes:
>
> [ ... ]
>
> > That is, I don't think what LOOP does is symbol processing.
> >
> > I think that a good test of whether symbol processing is being done is
> > whether substitution of a different symbol makes a difference. So if you
> > can replace FOO with #:FOO in something and it doesn't change the meaning,
> > then you aren't reasoning about symbols, you are reasoning about strings
> > using a strange representation.
>
> I was about to reply to this, but now I notice that the logic in the
> above sentence seems to be upside down:
>
> The above means:
>
> If the name matters, then it is symbol processing, if it doesn't,
> then it is string processing.
>
> This seems to contradict the other things that you said. Did you
> accidentally through in one too many "not"s ?
No, you misunderstand.
I think it is an essential property of symbol processing that there is an
input notation which corresponds to the name. this is why an instance of
standard class is not a symbol nor should it be in any conceivable lisp.
a symbols's manner of marshalling and unmarshalling is inextricably through
its name in some way.
however, i distinguish between typein and execution. at execution time,
i think the name should not be consulted. that is, what makes
A::FOO and B::FOO different at execution time is their lack of EQness, not
differences in their name (some symbols have the same name) or package
(some symbols have the same package). likewise #:FOO and A::FOO are different
by pointer identity, not by name. symbol processing reliably honors this,
and string processing does not.
Kent M Pitman <······@world.std.com> writes:
> Matthias Blume <········@shimizu-blume.com> writes:
>
> > Kent M Pitman <······@world.std.com> writes:
> >
> > [ ... ]
> >
> > > That is, I don't think what LOOP does is symbol processing.
> > >
> > > I think that a good test of whether symbol processing is being done is
> > > whether substitution of a different symbol makes a difference. So if you
> > > can replace FOO with #:FOO in something and it doesn't change the meaning,
> > > then you aren't reasoning about symbols, you are reasoning about strings
> > > using a strange representation.
> >
> > I was about to reply to this, but now I notice that the logic in the
> > above sentence seems to be upside down:
> >
> > The above means:
> >
> > If the name matters, then it is symbol processing, if it doesn't,
> > then it is string processing.
> >
> > This seems to contradict the other things that you said. Did you
> > accidentally through in one too many "not"s ?
>
> No, you misunderstand.
>
> I think it is an essential property of symbol processing that there is an
> input notation which corresponds to the name. this is why an instance of
> standard class is not a symbol nor should it be in any conceivable lisp.
>
> a symbols's manner of marshalling and unmarshalling is inextricably through
> its name in some way.
>
> however, i distinguish between typein and execution. at execution time,
> i think the name should not be consulted. that is, what makes
> A::FOO and B::FOO different at execution time is their lack of EQness, not
> differences in their name (some symbols have the same name) or package
> (some symbols have the same package). likewise #:FOO and A::FOO are different
> by pointer identity, not by name. symbol processing reliably honors this,
> and string processing does not.
Yes, that's how I understood what you are trying to say. My hangup
was (and still is) that the sentence that I quoted seems to say the
opposite...
Anyway, you once again talk about "symbol processing", but what about
"symbolic processing"? Bruce said he senses a difference. Do you?
----
Here is how I see things:
I agree with you in that symbols are values for which only identity
matters. The name thing comes in only when this identity needs to be
maintained across I/O. For pure "internal processing", it is not
required.
Now, let's have a look at the distinction between "symbol processing"
and "symbolic processing":
It is my guess that most people will agree with me when I say that,
for example, manipulating the expressions of the pure untyped lambda
calculus is "symbolic processing". Let's have a closer look:
We have three kinds of expression forms: variables, abstractions, and
applications. In Lisp, we might represent variables as symbols,
abstractions as 3-element lists with the CAR being 0 (the CADR being
the bound variable, and the CADDR being the body expression), and
applications as a 3-element lists with the CAR being 1 (the CADR being
the function expression, and the CADDR being the argument expression).
Notice that I avoided the use of symbols (such as LAMBDA) for
distinguishing between abstractions and applications because I want to
reserve the use of symbols for variables.
Now, the rules of the lambda calculus dictate that, indeed, the name
of /bound/ variables does not matter. This is known as "alpha
renaming is a valid reasoning principle". The names of free variables
do matter, but if it is our intention to not interpret such free
variables but rather carry them through as uninterpreted placeholders,
then a common trick can give us the independence from names back: By
/closing over free variables/ by wrapping the entire expression into
enough additional abstractions we get a fully closed expression where
names do not matter by the alpha renaming principle (as long as they
do not clash). This scenario seems to be a prime example for
something that would pass the "Pitman test" for symbol(ic?)
processing.
But there still is something nasty about this: Why, everything else
being equal, do we need that pesky side condition about avoiding name
clashes if names otherwise do not matter? In fact, there is a way of
completely circumventing this issue by using natural numbers in place
of variables. For this, we change our expression representation to
be one of the following (different) three forms:
1. a natural number
2. an abstraction represented by a singleton list containing the
body of the abstraction
3. an application represented by a two-element list containing the
function expression in the CAR and the argument expression in
the CADR
(We no longer need those 0 and 1 tags to distinguish between
abstraction and application because the length of the list
already carries this information.)
Notice that abstractions do not mention any variables to be bound.
Natural numbers (which stand for what formerly would have been the
use of a bound variable) count the number of nested abstractions
between this occurence and the corresponding abstraction. For example
old encoding new encoding lambda calculus
(0 x x) becomes (0) [\x.x]
(0 x (0 y (1 x y)) becomes (((1 0))) [\x.\y.(x y)]
etc.
The above new encoding is known as the DeBruin encoding of lambda
terms. It has a number of advantages, one being the absence of name
clashes (by virtue of the fact that there are no "names"), another one
the potential for a transition system that does not involve "global"
operations such as beta reduction. (Beta reduction involves the
non-local operation of substitution.) See a textbook on lambda
calculus for more on this.
My question now is: Given that manipulating (ordinary) lambda terms
constitutes "symbolic processing", does manipulating the same lambda
terms in DeBruin encoding still constitute "symbolic processing"?
Notice that there are no symbols whatsoever in this encoding. Even
the natural numbers are not used for identity but for their numeric
value. So it certainly isn't "symbol processing". Still, to me, the
answer to the question about "symbolic processing" is a clear and loud
"yes". In other words, "symbolic processing" does not imply
"processing with symbols".
-----
Now, let me come back to the issue of free variables. At face value,
compiling a Lisp expression such as
(CONS 1 2)
does not seem to pass the "Pitman test", even though at least I
definitely think that compilation is symbolic processing. The problem
is that the name CONS certainly cannot simply be replaced with just
about anything else without changing the meaning.
However, what Kent is apparently after is the larger picture that
involves the (implicit) "binding" of CONS by, e.g., the Common Lisp
language definition. Indeed, we could replace CONS with, e.g.,
KONSTRUKT iff we also make the corresponding change in the language
definition. So in some sense when we talk about something like (CONS
1 2) we really talk about a *much* larger "expression" -- an
expression that involves all the language's predefined bindings.
Looking at it this way, there are no "free" variables, and the
associated problems vanish.
------
Indeed, I agree with Kent in that as soon as a program inspects
properties of its "symbols" other than their identity, it no longer
uses "symbols" as "symbols". Having said all this, I still maintain
that about anything that has a notion of identity (and what doesn't?),
can be used /as/ symbols. So "symbol processing" does not require the
existence of a certain built-in (or otherwise defined) type. Instead,
it describes a particular way of using data. The representation type
of this "symbol" data is not that important -- as long as we ignore
representation issues and focus on identity only.
--
-Matthias
Matthias Blume <········@shimizu-blume.com> writes:
[ ... about "DeBruin" ... ]
Correction: The correct spelling is "de Bruijn". The numbers
representing occurences of variables are known as "de Bruijn indices".
Sorry about that.
By the way, the version of the lambda calculus that avoids "global"
operations is called the "C-lambda-xi-phi calculus" aka "calculus of
explicit subtsitutions". See N. G. de Bruijn's 1978 paper.
--
-Matthias
Matthias Blume <········@shimizu-blume.com> writes:
> Anyway, you once again talk about "symbol processing", but what about
> "symbolic processing"? Bruce said he senses a difference. Do you?
Probably. Not sure if it matters.
Symbol processing seems to me plainly processing of symbols.
Symbolic processing seems to me to be processing in the style of symbols.
For example, reducing (* (expt a 2) (expt a 2)) to (expt a 4) might be
seen as a numeric simplification since the main merging is of 2 and 2 to 4.
But I might say this was conceptually done in the style of symbolic
processing since formally the analysis strategy in use is that of a
symbol processor [qualitative/formal] not that of EVAL
[imperative/quantitative].
- - -
> Now, let me come back to the issue of free variables. At face value,
> compiling a Lisp expression such as
>
> (CONS 1 2)
>
> does not seem to pass the "Pitman test", even though at least I
> definitely think that compilation is symbolic processing. The problem
> is that the name CONS certainly cannot simply be replaced with just
> about anything else without changing the meaning.
>
> However, what Kent is apparently after is the larger picture that
> involves the (implicit) "binding" of CONS by, e.g., the Common Lisp
> language definition. Indeed, we could replace CONS with, e.g.,
> KONSTRUKT iff we also make the corresponding change in the language
> definition. So in some sense when we talk about something like (CONS
> 1 2) we really talk about a *much* larger "expression" -- an
> expression that involves all the language's predefined bindings.
> Looking at it this way, there are no "free" variables, and the
> associated problems vanish.
You are right that I meant to exclude this. The reason is so that I can
handle sentences like "Fred is so-named because of his father."
It simply does not work to replace Fred with a seemingly equivalently
operating symbol whose semantic binding is the same. I distinguish between
"sentences, made up of words (symbols)" and sentences made up of magic
tokens that are the value of these items. Granted that, as someone [Erann?]
suggested, there may be ways to think differently to avoid [some?]
morning star/evening star problems, it's still important to me to come up
with a way of MODELING the observed fact that people do have this problem,
and I think having data structures that mirror what's in my head do this.
My intuition is that one reason I like Lisp is that I have mindshare with
its structures, so my intuitions about how I think can be mapped usefully
back and forth to my intuitions about Lisp.
> Indeed, I agree with Kent in that as soon as a program inspects
> properties of its "symbols" other than their identity, it no longer
> uses "symbols" as "symbols". Having said all this, I still maintain
> that about anything that has a notion of identity (and what doesn't?),
> can be used /as/ symbols. So "symbol processing" does not require the
> existence of a certain built-in (or otherwise defined) type. Instead,
> it describes a particular way of using data. The representation type
> of this "symbol" data is not that important -- as long as we ignore
> representation issues and focus on identity only.
I didn't get enough sleep last night and so only have adequate brainpower
to answer some of your questions. Analyzing the middle part about the
alternate notations is beyond the scope of my processor at the moment.
However, I pondered a little more the issue of "names" and I might say it
this way: People do not share address space with Lisp, and so, just as
with the definition of "similarity" (which defines an equality predicate
that spans images), it is necessary to construct something that allows us
to share a "conceptual address space" with Lisp. The reason FOO needs a
name is because saying #x7a873b7h is not meaningful to specify FOO's
identity in a way that allows mindshare between the programmer and the
image. When I say marshalling/unmarshalling works by name, I mean that
people [and, incidentally other lisp images with different vendors or
data layouts] will want to share structure with this. To me, there is
really a meaning to CAR, so it makes no sense to me to talk about CAR as
if it could just as well be called CDR or FROG or JUSTICE.
It matters to me primitively in my sense of what a symbol is that it be a
specially chosen glyph or gesture that maps to my internal human information
structure. Now, I might have a special secret concept that has no name to
you and you might think it was well-represented by a non-symobl since it
is not shared. I don't know. I don't find that useful. What I do find useful
is that my memory is organized into units with names, like "the" and "box".
And those are not strings because when I speak Portuguese, and say
"no" I don't mean "the opposite of yes" but rather I mean "in the".
You can say this is a lexical context issue if you like, and we can debate
the structural nature of puns and the times at which linguistic resolution
occurs, but it sure feels to me like the symbol is what's in my brain and
that it's merely coincidence that the spellings are the same. That is,
when I think about words, I don't "feel" like I go inside the word and get
an unnamable concept--I really "feel" like I manipulate the word itself,
and yet I don't feel an ordinary confusion surrounding "no" tugging at me
once I have a reasonable theory of what language I have read the text in.
I can get from that "no" in portuguese to the "no" in spanish or english,
but I don't think they are the same node structure in my brain. Of course,
introspecting about such things is dangerous and I won't say that what
I feel is a proof--but it is at least a decent straw man, and nothing in
this conversation has been offered by me as other than such.
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> You are right that I meant to exclude this. The reason is so that I can
> handle sentences like "Fred is so-named because of his father."
> It simply does not work to replace Fred with a seemingly equivalently
> operating symbol whose semantic binding is the same. I distinguish between
> "sentences, made up of words (symbols)" and sentences made up of magic
> tokens that are the value of these items. Granted that, as someone [Erann?]
> suggested, there may be ways to think differently to avoid [some?]
> morning star/evening star problems, it's still important to me to come up
> with a way of MODELING the observed fact that people do have this problem,
People don't have this problem. Only philosophers have this problem ;-)
> And those are not strings because when I speak Portuguese, and say
> "no" I don't mean "the opposite of yes" but rather I mean "in the".
My father is fond of reciting the following little chant that shows how
common this sort of thing is in Hebrew: "Ani is me, and me is who, and who
is he, and he is she, and if you call a girl you call her boy."
> You can say this is a lexical context issue if you like, and we can debate
> the structural nature of puns and the times at which linguistic resolution
> occurs, but it sure feels to me like the symbol is what's in my brain and
> that it's merely coincidence that the spellings are the same. That is,
> when I think about words, I don't "feel" like I go inside the word and get
> an unnamable concept--I really "feel" like I manipulate the word itself,
> and yet I don't feel an ordinary confusion surrounding "no" tugging at me
> once I have a reasonable theory of what language I have read the text in.
> I can get from that "no" in portuguese to the "no" in spanish or english,
> but I don't think they are the same node structure in my brain. Of course,
> introspecting about such things is dangerous and I won't say that what
> I feel is a proof--but it is at least a decent straw man, and nothing in
> this conversation has been offered by me as other than such.
I think the most productive framework for this debate is not how it is but
rather how it should be from a software engineering point of view. (We
are supposed to be talking about a programming language after all.) I
think it's a valid point that portugese::no and english::no really should
be considered distinct symbols with the same "name". But on this view,
one really should think of packages in Common Lisp as defining *different
languages*, and that p1:foo and p2:foo are as distinct as portugese:no and
english:no.
It's pretty clear that we've done things like (import 'spanish:tortilla
'english), that is, that the word "tortilla" is really the same word in
both languages. But what about things like english:bureau and
french:bureau? German:hamburger and english:hamburger? Or english:lisp
(the programming language) and english:lisp (the speech impediment)?
In natural language these things are doomed to remain fuzzy. But in a
programming language we have the freedom to choose to make them clear. I
think we should.
E.
On Tue, 16 Apr 2002, Erann Gat wrote:
> In article <···············@shell01.TheWorld.com>, Kent M Pitman
> <······@world.std.com> wrote:
[snip]
> > tokens that are the value of these items. Granted that, as someone [Erann?]
> > suggested, there may be ways to think differently to avoid [some?]
> > morning star/evening star problems, it's still important to me to come up
> > with a way of MODELING the observed fact that people do have this problem,
>
> People don't have this problem. Only philosophers have this problem ;-)
[snip]
Hey! At least *some* philosophers are people (I try to use myself as an
example :)). We still have this "problem" (though, properly, it's a
phenomenon; the "problem" is in accomdating the phenomenon in various
formalisms and theories).
Cheers,
Bijan Parsia.
Just one data point:
In my notion space, symbolic reasoning/computation/processing is taking
sentences/expressions as the object of reasoning, rather than as the
subject (as in interpretation/evaluation/execution). Such reasoning is
normally done through the use of patterns, and the variables in those
patterns are symbols, in that they symbolise, i.e. stand for something else
during the course of the reasoning. This has nothing per se to do with
Lisp symbols (symbolic reasoning can be performed in ones head, or by hand
on paper), but that symbols seem a good choice to represent such variables.
The granularity of the identity predicate is no fundamental issue: my
algebraic variables on paper have a rather coarse equivalence predicate..
--
Biep
Kent M Pitman <······@world.std.com> writes:
[On symbolic processing, not very relevant to the question to follow]
> Some Lisp programs shown in some books do pattern matching by things like
> (match '(foo ?x bar))
> andt his is a problem for my definition of symbol processing because ?x
> is not treated in a symbolic fashion. taking what I'll call the symbolcdr
> of ?x destroys its package information. However, the real question is what
> is going on with the other names in the list, the ones without the ? marker.
> If matching is by string, then you're really using symbols as string
> designators, imo. If it's by identity, then you're doing symbol processing.
If, say, one would be to have a matcher package and a "variable"
package (possibly nick-named "?"), would using
(match '(foo ?:x bar) data)
be symbolic processing? One isn't using any property of the symbol
name, but "only" the package the sumbol lives in as an indication that
a variable is meant rather than any "self-matching symbol"?
Mostly an idle question, probing limits on what you consider "symbolic
priocessing" (and, also, in a way, a neat way of using the package
mechanism).
//Ingvar
--
Ingvar Mattsson; ····@algonet.se;
You can get further with a kind word and a 2x4
than you can with just a kind word. Among others, Marcus Cole
Ingvar Mattsson <······@cathouse.bofh.se> writes:
> Kent M Pitman <······@world.std.com> writes:
>
> [On symbolic processing, not very relevant to the question to follow]
> > Some Lisp programs shown in some books do pattern matching by things like
> > (match '(foo ?x bar))
> > andt his is a problem for my definition of symbol processing because ?x
> > is not treated in a symbolic fashion. taking what I'll call the symbolcdr
> > of ?x destroys its package information. However, the real question is what
> > is going on with the other names in the list, the ones without the ? marker.
> > If matching is by string, then you're really using symbols as string
> > designators, imo. If it's by identity, then you're doing symbol processing.
>
> If, say, one would be to have a matcher package and a "variable"
> package (possibly nick-named "?"), would using
> (match '(foo ?:x bar) data)
> be symbolic processing? One isn't using any property of the symbol
> name, but "only" the package the sumbol lives in as an indication that
> a variable is meant rather than any "self-matching symbol"?
yeah, let me be more clear after thinking about this a little...
Certainly a matcher that does something like
(match '( match:begin-group foo match:alternative bar
match:end-group match:any-number ))
as perhaps a representation of the regexp "\(foo|bar\)" except matching
symbols foo and bar rather than character strings "FOO" and "BAR" so that
'(FOO BAR BAR BAR FOO)
might match but neither
'("FOO" "BAR" "BAR" "BAR" "FOO")
nor
"FOOBARBARFOO"
would match would be ok.
I also have written matchers that did
(MATCH-BIND ((*= X) IS (*= Y)) '(THE DOG IS BARKING LOUDLY)
(LIST X Y))
=> ((THE DOG) (BARKING LOUDLY))
to get a body executed. I think that's symbol processing too.
But I think that the case I cited is not doing symbol processing at
macro expansion time if (FOO ?X BAR) turns into
((LAMBDA (X) ..)
(MATCH '((LITERAL-TOKEN FOO) (VARIABLE X) (LITERAL-TOKEN BAR))))
even though the same thing [once macroexpanded] would be doing symbol
processing at runtime.
I specifically was annoyed, though, by some examples in winston's
early AI book (when I took the class, circa spring 1977) where it did
exploding of the symbol at runtme as part of the matching. if you
don't precompile the references to symbols named ?X it's WAY too
inefficient to handle the combinatorics. I wrote a doctor [i.e.,
eliza-ish] program using that kind of technology and it was impossibly
slow. it traces to doing EXPLODE (the Maclisp function of the day
that got you a list of the characters in a symbol name; we didn't have
strings) all the time... it was effectively string manipulating. BUT
if you swapped the program for one that had already broken the symbols
apart, either by readmacro or by macro processing, you got one that
ran tolerably fast on rational size inputs because it only pushed
symbols and the combinatorics didn't kill pointer compares nearly as
fast as it did other things...
> Mostly an idle question, probing limits on what you consider "symbolic
> priocessing" (and, also, in a way, a neat way of using the package
> mechanism).
yeah... good question
In article <···············@shell01.TheWorld.com>,
Kent M Pitman <······@world.std.com> wrote:
> I dunno if this helps at all.
It matches what you've been saying in the past. But I'm more interested
in a concrete example, which is whether the add-a-gram puzzle is a
symbolic processing problem.
-- Bruce
···@jpl.nasa.gov (Erann Gat) writes:
> In article <···············@shell01.TheWorld.com>, Kent M Pitman
> <······@world.std.com> wrote:
>
> > That is, I don't think what LOOP does is symbol processing.
>
> Can you cite a canonical example of what you *do* consider symbol processing?
Again, we're just talking one person's opinion on a matter that is far less
principled than we usually do.
But, for example,
- most macro processing in lisp [other than ones that explode symbols]
- symbolic algebra (e.g. macsyma)
- the old ai systems that used to use symbols in place of instances
and get/putprop instead of slot references
[in fact, pretty much anything that uses get and putprop (setf of get) ]
> > To me, the real usefulness of symbol processing is that you're
> > only looking at identities, so if you go allowing names to matter,
> > then you're destroying the ability to do the fast comparison that
> > symbols promise.
> >
> > I have often felt that object-oriented programming should be
> > called identity-oriented programming. I don't think
> > string-equalness is an identity issue.
>
> Is there a difference on your view between symbol processing and
> object-oriented (by your definition) programming?
object-oriented programming subsumes symbol processing, but not vice versa.
> Do you consider CLOS instances symbols?
(only the ones of metaclass builtin-class and class symbol.)
i.e., "of course not". symbols and instances are disjoint.
YMMV
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> ···@jpl.nasa.gov (Erann Gat) writes:
>
> > In article <···············@shell01.TheWorld.com>, Kent M Pitman
> > <······@world.std.com> wrote:
> >
> > > That is, I don't think what LOOP does is symbol processing.
> >
> > Can you cite a canonical example of what you *do* consider symbol
processing?
>
> Again, we're just talking one person's opinion on a matter that is far less
> principled than we usually do.
Understood.
> But, for example,
>
> - most macro processing in lisp [other than ones that explode symbols]
But LOOP, your canonical example of non-symbol-processing, is a macro that
doesn't explode symbols.
E.
···@jpl.nasa.gov (Erann Gat) writes:
> But LOOP, your canonical example of non-symbol-processing, is a macro that
> doesn't explode symbols.
It doesn't litterally call the EXPLODE function, but it does use
STRING= of SYMBOL-NAME, which I'm pretty sure is what Kent meant
(using symbols as string designators).
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
···@jpl.nasa.gov (Erann Gat) politely asked:
> Can you cite a canonical example of what you *do* consider symbol
processing?
"Kent M Pitman" <······@world.std.com> in message
····················@shell01.TheWorld.com came up with:
> - the old ai systems that used to use symbols in place of instances
> and get/putprop instead of slot references
> [in fact, pretty much anything that uses get and putprop (setf of
get) ]
> YMMV
It does. In my lexical environment, using properties is a non-symbolic
action, because the Lisp:symbol is then no longer used as a
Computation:symbol, but as a record.
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote in message
···················@ID-63952.news.dfncis.de...
>
> In my lexical environment, using properties is a non-symbolic
> action, because the Lisp:symbol is then no longer used as a
> Computation:symbol ....
The word you're looking for `identifier' (a name for an instance
of a language construct such as a variable or function)
But using a lisp symbol for properties other than the uniqueness
of its print-name doesn't preclude you from using that same name
as an identifier in your program.
"Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote
in message ···················@ID-63952.news.dfncis.de...
> In my lexical environment, using properties is a non-symbolic
> action, because the Lisp:symbol is then no longer used as a
> Computation:symbol ....
"Joe Marshall" <·············@attbi.com> replied
in message ··························@typhoon.ne.ipsvc.net...
> The word you're looking for `identifier' (a name for an instance
> of a language construct such as a variable or function)
Thanks, but I don't think that "identifier" would fit the bill. Maybe a
pattern variable might be called an identifier in the pattern language, but
it wouldn't be one in the underlying pattern matcher, and it is the matcher
that would be doing the symbolic computation.
But you are right in that the notion is very closely related.
--
Biep
Reply via http://www.biep.org
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> ···@jpl.nasa.gov (Erann Gat) politely asked:
> > Can you cite a canonical example of what you *do* consider symbol
> processing?
>
> "Kent M Pitman" <······@world.std.com> in message
> ····················@shell01.TheWorld.com came up with:
> > - the old ai systems that used to use symbols in place of instances
> > and get/putprop instead of slot references
> > [in fact, pretty much anything that uses get and putprop (setf of
> get) ]
> > YMMV
>
> It does. In my lexical environment, using properties is a non-symbolic
> action, because the Lisp:symbol is then no longer used as a
> Computation:symbol, but as a record.
But the same can be said about lists.
Lists are often used as low-tech records. Even Lisp forms are (op . args)
and arguably might have been better represented as a datatype of their own.
Such use does not make what most macros do not be "list processing".
The traditional sense of "symbol processing", just like the traditional
sense of "list processing", was that symbols and lists were indeed the
data structures of choice for a great many things that people today
use other structures for.
"Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote:
> In my lexical environment, using properties is a non-symbolic
> action, because the Lisp:symbol is then no longer used as a
> Computation:symbol, but as a record.
"Kent M Pitman" <······@world.std.com>, in message
····················@shell01.TheWorld.com, aptly observed:
> But the same can be said about lists.
True. Organising data in lists is, to me, not a symbolic activity. There
is nothing anti-symbolic in it either, though, whereas the use of property
lists - while arguably orthogonal with the symbolic use of symbols - is
itself a non-symbolic use of symbols that tends to muddle the notion of
symbolicity.
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> "Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote:
> > In my lexical environment, using properties is a non-symbolic
> > action, because the Lisp:symbol is then no longer used as a
> > Computation:symbol, but as a record.
>
> "Kent M Pitman" <······@world.std.com>, in message
> ····················@shell01.TheWorld.com, aptly observed:
> > But the same can be said about lists.
>
> True. Organising data in lists is, to me, not a symbolic activity. There
> is nothing anti-symbolic in it either, though, whereas the use of property
> lists - while arguably orthogonal with the symbolic use of symbols - is
> itself a non-symbolic use of symbols that tends to muddle the notion of
> symbolicity.
No, you missed my point. Lists are untyped and arbitrarily sizeable.
But one can still treat them as fixed-size and with fixed-type slots.
And it's still "list processing" by the standards of some.
Oops! It seems I can't quickly type double colons on this keyboard..
--
Biep
Reply via http://www.biep.org
"Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote in message
···················@ID-63952.news.dfncis.de...
>
> ···@jpl.nasa.gov (Erann Gat) politely asked:
> > Can you cite a canonical example of what you *do* consider symbol
> processing?
>
> "Kent M Pitman" <······@world.std.com> in message
> ····················@shell01.TheWorld.com came up with:
> > - the old ai systems that used to use symbols in place of instances
> > and get/putprop instead of slot references
> > [in fact, pretty much anything that uses get and putprop (setf of
> get) ]
> > YMMV
>
> It does. In my lexical environment, using properties is a non-symbolic
> action, because the Lisp:symbol is then no longer used as a
> Computation:symbol, but as a record.
>
> --
> Biep
>
>
"Geoff Summerhayes" <·············@hNoOtSmPaAiMl.com> writes:
> "Bruce Hoult" <·····@hoult.org> wrote in message
> ································@copper.ipg.tsnz.net...
> >
> > OK, so now we have a counter-claim, that this problem is *not* an
> > example of symbolic processing, contrary to the understanding that Jon
> > Allen Boone and I just thought we reached.
> >
> > Perhaps we need to settle this definitional matter before we go on.
> > Kent? Erik? Anyone?
> >
>
> I'm not sure it's possible to come to a clear definition.
> Face it, given the level of abstraction that programmers
> work on, it's symbols `all the way down'. There is no
> inherent `three-ness' to #b11, after all. Pedantically,
> all programming is symbolic processing.
>
> The main problem is pinning down the meta-level symbols
> need to work on so we can attach a meaningful SP label
> to it.
Funnily enough, I thought you were on a good track here and then you
derailed it.
if you interned numbers [and Maclisp did, for small integers at least],
you could argue they were symbol-like. especially if you interned
bignums, this might make them fast to compare and depending on your use
of the bignum (perhaps if you were using them as random keys with enough
bits to make it unlikely two people would randomly genreate the same one)
efficient compare might be good. in that regard, numbers might be symbol-like.
it seems to me that it's not symbols "all the way down" unless at
every abstraction layer the symbolness is preserved, and i think at
the intermediate abstraction level, #b11 is a string, not a symbol,
that is the same as some other #b11 not because of its consistent use
of the same pointer but because of the coincidence that it orders its
1-symbols and 0-symbols the same way in its container as some other
machine word does in its.
whether the 1-symbols are symbols or strings is more of a philosophical
than practical problem but i suppose it at least could be symbols.
"Kent M Pitman" <······@world.std.com> wrote in message
····················@shell01.TheWorld.com...
> "Geoff Summerhayes" <·············@hNoOtSmPaAiMl.com> writes:
> >
> > I'm not sure it's possible to come to a clear definition.
> > Face it, given the level of abstraction that programmers
> > work on, it's symbols `all the way down'. There is no
> > inherent `three-ness' to #b11, after all. Pedantically,
> > all programming is symbolic processing.
> >
> > The main problem is pinning down the meta-level symbols
> > need to work on so we can attach a meaningful SP label
> > to it.
>
> Funnily enough, I thought you were on a good track here and then you
> derailed it.
>
> if you interned numbers [and Maclisp did, for small integers at least],
> you could argue they were symbol-like. especially if you interned
> bignums, this might make them fast to compare and depending on your use
> of the bignum (perhaps if you were using them as random keys with enough
> bits to make it unlikely two people would randomly genreate the same one)
> efficient compare might be good. in that regard, numbers might be
symbol-like.
>
> it seems to me that it's not symbols "all the way down" unless at
> every abstraction layer the symbolness is preserved, and i think at
> the intermediate abstraction level, #b11 is a string, not a symbol,
> that is the same as some other #b11 not because of its consistent use
> of the same pointer but because of the coincidence that it orders its
> 1-symbols and 0-symbols the same way in its container as some other
> machine word does in its.
>
> whether the 1-symbols are symbols or strings is more of a philosophical
> than practical problem but i suppose it at least could be symbols.
It was the more philosophical I was aiming at. Viewing numbers as
abstract concepts, their definition in set theory, and viewing
the same bits representing different things depending on the
context of their viewing. I remove myself from the physical workings
of the computer, electron flow, transistors, clock pulses, etc. by
abstracting them up to the level of bits, addresses, instructions
and then onto numbers, strings, HLL programs. It's just layer on
layer of symbols.
Looking this over, I suppose I should never have read Korzybski's
"Science and Sanity". Apparently it's warped my mind considerably. :-)
----------
Geoff
···@jpl.nasa.gov (Erann Gat) writes:
> In article <···············@shell01.TheWorld.com>, Kent M Pitman
> <······@world.std.com> wrote:
>
> > ···@jpl.nasa.gov (Erann Gat) writes:
> >
> > > In article <···············@shell01.TheWorld.com>, Kent M Pitman
> > > <······@world.std.com> wrote:
> > >
> > > > That is, I don't think what LOOP does is symbol processing.
> > >
> > > Can you cite a canonical example of what you *do* consider symbol
> processing?
> >
> > Again, we're just talking one person's opinion on a matter that is far less
> > principled than we usually do.
>
> Understood.
>
> > But, for example,
> >
> > - most macro processing in lisp [other than ones that explode symbols]
>
> But LOOP, your canonical example of non-symbol-processing, is a macro that
> doesn't explode symbols.
Yes, it does. You don't understand what I said. Maclisp didn't have
a STRING datatype. The "..." readmacro in Maclisp created an
uninterned symbol named |...| (I think with some special property like
+internal-string-marker/| or some such thing. that reminded the
printer to print it as "..." instead of |...|.) EXPLODE (or usually
EXPLODEN or EXPLODEC), was the name of the operator in Maclisp that
allowed you to gain access to the characters in the name, by getting a
list. (The actual storage was not something you were supposed to get
at; it was a list of packed integers or some such weirdness...) Just
because you are not taking CDR of the result does not mean you are not
using the conceptual operation. Doing
(equal (exploden symbol-x) (exploden symbol-y)) ;Maclisp
is the same as asking
(string= (symbol-name symbol-x) (symbol-name symbol-y)) ;CL
···@jpl.nasa.gov (Erann Gat) writes:
> In article <···············@shell01.TheWorld.com>, Kent M Pitman
> <······@world.std.com> wrote:
>
> > You are right that I meant to exclude this. The reason is so that I can
> > handle sentences like "Fred is so-named because of his father."
> > It simply does not work to replace Fred with a seemingly equivalently
> > operating symbol whose semantic binding is the same. I distinguish between
> > "sentences, made up of words (symbols)" and sentences made up of magic
> > tokens that are the value of these items. Granted that, as someone [Erann?]
> > suggested, there may be ways to think differently to avoid [some?]
> > morning star/evening star problems, it's still important to me to come up
> > with a way of MODELING the observed fact that people do have this problem,
>
> People don't have this problem. Only philosophers have this problem ;-)
I don't think this is true, btw. I think what's true is that the
problems people cause themselves with this problem are not properly
attributed if they are not philosophers savvy enough to attribute the
blame correctly.
> > And those are not strings because when I speak Portuguese, and say
> > "no" I don't mean "the opposite of yes" but rather I mean "in the".
>
> My father is fond of reciting the following little chant that shows how
> common this sort of thing is in Hebrew: "Ani is me, and me is who, and who
> is he, and he is she, and if you call a girl you call her boy."
>
> > You can say this is a lexical context issue if you like, and we can debate
> > the structural nature of puns and the times at which linguistic resolution
> > occurs, but it sure feels to me like the symbol is what's in my brain and
> > that it's merely coincidence that the spellings are the same. That is,
> > when I think about words, I don't "feel" like I go inside the word and get
> > an unnamable concept--I really "feel" like I manipulate the word itself,
> > and yet I don't feel an ordinary confusion surrounding "no" tugging at me
> > once I have a reasonable theory of what language I have read the text in.
> > I can get from that "no" in portuguese to the "no" in spanish or english,
> > but I don't think they are the same node structure in my brain. Of course,
> > introspecting about such things is dangerous and I won't say that what
> > I feel is a proof--but it is at least a decent straw man, and nothing in
> > this conversation has been offered by me as other than such.
>
> I think the most productive framework for this debate is not how it is but
> rather how it should be from a software engineering point of view. (We
> are supposed to be talking about a programming language after all.)
I have as a personal design philosophy a belief that the language that has
best isomorphism to how people think is the one easiest to program in and
the hardest to make accidental conceptual errors with. As such, I think
these are not separable.
You don't have to have this same design rule. I'm just saying how I think
and what I value because I was asked to. I'm not waging a campaign.
> I think it's a valid point that portugese::no and english::no really should
> be considered distinct symbols with the same "name". But on this view,
> one really should think of packages in Common Lisp as defining *different
> languages*, and that p1:foo and p2:foo are as distinct as portugese:no and
> english:no.
I've often heard Lisp described as a language in which the addition of each
program or set of programs extends the language, primarily because programs
so smoothly extend not just the functionality but the syntax of the language
that there isn't the sharp syntactic divide between kinds of things "language
designers" do an kinds of things "users" do. As such, I see no problem with
thinking each package a separate language and I'm not sure I see your point
here. Did you expect I would? Maybe you can rephrase your concern to focus
in on what you think and what you thought I'd think.
> It's pretty clear that we've done things like (import 'spanish:tortilla
> 'english), that is, that the word "tortilla" is really the same word in
> both languages. But what about things like english:bureau and
> french:bureau? German:hamburger and english:hamburger? Or english:lisp
> (the programming language) and english:lisp (the speech impediment)?
You're getting yourself confused by not seeing each of these languages as
a package and each jargon domain as yet another package that uses the symbols
it wants and redefines others. lisp:car is another example. I'd cut the
identity link any time you don't have a synonym.
> In natural language these things are doomed to remain fuzzy.
This is possibly as much an artifact of the storage mechanism as the datatype.
That is, what counts as a pointer might turn out to be fuzzy, not the object.
It could be the object is clear and waving "me me me!" but that the pointer is
just a probabilistic path that says "that thing over there lighting up with
85% power seems a better bet than that other thing that's only doing 65%".
> But in a
> programming language we have the freedom to choose to make them clear. I
> think we should.
"should"? We're talking terminology. You simply asked my opinion (a "do"
question) and the reason (a "rationale" question). I have a reason for
wanting what I want, and I presented it.
I reject the notion that it is a priori better to do things better. I think
it's quite important to understand as best one can what peoples' intuitions
are.
People who lean heavy on symbols to support them have found they need
the flexibility CL symbols have. Many people have learned not to lean
on symbols find they don't need the extra support of CL symbols. I
don't see a conflict between these two.
People who are hungry on the street find it useful to have food banks, people
who are raped find it useful to have rape crisis centers, people who don't
have phone books find it useful to have a number to call for information,
etc. People who have other sources of food don't find they need food banks,
people who aren't raped don't need rape crisis centers. People who keep phone
books handy don't think having an information number is necessarily needed.
Does this argue for cancelling all these services?
When I want to know how to design a service, I don't ask the people who don't
plan to use it, I ask the people who do.
Nothing keeps a person who has the simplistic model of packages from simply
using a single package and designing a module system that works well within
it (or using existing lexical scope as that module system). But for people
who want to bind meaning to symbols, there is no substitute for partitioning
symbols adequately.
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> > People don't have this problem. Only philosophers have this problem ;-)
>
> I don't think this is true, btw.
Yeah, I don't either. :-( I was just trying to be funny.
> I think what's true is that the
> problems people cause themselves with this problem are not properly
> attributed if they are not philosophers savvy enough to attribute the
> blame correctly.
I do think that the problems that people really have are different than
the ones the philosophers think they have, which is actually the same
thing as what you said, but puts a different spin on it.
> > I think it's a valid point that portugese::no and english::no really should
> > be considered distinct symbols with the same "name". But on this view,
> > one really should think of packages in Common Lisp as defining *different
> > languages*, and that p1:foo and p2:foo are as distinct as portugese:no and
> > english:no.
>
> I've often heard Lisp described as a language in which the addition of each
> program or set of programs extends the language, primarily because programs
> so smoothly extend not just the functionality but the syntax of the language
> that there isn't the sharp syntactic divide between kinds of things "language
> designers" do an kinds of things "users" do. As such, I see no problem with
> thinking each package a separate language and I'm not sure I see your point
> here. Did you expect I would? Maybe you can rephrase your concern to focus
> in on what you think and what you thought I'd think.
I wasn't really trying to make a point. I was throwing out an
interpretation to see if you (and other people) agreed with it or not.
> > But in a
> > programming language we have the freedom to choose to make them clear. I
> > think we should.
>
> "should"? We're talking terminology. You simply asked my opinion (a "do"
> question) and the reason (a "rationale" question). I have a reason for
> wanting what I want, and I presented it.
Yeah, at this point I'm shifting from asking a question to taking a
stand. Perhaps I should have signalled this better.
> I reject the notion that it is a priori better to do things better. I think
> it's quite important to understand as best one can what peoples' intuitions
> are.
I agree, which is why I'm asking all these questions.
> People who lean heavy on symbols to support them have found they need
> the flexibility CL symbols have. Many people have learned not to lean
> on symbols find they don't need the extra support of CL symbols. I
> don't see a conflict between these two.
Me neither.
To jump ahead a few steps (I'm taking a stand now) I am coming to the
conclusion that the "right" answer is to have good support for *both*
packages and first-class environments. Unfortunately, the current state
of the world forces you to choose between one or the other (and if you
want first-class environments forces you to abandon both Common Lisp and
Scheme).
To go back to the natural language analogy, if I'm talking with someone
(supposing we're both speaking English) and we discover that we're using
the same word (like 'symbol') to mean different things, Common Lisp forces
me, in order to continue communicating, to say something like "OK, I'm
going to define my own language here, which is just like English, except
that in my language the word "symbol" means ...." as opposed to, "We're
both still speaking the same language, but when I say 'symbol' (which is
still the same word you're using when you say 'symbol') I mean ..." The
latter feels like a better metaphor to me in many (perhaps even most but
not all) situations.
E.
Erann Gat <···@jpl.nasa.gov> wrote in message
·························@eglaptop.jpl.nasa.gov...
> In article <···············@shell01.TheWorld.com>, Kent M Pitman
> <······@world.std.com> wrote:
>
> > > People don't have this problem. Only philosophers have this problem
;-)
> >
> > I don't think this is true, btw.
>
> Yeah, I don't either. :-( I was just trying to be funny.
>
I laughed.. :)
> > > I think it's a valid point that portugese::no and english::no really
should
> > > be considered distinct symbols with the same "name". But on this
view,
> > > one really should think of packages in Common Lisp as defining
*different
> > > languages*, and that p1:foo and p2:foo are as distinct as portugese:no
and
> > > english:no.
For me, replacing "should" with "could" ("one really could think of
packages...") makes the above a much more useful conclusion. Sometimes
packages are just disambiguating within the same language. (see below re:
"lisp" and "lithp")
> > I reject the notion that it is a priori better to do things better.
:) I like that line! A very thought-provoking statement..
> > People who lean heavy on symbols to support them have found they need
> > the flexibility CL symbols have. Many people have learned not to lean
> > on symbols find they don't need the extra support of CL symbols. I
> > don't see a conflict between these two.
>
> Me neither.
I think alot of the noise in this thread could be avoided if people would
all take you at your word for that. For some reason, so many people take "I
don't understand why X" as meaning "I think X is bad" (even "I disagree with
X" is not the same as "X is bad")
I'm quite sure most of us agree that above all else, it is the flexibility
of lisp that gives it its greatest appeal. Symbolic programming is just one
of the many "Lisp ways" and I'd be surprised if the statement of Erik's you
cited was meant to be taken at face value outside of the discussion of
symbols as identity vs symbols as values.
> To go back to the natural language analogy, if I'm talking with someone
> (supposing we're both speaking English) and we discover that we're using
> the same word (like 'symbol') to mean different things, Common Lisp forces
> me, in order to continue communicating, to say something like "OK, I'm
> going to define my own language here, which is just like English, except
> that in my language the word "symbol" means ...." as opposed to, "We're
> both still speaking the same language, but when I say 'symbol' (which is
> still the same word you're using when you say 'symbol') I mean ..." The
I liked your "lisp" "lithp" example but it has been culled from what I am
replying to. I would simply suggest that a package solution for this is
having a "GEEK" package that uses "ENGLISH" and when inside that package, if
you need it, you use english:lisp. I think this is still a very close
analogy to what goes on in natural discourse. Context is usually inferred
by various subtle mechanism (this would be analogous to the explicit use of
in-package) and the ambiguous situations in natural discourse often require
the analogy of english:lisp (ie a little extra communication such as "and
when I said lisp just now, I meant the speech impediment" or an emphasis of
some kind to clue in the listener that they need to double check their
assumptions)
--
Coby Beck
(remove #\Space "coby 101 @ bigpond . com")
···@jpl.nasa.gov (Erann Gat) writes:
> To jump ahead a few steps (I'm taking a stand now) I am coming to the
> conclusion that the "right" answer is to have good support for *both*
> packages and first-class environments. Unfortunately, the current state
> of the world forces you to choose between one or the other (and if you
> want first-class environments forces you to abandon both Common Lisp and
> Scheme).
I've for years claimed these two issues were orthogonal and non-competing.
We had this problem actively in the ISLISP standardization. There
were a lot of proponents of module systems. Interestingly enough,
though, there were not _any_ actual implementations of one that anyone
on the committee advanced as workable, not even any of the proponents
of a module system. So we didn't include one.
I have to say, as just a point of personal commentary, that module
systems seem to be something that the advocates (not just here but in
a number of forums) want to _first_ get support for and _then_
implement... as if they can't figure out how to make it and they're
hoping their conuqered opponents in some public debate will get them
over some hurdle. Maybe that's not the issue, I don't know. I just
know that for years I've been through this discussion over and over
and over again, and in the end, no one ever shoves a module system
proposal in front of my face and says "it would work this way". Nor
does anyone say "Here's a vendor who's been convinced it's in his
economic interest [or reasonable facsimile thereof] to do it and who
likes it." I'm not saying it can't be done. It's just a mystery to
me why if it can be done, it hasn't been... There's quite a diverse set
of implementations and world views out there, and it's a conspicuous
omission. Nor do I hear people who tried complaining that there is a
technical barrier impeding their success.
Like most other things in the language design process, the right thing
is to work up from the ground grassroots style. Get some vendor to
support you, get a user base, show success, try to convince others
using your success...
> To go back to the natural language analogy, if I'm talking with
> someone (supposing we're both speaking English) and we discover that
> we're using the same word (like 'symbol') to mean different things,
> Common Lisp forces me, in order to continue communicating, to say
> something like "OK, I'm going to define my own language here, which
> is just like English, except that in my language the word "symbol"
> means ...." as opposed to, "We're both still speaking the same
> language, but when I say 'symbol' (which is still the same word
> you're using when you say 'symbol') I mean ..." The latter feels
> like a better metaphor to me in many (perhaps even most but not all)
> situations.
Your remark seems to take the posture that the act of definition doesn't
work in an object-oriented way with inheritance, importing, exporting,
etc. It sound like "a language" is a heavyweight item that
is not defined often. But if languages are lightweight, that's not so.
CLTL2 isn't the same language as ANSI CL, I think, but some would
disagree. Fortunately, there's a large shared subset.
My take on this is again that indeed when I'm talking nerdspeak at
dinner, I'm not talking English. I remember being on my way to a Lisp
meeting somewhere and running into someone from France going to the
same meeting, Jerome Chailloux, I think. I showed him some proposal
and he wizzed right through reading it. I said I was impressed by the
speed he read English. "English?" he replied. "This isn't English.
It's Lisp." (It was _about_ Lisp. But his point was well-taken...)
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> I have to say, as just a point of personal commentary, that module
> systems seem to be something that the advocates (not just here but in
> a number of forums) want to _first_ get support for and _then_
> implement...
FWIW, my aim in this exchange is not to get support for anything, but to
simply understand the issues so I don't go down blind alleys.
> as if they can't figure out how to make it and they're
> hoping their conuqered opponents in some public debate will get them
> over some hurdle. Maybe that's not the issue, I don't know.
I know how to implement what (I think) I want as an interpreter, and even
as a compiler, but not as an *efficient* compiler. So I guess my real
choice (given my current level of technical expertise in the matter) is
not so much between Lisp and environments, but between a slow Lisp that
does what I want and a fast one that doesn't. (Actually, my situation is
more complicated than that because I'm also working under some severe
political constraints, but we can ignore those for the purposes of this
discussion I think.)
> I just
> know that for years I've been through this discussion over and over
> and over again, and in the end, no one ever shoves a module system
> proposal in front of my face and says "it would work this way".
I don't want to shove anything under anyone's face, but suppose I pointed
to T and said "it would work this way." What would be your response?
(This feels really bizzare. I'm using your own invention as a
counterexample to your claim that no one ever showed you a working module
system.)
> > To go back to the natural language analogy, if I'm talking with
> > someone (supposing we're both speaking English) and we discover that
> > we're using the same word (like 'symbol') to mean different things,
> > Common Lisp forces me, in order to continue communicating, to say
> > something like "OK, I'm going to define my own language here, which
> > is just like English, except that in my language the word "symbol"
> > means ...." as opposed to, "We're both still speaking the same
> > language, but when I say 'symbol' (which is still the same word
> > you're using when you say 'symbol') I mean ..." The latter feels
> > like a better metaphor to me in many (perhaps even most but not all)
> > situations.
>
> Your remark seems to take the posture that the act of definition doesn't
> work in an object-oriented way with inheritance, importing, exporting,
> etc. It sound like "a language" is a heavyweight item that
> is not defined often.
But (natural) languages (of the sort that you need to invoke to suppoer
the portugese:no vs english:no distinction) *are* heaviweight items that
aren't defined very often.
> But if languages are lightweight, that's not so.
> CLTL2 isn't the same language as ANSI CL, I think, but some would
> disagree. Fortunately, there's a large shared subset.
Language identity is a continuum, not a dichotomy.
The meaning of the English word "window" has taken on a new meaning since
the advent of GUIs. But that doesn't mean that if I say "I have a window
on my screen" that I'm speaking a different language than if I say "I have
a window in my house." (And if you want to insist that I am, then
consider, "I was so frustrated by the behavior of the window system that I
threw the computer out the window.")
> My take on this is again that indeed when I'm talking nerdspeak at
> dinner, I'm not talking English. I remember being on my way to a Lisp
> meeting somewhere and running into someone from France going to the
> same meeting, Jerome Chailloux, I think. I showed him some proposal
> and he wizzed right through reading it. I said I was impressed by the
> speed he read English. "English?" he replied. "This isn't English.
> It's Lisp." (It was _about_ Lisp. But his point was well-taken...)
What language are we having this conversation in then?
E.
In article <···············@shell01.TheWorld.com>, Kent M Pitman wrote:
> My take on this is again that indeed when I'm talking nerdspeak at
> dinner, I'm not talking English. I remember being on my way to a Lisp
> meeting somewhere and running into someone from France going to the
> same meeting, Jerome Chailloux, I think. I showed him some proposal
> and he wizzed right through reading it. I said I was impressed by the
> speed he read English. "English?" he replied. "This isn't English.
> It's Lisp." (It was _about_ Lisp. But his point was well-taken...)
Yes, it's quite easy to learn as much of a language as necessary
for reading technical texts in it. Unfortunately, that is still
very, very far away from being able to communicate in any sensible
way. Not only does your vocabulary sound really weird for native
speakers, you are still totally unable to understand what normal
people are telling you. In the worst case, a typical conversation
between a typical european nerd and a typical American would go like
this:
Me: HELO Nils
Her: Hello, my name is Jackie, not Neels
Me: REQUEST BEER COUNT=1 VOLUME=.5 UNIT=litre
Jackie: Huh?
Me: SABME
Jackie: HUH? Hey Barney, this asshole told me to ``sab'' him! Does
that mean somethin dirty?
Me: FRAME REJECT
Barney: Listen, mister: You have your drink and leave the lady alone
or you get the fuck outa here, you understand?
Me: FRAME REJECT
Me: SABME
Barney: Hey Jack! Get the shotgun, the motherfucker's crazy!
Me: FRAME REJECT
Jack: You wonna get sabbed, man? Here you go: <BOOM!>
Me: INTERNAL ERROR, CORE DUMPED
Watching (and listening to) American DVDs helps a bit.
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
···@jpl.nasa.gov (Erann Gat) writes:
> > I just
> > know that for years I've been through this discussion over and over
> > and over again, and in the end, no one ever shoves a module system
> > proposal in front of my face and says "it would work this way".
>
> I don't want to shove anything under anyone's face,
I wasn't meaning it in any bad way--I was just meaning no one has made it
plainly apparent. I almost wish they would...
> but suppose I pointed
> to T and said "it would work this way." What would be your response?
> (This feels really bizzare. I'm using your own invention as a
> counterexample to your claim that no one ever showed you a working module
> system.)
I'd want to see the specific operations you propose. Certainly there are
module systems in other languages, but languages being ecologies, I'd want
to see the specific attach points at which the transplant is to be done.
Just to pick one random example: Introducing locales would affect more
than just CL. For example, T made a new locale for every call to
#. and you can't just toss such a deatil into CL compatibly.
> But (natural) languages (of the sort that you need to invoke to suppoer
> the portugese:no vs english:no distinction) *are* heaviweight items that
> aren't defined very often.
I didn't have to pick anything that big. I picked those to show that this
comes up naturally, not to say this is the only place it happens.
The fact that the CL glossary (much smaller than English) defines a new
jargon module on top of English that redefines many words, like car,
illustrates this.
(I'm not sure why this matters, btw. Just answering your question.)
> > But if languages are lightweight, that's not so.
> > CLTL2 isn't the same language as ANSI CL, I think, but some would
> > disagree. Fortunately, there's a large shared subset.
>
> Language identity is a continuum, not a dichotomy.
>
> The meaning of the English word "window" has taken on a new meaning since
> the advent of GUIs. But that doesn't mean that if I say "I have a window
> on my screen" that I'm speaking a different language than if I say "I have
> a window in my house." (And if you want to insist that I am, then
> consider, "I was so frustrated by the behavior of the window system that I
> threw the computer out the window.")
This example neither supports nor refutes either my nor your posture, btw.
Neither an environment model nor a package model, in and of itself, supports
the construction of mixed symbols in the same sentence. The sentence contains
no binding forms that would bind a lexical environment, nor does it contain
a reliable active mechanism for disambiguating these references absent an
examination of the meaning of the sentence.
> > My take on this is again that indeed when I'm talking nerdspeak at
> > dinner, I'm not talking English. I remember being on my way to a Lisp
> > meeting somewhere and running into someone from France going to the
> > same meeting, Jerome Chailloux, I think. I showed him some proposal
> > and he wizzed right through reading it. I said I was impressed by the
> > speed he read English. "English?" he replied. "This isn't English.
> > It's Lisp." (It was _about_ Lisp. But his point was well-taken...)
>
> What language are we having this conversation in then?
Well, I didn't say he didn't speak English. He was just making a
point that his reading speed is faster in this jargonified language
layer. It's really proof of little, other than to say that it's
'natural' (i.e., occurs spontaneously due to forces not conscious of
this conversation or some similar agenda) to model language as I have.
In article <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
> I'd want to see the specific operations you propose. Certainly there are
> module systems in other languages, but languages being ecologies, I'd want
> to see the specific attach points at which the transplant is to be done.
>
> Just to pick one random example: Introducing locales would affect more
> than just CL. For example, T made a new locale for every call to
> #. and you can't just toss such a deatil into CL compatibly.
Well, hurm, OK. I'm a little bit hesitant because this is not my area of
expertise, and this group has been pretty unforgiving of naive technical
proposals in the past, but what the hell.
I was referring to T environments, not locales (which IIUC are two
entirely different things).
An environment is simply an association map between symbols and values.
Since I'm crawling out on a limb here anyway I might as well go all the
way. I'm going to propose using the REF operator introduced in earlier
discussions. REF is a generic function that works as follows:
(ref a x) == (aref a x) when a is a vector
(ref h x) == (gethash x h) when h is a hashmap
(ref a x) == (assoc a x) when a is an alist
(ref p x) == (getf x p) when p is a plist
REF is setfable.
A MAP is any class that implements REF and obeys the following invariant:
(progn (setf (ref m x) y) (ref m x)) --> y
If (ref m x) == y then we say that x is bound to y in m.
An ENVIRONMENT comprises a pair of maps, a VALUE map and a FUNCTION map.
(We can also add a property map.) (Side note: if we allow the value map
and the function map to be the same map then we get a Lisp1 environment.)
An environment also contains a (possibly empty) list of PARENT
environments.
(ref e x) when x is an environment proceeds as follows. If x is bound to
y in the value map of e then (ref e x) --> y. Otherwise the parent
environment are searched in order for a binding of x in their value maps.
The first binding found is returned. If no binding is found an exception
is raised.
To access the function map we have to introduce a new function, fref,
which works just like ref except that it searches the function maps of the
environments for a binding.
(setf (ref e x) ...) does destructive assignment if x is bound in e,
otherwise it creates a new binding of x in e's value map. (setf (fref e
x) ...) works analogously for e's function map. (i.e. (setf (ref e x)
...) can do assignment in a parent environment, but can create bindings
only in the environment itself.)
There is an environment, the REPL-ENV, which defines the bindings of
symbols for the read-eval-print loop. Exactly how this environment is
accessed is a little tricky, but let's just assume for now that we can get
to it somehow.
(symbol-value x) is redefined to be (ref repl-env x)
(symbol-function x) is redefined to be (fref repl-env x)
Now the tricky part: we have a chicken-and-egg problem in finding the
repl-env. We can't bind it to a global variable because the value of the
variable is defined in terms of the repl-env, which would be circular.
The T solution was to define a settable function, (repl-env), that
returned the repl-env. My memory of this is fuzzy, but I think in T you
could get yourself into a situation where you lost all pointers to the
repl-env function and really screw yourself. A Common-Lispy solution
would be to simply require every environment to have a binding for the
symbol *repl-env* to an environment (analogous to the role of the binding
of *package* in CL today).
In a Lisp with threads, whenever a thread is spawned, the repl-env is set
to a new environment whose parent is the environment of the spawning
thread. This gives every thread its own set of dynamic bindings for
symbols.
There are some tricky issues on how all this interacts with the compiler,
but I think I'll stop here for now and get some feedback on what I've
written so far first.
> > But (natural) languages (of the sort that you need to invoke to suppoer
> > the portugese:no vs english:no distinction) *are* heaviweight items that
> > aren't defined very often.
>
> I didn't have to pick anything that big. I picked those to show that this
> comes up naturally, not to say this is the only place it happens.
>
> The fact that the CL glossary (much smaller than English) defines a new
> jargon module on top of English that redefines many words, like car,
> illustrates this.
>
> (I'm not sure why this matters, btw. Just answering your question.)
It matters because what happens when you create a new jargon feels to me
much more analogous to creating a new environment than creating a new
package.
> This example neither supports nor refutes either my nor your posture, btw.
> Neither an environment model nor a package model, in and of itself, supports
> the construction of mixed symbols in the same sentence. The sentence contains
> no binding forms that would bind a lexical environment, nor does it contain
> a reliable active mechanism for disambiguating these references absent an
> examination of the meaning of the sentence.
Yes, that was actually my point. To understand the sentence above you
have to treat "window" as a keyword (or a string), not a symbol (according
to your definitions of those words).
E.
···@jpl.nasa.gov (Erann Gat) writes:
> Here's the relevance it has to me: in exploring the surprising (to me)
> affinity that people have for packages, I discovered that there is a whole
> style of programming (which is called here "symbolic programming") of
> which I was only dimly aware, and which some people whose views are
> respected, notably you, believe is absolutely central to the entire notion
> of programming in Lisp. All this comes as a surprise to me, for reasons
> I've discussed in excruciating detail elsewhere and won't
> belabor here.
Maybe I just don't understand what all this is all about, but
frankly I doubt that you, as you claim, write everything in a
``Scheme way''. You didn't provide any code examples of yours to
support this claim, anyway ;-) You also said you like to program
in an object oriented style in CL; now I wonder: Isn't CLOS
itself an excellent example for doing things ``the Lisp way''? I
mean, no matter where you look, it uses symbols and keywords for
pretty much everything. Just take SLOT-VALUE, for instance? Do
you think if CLOS was designed by a Schemer in and for Scheme, it
would look the same?
Regards,
--
Nils Goesche
Ask not for whom the <CONTROL-G> tolls.
PGP key ID #xC66D6E6F
In article <··············@darkstar.cartan>, Nils Goesche <···@cartan.de> wrote:
> ···@jpl.nasa.gov (Erann Gat) writes:
>
> > Here's the relevance it has to me: in exploring the surprising (to me)
> > affinity that people have for packages, I discovered that there is a whole
> > style of programming (which is called here "symbolic programming") of
> > which I was only dimly aware, and which some people whose views are
> > respected, notably you, believe is absolutely central to the entire notion
> > of programming in Lisp. All this comes as a surprise to me, for reasons
> > I've discussed in excruciating detail elsewhere and won't
> > belabor here.
>
> Maybe I just don't understand what all this is all about, but
> frankly I doubt that you, as you claim, write everything in a
> ``Scheme way''. You didn't provide any code examples of yours to
> support this claim, anyway ;-)
Well, it's not really my claim. It's what I've been told by others.
> You also said you like to program
> in an object oriented style in CL; now I wonder: Isn't CLOS
> itself an excellent example for doing things ``the Lisp way''? I
> mean, no matter where you look, it uses symbols and keywords for
> pretty much everything. Just take SLOT-VALUE, for instance? Do
> you think if CLOS was designed by a Schemer in and for Scheme, it
> would look the same?
No. If CLOS were designed by a Schemer it would look like T or Oaklisp.
In fact, I use wrapper macros for defclass and defmethod (which I call
DEFINE-CLASS and DEFINE-METHOD) that allow me to program in more of a
T-like style, though I don't really change the underlying semantics.
I don't use slot-value. I only reference slots inside methods defined by
DEFINE-METHOD, and DEFINE-METHOD takes as an argument a list of slots to
be referenced. It then automatically defines a local symbol macro for
each slot. So where one would normally write:
(defmethod foo ((x blarg) ...)
(... (slot-value x 'this) ... (slot-value x 'that) ...))
I write:
(define-method (foo (x blarg this that) ...)
(... this ... that ...))
This is very Schemely because everything is lexically scoped.
(My version of DEFINE-METHOD assumes single-argument dispatch because
that's what I use 99% of the time. On the rare occasions that I need a
multi-method I fall back on defmacro, though it is possible to define a
multi-dispatch version of a lexically scoped define-method.)
On the other hand, I do use slot-value for writing introspective methods.
For example, I have an infrastructure for describing containment
hierarchies where objects automatically insert themselves into appropriate
slots according to their types. But none of this code uses symbols as
anything other than uniquified strings (I think). Hm... now that I think
about it, I would get into trouble if I wanted to use two different
classes that happened to have the same name. But how often does that
really happen?
Obdisclaimer: I am not advocating this programming style, I am merely
describing it so that people can critique it.
E.
On Sat, 13 Apr 2002 12:43:40 -0800, Erann Gat <···@jpl.nasa.gov> wrote:
>In article <··············@darkstar.cartan>, Nils Goesche <···@cartan.de>
wrote:
>
>> You also said you like to program
>> in an object oriented style in CL; now I wonder: Isn't CLOS
>> itself an excellent example for doing things ``the Lisp way''? I
>> mean, no matter where you look, it uses symbols and keywords for
>> pretty much everything. Just take SLOT-VALUE, for instance? Do
>> you think if CLOS was designed by a Schemer in and for Scheme, it
>> would look the same?
>
>No. If CLOS were designed by a Schemer it would look like T or Oaklisp.
That's an information-free statement :) I'm not that familiar with T,
but from your example below the object style seems similar to that of
New Flavors which sits firmly in the middle of the Common Lisp
tradition.
>In fact, I use wrapper macros for defclass and defmethod (which I call
>DEFINE-CLASS and DEFINE-METHOD) that allow me to program in more of a
>T-like style, though I don't really change the underlying semantics.
>
>I don't use slot-value. I only reference slots inside methods defined by
>DEFINE-METHOD, and DEFINE-METHOD takes as an argument a list of slots to
>be referenced. It then automatically defines a local symbol macro for
>each slot. So where one would normally write:
>
>(defmethod foo ((x blarg) ...)
> (... (slot-value x 'this) ... (slot-value x 'that) ...))
>
>I write:
>
>(define-method (foo (x blarg this that) ...)
> (... this ... that ...))
>
>This is very Schemely because everything is lexically scoped.
I guess, though this seems to more an encapsulation issue than a
lexical scope issue.
I assume you know this is equivalent to
(defmethod foo ((x blarg) ...)
(with-slots (this that) x
...))
>(My version of DEFINE-METHOD assumes single-argument dispatch because
>that's what I use 99% of the time. On the rare occasions that I need a
>multi-method I fall back on defmacro, though it is possible to define a
>multi-dispatch version of a lexically scoped define-method.)
>
...
>Obdisclaimer: I am not advocating this programming style, I am merely
>describing it so that people can critique it.
I don't know whether or not this is a "Common Lisp" style, or why you
or anyone should care. On the one hand you are blowing off one of the
fundamental features of CLOS: methods are decoupled from classes.
You're also ignoring the functional interface to slots through
accessor functions. On the other hand, it's certainly Common Lisp
style to define layers of macros to transform the language into
something that's a better fit for your problem domain.
Tim
Erik Naggum <····@naggum.net> writes:
> Geez, for a few days, now, we had an abuse-free zone here because you
> nutjobs seemed to be able to focus on something other than attacking me,
> but I guess it is impossible for lunatics like you and Thomas Bushnell to
> actually discuss anything at all unless I agree with your point of
> view.
Oh, I think you're quite right. It's clear that the abuse comes only
from certain people, and that it's due to the ever-diligent efforts of
people like you when we have an abuse-free zone.
Thanks for keeping it so nice and pleasant here, and doing your part
to keep the abuse out of c.l.l.
Thomas
Erik Naggum <····@naggum.net> writes:
> Why _are_ you guys so upset about what I think?
Oh, I'm not upset about it at all. I used to be upset, but now I see
I was wrong. Somehow I thought you were being abusive and mean, but
it's now clear to me that I was mistaken. What a foolish error on my
part! However, now that this is all cleared up, I have nothing but
praise for your eager and constructive efforts to make c.l.l a
pleasant and constructive--and abuse-free--zone.
Thomas
* Thomas Bushnell, BSG
| Oh, I'm not upset about it at all. I used to be upset, but now I see I
| was wrong. Somehow I thought you were being abusive and mean, but it's
| now clear to me that I was mistaken. What a foolish error on my part!
| However, now that this is all cleared up, I have nothing but praise for
| your eager and constructive efforts to make c.l.l a pleasant and
| constructive--and abuse-free--zone.
I "appreciate" the more mellow and prozac-influenced Thomas, but maybe
you should ask for a lower dosage?
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum <····@naggum.net> writes:
> I "appreciate" the more mellow and prozac-influenced Thomas, but maybe
> you should ask for a lower dosage?
Oh no, not mellow at all. I just think you are an excellent model and
we should all try our best to be more like you.
I'm sure everyone can agree that this would make c.l.l a much more
pleasant place.
Thomas
In article <··············@becket.becket.net>, Thomas Bushnell, BSG wrote:
> Erik Naggum <····@naggum.net> writes:
>
>> I "appreciate" the more mellow and prozac-influenced Thomas, but maybe
>> you should ask for a lower dosage?
>
> Oh no, not mellow at all. I just think you are an excellent model and
> we should all try our best to be more like you.
>
> I'm sure everyone can agree that this would make c.l.l a much more
> pleasant place.
>
> Thomas
Well I can not speak for anyone else, but I much prefer Erik to you.
And from a purely practical POV Erik is also very useful to have around.
He can and has helped numerous people in this group, myself included,
with lisp problems.
marc
Erik Naggum <····@naggum.net> writes:
> Quit being so goddamn personal. If you have defend yourself all the
> time, at least talk to a shrink, and do not attack _me_ all the time.
It's a shame, the way everybody here is always making it personal. I
mean, Erik just never posts nasty diatribes against other peoples'
character, and for no particular reason, they just hate him so much.
It's a shame that poor Erik is always getting attacked, and that
people are unable to simply stay focused on the topic. I mean, Erik
would never launch a personal attack unless someone first attacked
him, right? It's other people who provoke him, after all.
Thomas
* Thomas Bushnell, BSG
| It's a shame, the way everybody here is always making it personal.
How come _you_ suddenly decide to open your sewer and dump here, again?
You need some serious help, too. This is not the place to get it.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum <····@naggum.net> writes:
> * Thomas Bushnell, BSG
> | It's a shame, the way everybody here is always making it personal.
>
> How come _you_ suddenly decide to open your sewer and dump here, again?
Oh no, I'm on your side Erik. I do think it's a shame they way you
are a victim of such unwarranted abuse. After all, you are so nice to
everyone, and people just make these unwarranted attacks on you. It's
quite right for you to be bothered by the way people are so hostile.
Thomas
* Thomas Bushnell, BSG
| Oh no, I'm on your side Erik.
What does it take to make you regain your senses? Electroshock?
This newsgroup is not group therapy for nutjobs like you and Erann Gat.
Quit bothering people with your coping problems and just _*THINK*_, OK?
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum <····@naggum.net> writes:
> * Thomas Bushnell, BSG
> | Oh no, I'm on your side Erik.
>
> What does it take to make you regain your senses? Electroshock?
>
> This newsgroup is not group therapy for nutjobs like you and Erann Gat.
> Quit bothering people with your coping problems and just _*THINK*_, OK?
Yes, that's quite right. And thank you for all your kind advice. I'm
now thinking, and I'm so grateful for the jillion manifest kindnesses
you give. It really is so unfair that you get treated harshly by
people when you're really so terribly nice!
Thomas
* Dorai Sitaram
| All novice problems should be so easily self-correctable.
Would that that were true. The problem is that they are not.
| I think a much more pervasive and uncorrectable malaise is intended when
| the bad influence of Scheme is cited.
Somehow, a Scheme freak believes that Scheme is "right" and whatever else
he has to do to make things work is "wrong", and therefore never learns
what is right in any other language that does not very forcefully prove
him fundamentally wrong. It is much harder to make someone believe they
are wrong when they are right some of the time than none of the time.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
* Kent M Pitman <······@world.std.com>
| This seems to me a simple matter of proper education. I doubt it's a
| fundamental property of the universe.
It seems to me that Scheme victims are far less aware of the need for
re-education that users of any other language. This is a level of
language-design arrogance that comes with most Scheme texts and material
that rubs off on students who think they have found the One True Design.
| My bet is that the same is said for Lisp.
Well, if "Lisp" here means Common Lisp, I have never seen it.
| Education is itself a mind-altering drug and it warps people's ability to
| think in the way they would have thought absent it.
True, but I said thinking straight, not keep thinking crooked.
| If it warrants resistance, it is not for the per se reason that it alters
| minds.
No, but any "education" that causes people to become unable to cope with
the world the live in, when they could cope just fine previously, has
good reason to be met with resistance and the association with brain-
washing cults is normally not welcome.
> However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based
> training.
| Could this just mean one is in the pipe?
Nope. This is policy.
| Does anyone know why this would be there? If it is a bad experience, can
| we find out what?
I have tried, but I have only off-the-record comments and reasoning. If
you have more success, that would be great. However, what I have heard
is the old "Scheme frightens people", which is true, and then "Scheme is
a Lisp", which is not, so "Lisp frightens people" follows, which it
_should_ not even if the second premise were true. For a long time, my
conclusion has been that Scheme really is harmful to people's ability to
think properly and results in a perspective on programming and on problem
solving in general that requires the equivalent of psychotherapy to find
out what horrible "childhood" you had and how it affects your adult life.
In general, I have found Scheme to be an extraordinarily _limiting_
language, not the least in the warped idea that all code must be elegant
and all solutions minimalistic, that "dirty tricks" must be avoided at
all cost, etc. This fear of getting dirt under their nails is perhaps
the most damaging effect of working with an over-elegant language that
places so much focus on doing The Right Thing. The fact that the Scheme
language is so incredibly _tiny_ is a testament to how _little_ you can
do in real life that qualify as The Right Thing. If more One-Right-Thing
Maximally-Elegant Final Solutions were possible, they would have gotten
into Scheme, right? So _everything_ else just has to be dirtier than
Scheme, but this never dawns on some people. Some people react with
hostility to the expressed notion that "we're clean, you're not" that
comes with languages that have excluded everything that was not "clean"
enough. (Any similarity to dissing the unwashed masses is intentional.)
I think Scheme _deserves_ its really bad reputation and should not be
taught or used. I would rather teach people Java and rescue them later
than even tell them about Scheme. At least they will have gotten some
exposure to that dirty old Real World and Common Lisp will be seen as an
improvement. Too many Scheme victims regard anything after Scheme to be
inferior and uglier and this simply does not help them to learn anything.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
> * Kent M Pitman <······@world.std.com>
> | This seems to me a simple matter of proper education. I doubt it's a
> | fundamental property of the universe.
>
> It seems to me that Scheme victims are far less aware of the need for
> re-education that users of any other language. This is a level of
> language-design arrogance that comes with most Scheme texts and material
> that rubs off on students who think they have found the One True Design.
I somewhate agree with the perception of the "One True Design" arrogance.
There is a beauty in the simplicity of Scheme, but that beauty is all there
is to it. It's nice thing to gander and gawk and perhaps admire from afar,
thats about it. Once the realities of the programming world appear, and
Stuff starts getting bolted on to the system, you lose that beauty and
elegance. Once at that stage, the question then becomes "Why Scheme?". Why
indeed.
> > However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based
> > training.
>
> | Could this just mean one is in the pipe?
>
> Nope. This is policy.
>
> | Does anyone know why this would be there? If it is a bad experience,
can
> | we find out what?
>
[ no books because Scheme, ergo Lisp, is Scary...*snipped* ]
I would have simply thought that the market for Lisp books in general was
simply too mature. Pretty much any CL book in the past 10 years is
completely relevant and up to date today.
They only common CL book that CL itself has actually "passed by" is CLTL2.
I think that a good book on CLIM (something beyond an API reference, more
like "The CLIM Way"), or a more focused book on Lisp Programming Techniques
and Optimization (going beyond PAIP and On Lisp) would be nice. But, I can
see those being fairly niche books, and perhaps too vendor dependant.
> I think Scheme _deserves_ its really bad reputation and should not be
> taught or used. I would rather teach people Java and rescue them later
> than even tell them about Scheme. At least they will have gotten some
> exposure to that dirty old Real World and Common Lisp will be seen as an
> improvement. Too many Scheme victims regard anything after Scheme to be
> inferior and uglier and this simply does not help them to learn
anything.
The only thing that Java really lacks as a good First Language, I think, is
an interactive environment to play around in. The only good thing Scheme
would do is put the silly fear of S-Expressions and first-class functions
out of peoples minds. They were my biggest hurdles getting into this
environment.
Will Hartung
(·····@msoft.com)
In article <············@news.nntpserver.com>, Will Hartung wrote:
>
> "Erik Naggum" <····@naggum.net> wrote in message
> ·····················@naggum.net...
>> * Kent M Pitman <······@world.std.com>
>> | This seems to me a simple matter of proper education. I doubt it's a
>> | fundamental property of the universe.
>>
>> It seems to me that Scheme victims are far less aware of the need for
>> re-education that users of any other language. This is a level of
>> language-design arrogance that comes with most Scheme texts and material
>> that rubs off on students who think they have found the One True Design.
>
> I somewhate agree with the perception of the "One True Design" arrogance.
> There is a beauty in the simplicity of Scheme, but that beauty is all there
> is to it. It's nice thing to gander and gawk and perhaps admire from afar,
> thats about it. Once the realities of the programming world appear, and
> Stuff starts getting bolted on to the system, you lose that beauty and
> elegance. Once at that stage, the question then becomes "Why Scheme?". Why
> indeed.
I wonder if it still has beauty in your eyes when you come to that
conclusion. How can something that turns out to be bad have beauty
at all? Maybe it first appears to be beautiful, then your taste
ripes, and it isn't beautiful anymore. Is Scheme Kitsch? :-)
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
"Nils Goesche" <······@cartan.de> wrote in message
··················@ID-125440.news.dfncis.de...
> In article <············@news.nntpserver.com>, Will Hartung wrote:
> > I somewhate agree with the perception of the "One True Design"
arrogance.
> > There is a beauty in the simplicity of Scheme, but that beauty is all
there
> > is to it. It's nice thing to gander and gawk and perhaps admire from
afar,
> > thats about it. Once the realities of the programming world appear, and
> > Stuff starts getting bolted on to the system, you lose that beauty and
> > elegance. Once at that stage, the question then becomes "Why Scheme?".
Why
> > indeed.
>
> I wonder if it still has beauty in your eyes when you come to that
> conclusion. How can something that turns out to be bad have beauty
> at all? Maybe it first appears to be beautiful, then your taste
> ripes, and it isn't beautiful anymore. Is Scheme Kitsch? :-)
As they say, Beauty is in the eye, etc.
If the beauty of Scheme is its simplicity, then that beauty is pervasive and
can't be clouded.
If the beauty is that it provides a nice "start from scratch" foundation to
build upon, then no matter what you clump on to it, that original foundation
is still there.
But if a programmer sees that simplicity and thinks that it will translate
into their real world application, that beauty then becomes a lot of work
and loses its luster.
If you have to bolt on all of this extra functionality to the base package
to get your work done, then the question is do you really still have Scheme,
and not something else.
As a completely non sequitor analogy from the world of motorcycles (yes, I
agree this is basically off topic for c.l.l, but at least I'm not bitching
about Erik...). In some circles of the motorcycling world, one may encounter
"a trike conversion", essentially having two wheels in the back rather than
one. When someone does this, do they still have a motorcycle? If someone
converts a Honda Gold Wing thusly, why not spring for something like a Miata
instead?
Certainly the owner wants to keep some bond with motorcyles that a Miata
doesn't offer, but he's not riding a motorcycle, IMHO. For me, the beauty of
the motorcycle is gone, the dynamics of the riding experience. But for the
owner, it apparently is not. Perhaps they value the more open feeling one
would get riding a trike, or the comraderie he gets by associating with the
other Gold Wing folks who will welcome him with open arms, trike or no.
So, for me, bolting a Common Lisp compatability package onto Scheme gets me
neither. Lumping a bunch of "non-standard" and incompatible stuff together
removes the "scheme-ness" of Scheme. You end up coding in those frameworks,
not necessarily Scheme. People using VC++ for Windows apps are more writing
MFC than C++, for example.
Therefor, the luster goes away because with the added cruft, the simplicity
get occluded. I was blinded by Schemes simplicity, the novelty of its
idioms. But then I found that they're a lot extra work, and soon those
idioms became barriers, or were written away and "simplified". Soon after,
you're not using Scheme at all, rather some bastard son that no one else is
using.
But, hey, that's just me.
Will Hartung
(·····@msoft.com)
Erik Naggum <····@naggum.net> writes:
> * Kent M Pitman <······@world.std.com>
> | This seems to me a simple matter of proper education. I doubt it's a
> | fundamental property of the universe.
>
> It seems to me that Scheme victims are far less aware of the need for
> re-education that users of any other language. This is a level of
> language-design arrogance that comes with most Scheme texts and material
> that rubs off on students who think they have found the One True Design.
It seems that getting over Scheme can be a difficult task. However,
it's clear that getting over the getting over of Scheme can take even
longer ...
Patrick W:
> It seems that getting over Scheme can be a difficult task.
i am sceptical. it is only a programming language, and in a very large
majority of young programmers, not even close to being the first language;
that it itself may lessen its (claimed) impact. moreover, what is it that
is so important, so sticky and hard to relearn? what is the real claim
about learning? what is the claim about cognition? is the claim supportable?
is this sapir/worf rearing its head again? it is so much fun to bash basic,
perl, scheme or whatever we hate today, but the actual cognitive effects
of learning these languages are not properly studied, so far as i know.
one may as well claim that those who learn french or turkish are
forever damaged to ever do good lisp programming... :-/
this stuff is all very muddled.
oz
--
it seems so long and so many parentheses ago... -- thomas a. russ
ozan s yigit <··@blue.cs.yorku.ca> writes:
> Patrick W:
>
> > It seems that getting over Scheme can be a difficult task.
>
> i am sceptical. it is only a programming language, and in a very large
> majority of young programmers, not even close to being the first language;
In my experience, languages at MIT were taught as religions not as
sciences.
I was told once by one instructor that it wasn't obvious how otherwise
to grade these things if there were not "absolute" answers. The best
example of this was a mid-term in compiler design where I was asked if
gotos were (a) good or (b) bad. This surely made it easier to grade,
but did not contribute toward nor measure a robust understanding.
I was also asked to take hardware courses that seemed tedious and
pointless to me because I had planned a career in software, not
hardware. Most professors having risen to power in the EE side of the
recently-renamed EE&CS department, I was again told that it was
important to take some hard sciences even if they were irrelevant so
they could be sure they had graded me properly.
Then again, Sussman designed a series of courses on hardware taught
using Scheme, but I was specifically excluded because I was "bad data"
for his "experiment", in which he wanted to have only blank slate
people that he could mold. If I succeeded (something I was paying MIT
good money to ensure, by the way), that would not help him with what
was effectively his research experiment in indoctrinating students.
IMO, this particular decision, more than any single other, accounts
for why I ultimately was forced out of the EE&CS department and ended
up getting a degree in Philosophy. (As I understand it, this kind of
"taking refuge" in another department happened to several other well
known Lisp people, though usually it was the Math or Architecture
department they ended up in. The reason cited to me was that these
departments required few core courses and offered lots of elective
room.) I suspect that at many other universities, the math
department, not the EE department, is the genesis of the CS
department, and that this accounts for the differences in leaning
between the mathemeticians and engineers among us. But always,
whether we are "of the department" or "escaping the department",
politics and religion _is_ in play. It's just different what the
politics are.
It's probably like the issue of speaking a language with an
accent--everyone has an accent, but no one can hear their own.
Politics works likewise. And anwyay, how can any teacher be
passionate about something they teach without exposing more than just
the topic domain. If you can make a topic relevant, you have driven
connective tethers into the fabric of the real world, and in so doing
you have made it hard to indulge change without at least the risk of
picking up some of those stakes.
> that it itself may lessen its (claimed) impact. moreover, what is it that
> is so important, so sticky and hard to relearn?
Why are some religions harder to unlearn than others? Have you ever had
a family member taken in by a cult? Or can you imagine what it would be
like to hear someone say "religion can be unlearned" or the fights that
result if you even suggest it "should" be unlearned?
> what is the real claim
> about learning? what is the claim about cognition? is the claim supportable?
Formally? Statistically? Religious claims are hard to make supportable
because it's hard to care enough to take data without being strongly
on one side of the religious gap or another, and by virtue of your own
position you become scientifically distrusted. And it's hard to get someone
on the other side of the gap to perform a similar experiment in good faith,
if such were even meaningful. ("Is it symmetric to compare the difficulty
of deprogramming a CL person into Scheme and vice versa? Who would consent
to being the guinea pig? How would you get a large enough sample to be
statistically representative, peoples' backgrounds being so hard to control?")
> is this sapir/worf rearing its head again? it is so much fun to bash basic,
> perl, scheme or whatever we hate today, but the actual cognitive effects
> of learning these languages are not properly studied, so far as i know.
I don't like to see these discussions get contentious and
mean-spirited, but I also don't like to see things for which there are
only anecdotal observations not get logged because it contributes to a
false sense that just because an effect is not measurable, that there
is nothing there to be measured. The social sciences (so-called
"soft" sciences) are just plain harder to deal with than the so-called
"hard" sciences (one might call them the "easy" sciences in this
regard; dealing largely with reproducible data sets, often homogeneous
data, etc.)
> one may as well claim that those who learn french or turkish are
> forever damaged to ever do good lisp programming... :-/
Actually, a good argument can be made linguistically that learning certain
languages hinders others. There is good standing evidence that certain
concept formation happens through puberty and then reifies in brain
structures that are far less maleable in adulthood. In language, for
example, the number of what I call "hash buckets for sounds" gets fixed
at some point, accounting for the well-known difficulties of speakers of
some asian languages where r/l differentiation is unimportant (or less
important) and probably "hashed to the same bucket" and the problems I had
when dealing with trying to learn German a few years back where I don't
have enough "ch"/"sch"/"sh" sounds to reliably get the sound right there.
It's not a documented issue that there are equivalent effects in computation
that we will see more of as langauge instruction moves earlier into childhood
learning, but that doesn't make it unworthy of discussion. Serious scientific
discussion probably begins with heated proto-discussion just like this.
One might wish that scientists just spontaneously knew which areas to study,
but I bet the path to that point is rarely so clean and straightforward.
Never underestimate the possible effect of exasperation and other such "low"
emotions as having driven science along through the years...
> this stuff is all very muddled.
It may or may not help at this point to quote from the "AI Koans"
(teaching parables, I think written by Danny Hillis):
In the days when Sussman was a novice, Minsky once came to
him as he sat hacking at the PDP-6.
"What are you doing?", asked Minsky.
"I am training a randomly wired neural net to play
Tic-Tac-Toe" Sussman replied.
"Why is the net wired randomly?", asked Minsky.
"I do not want it to have any preconceptions of how
to play", Sussman said.
Minsky then shut his eyes.
"Why do you close your eyes?", Sussman asked his teacher.
"So that the room will be empty."
At that moment, Sussman was enlightened.
Kent M Pitman wrote:
>
> In my experience, languages at MIT were taught as religions not as
> sciences.
>
> I was told once by one instructor that it wasn't obvious how otherwise
> to grade these things if there were not "absolute" answers. The best
> example of this was a mid-term in compiler design where I was asked if
> gotos were (a) good or (b) bad. This surely made it easier to grade,
> but did not contribute toward nor measure a robust understanding.
>
> I was also asked to take hardware courses that seemed tedious and
> pointless to me because I had planned a career in software, not
> hardware. Most professors having risen to power in the EE side of the
> recently-renamed EE&CS department, I was again told that it was
> important to take some hard sciences even if they were irrelevant so
> they could be sure they had graded me properly.
>
> Then again, Sussman designed a series of courses on hardware taught
> using Scheme, but I was specifically excluded because I was "bad data"
> for his "experiment", in which he wanted to have only blank slate
> people that he could mold. If I succeeded (something I was paying MIT
> good money to ensure, by the way), that would not help him with what
> was effectively his research experiment in indoctrinating students.
> IMO, this particular decision, more than any single other, accounts
> for why I ultimately was forced out of the EE&CS department and ended
> up getting a degree in Philosophy. (As I understand it, this kind of
> "taking refuge" in another department happened to several other well
> known Lisp people, though usually it was the Math or Architecture
> department they ended up in. The reason cited to me was that these
> departments required few core courses and offered lots of elective
> room.) I suspect that at many other universities, the math
> department, not the EE department, is the genesis of the CS
> department, and that this accounts for the differences in leaning
> between the mathemeticians and engineers among us. But always,
> whether we are "of the department" or "escaping the department",
> politics and religion _is_ in play. It's just different what the
> politics are.
>
hmm, that sounds a little weird...
I am self taught as far as programming is concerned, and probably around
"puberty" (11-14) I was using basic, assembler, and some c (I think I
messed with pascal but nothing serious).
I started with basic, then started moving to assembler, then to c.
I do not hold anything technical as "religion", nor do I consider holding
really strong views.
other than programming I like math (but not so much). I used to also fiddle
with electronics but lack a large interest (probably more the thought that
I can't make the hardware how I want it, but I can mess with the next level
up, ie: the os).
> It's probably like the issue of speaking a language with an
> accent--everyone has an accent, but no one can hear their own.
> Politics works likewise. And anwyay, how can any teacher be
> passionate about something they teach without exposing more than just
> the topic domain. If you can make a topic relevant, you have driven
> connective tethers into the fabric of the real world, and in so doing
> you have made it hard to indulge change without at least the risk of
> picking up some of those stakes.
>
>> that it itself may lessen its (claimed) impact. moreover, what is it that
>> is so important, so sticky and hard to relearn?
>
> Why are some religions harder to unlearn than others? Have you ever had
> a family member taken in by a cult? Or can you imagine what it would be
> like to hear someone say "religion can be unlearned" or the fights that
> result if you even suggest it "should" be unlearned?
>
>> what is the real claim
>> about learning? what is the claim about cognition? is the claim
>> supportable?
>
> Formally? Statistically? Religious claims are hard to make supportable
> because it's hard to care enough to take data without being strongly
> on one side of the religious gap or another, and by virtue of your own
> position you become scientifically distrusted. And it's hard to get
> someone on the other side of the gap to perform a similar experiment in
> good faith,
> if such were even meaningful. ("Is it symmetric to compare the difficulty
> of deprogramming a CL person into Scheme and vice versa? Who would
> consent
> to being the guinea pig? How would you get a large enough sample to be
> statistically representative, peoples' backgrounds being so hard to
> control?")
>
religion: I have allways been pushed with religious views, but I can not
understand by myself as I don't really have "intuition" about anything
really religious.
actually I find it nearly impossible to really think about the issues
(thoughts come in with possible religious implications and are blanked out,
independent of side).
> is nothing there to be measured. The social sciences (so-called
> "soft" sciences) are just plain harder to deal with than the so-called
> "hard" sciences (one might call them the "easy" sciences in this
> regard; dealing largely with reproducible data sets, often homogeneous
> data, etc.)
>
I tried a little to understand psychology, no real luck. I don't
paticualarly understand psychology myself.
I can't seem to figure what problems are myself, and what are others', or
really if the problems exist.
I spend some time trying to "unlearn" much of my emotional stuff, but as
far as I can tell I have allways been doing that. my mind seems to have a
problem with itself. I can't really locate a "core" problem, and trying to
mess with them causes weird effects.
there doesn't seem to be a way to "unlearn" emotional stuff without
recreating it based on other emotions, and I lack a strong reference to
disprove anything...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
cr88192 <·······@hotmail.com> writes:
> I do not hold anything technical as "religion", nor do I consider
> holding really strong views.
I'm not so sure any of us are free of treating the technical as religion.
I'll try to elaborate on what I mean by religion in this context.
First, it is a property of religions that (with respect to science, at
least), they are based on the arbitrary rather than the necessary. Of
course, "faith" requires that one believe the arbitrary matters; but
if one doesn't offer "faith", that doesn't leave one nearly so constrained.
In Physical Science, the fact that gravity attracts rather than repels
is perhaps arbitrary, but we don't have the option of a universe
constructed any other way. (I'm sure there are aspects of physics
that are not so obvious and that do also rely on the arbitrary in the
absence of evidence, but even then, a process exists for discerning
new evidence and for dislodging the aribtrary.)
In Computer "Science", the fact that even one means true and zero
means false is an arbitrary choice. In Lisp, for example, 0 is true
and NIL is false. In MOO both 0 and {} are false. These matters are
simply definitional, not scientific.
To test these facts in computer science is therefore to test the
ability to take in and store trivia--internal consistency among the
arbitrary. An argument can be constructed that the ability to store
and regurgitate the history of my favorite soap opera, The Young and
the Restless, uses the same skills.
I'd bet the careers of some people can be made and broken over whether
they can remember that ";" goes _after_ a statement in some languages
or _between_ statements in another... when perhaps all we should
diagnose is that if they think it should be a different way, they
belong in another programming language.
Second, it is a property of religions that ritual matters as much as
accomplishing a goal.
What are we to say of people who when presented with a problem are
able to solve it but not using the technique that is offered?
One of the first things I learned in the study of computers at MIT was
the notion of the black box--that if you knew the behavioral spec of
something, you could reason about it without concern about what was
inside. This is the core of all informational technology that allows
us to talk about anything from Babbage's machines to Turing's machines
to Intel's machines as if they are the same. And yet, I was told I
could not graduate in Computer Science without a strong mathematical
understanding of what happens at the wave electronics level of circuit
components. I'm sorry, but I had important stuff to study and I just
did not care. Repeatedly I was told I must waste my time on such
courses, but while I'm tremendously grateful that _someone_ makes
hardware, I just don't think it needs to be me. And, moreover, it has
not hindered my career in the so-called science of computers that I
ultimately left for the Philosophy department and never did really get
that wave form understanding.
That it mattered was religion, because any reasonable definition of
science said that it was provable that I could get away without
knowing these things. If there were not the ability to abstract above
a particular layer of technology, all of us would be drowning in
complexity right now. Mind you, I didn't mind knowing circuits even
down to the flip/flop level, because that was all digital. And I
didn't mind a day spent on someone telling me what was below digital.
But I didn't need to be sitting in labs measuring electrical levels
and doing Z-transforms in order to be competent to reason about
closures; indeed, I would make the bold (and equally religious) claim
that _had_ I spent that time in that class, I might not have taken
something that I ended up taking that turned out to be more relevant.
I'm not saying that computer science is bunk because it involves
religion. I'm just saying that we should understand when we're doing
science and when we're merely pushing propaganda. Because we move in
and out of both of these and they are very different activities.
We should arm students to _cope_ with propaganda, not try to deny that
it's happening when it does. Back to relevance to Lisp, the fact that
we don't do this is probably one reason that people have trouble
defending Lisp against other languages when there are often perfectly
good reasons right at hand, or when the arguments on the other side
are nothing more than blind allegiance to an alternate religion.
Kent M Pitman wrote:
> cr88192 <·······@hotmail.com> writes:
>
>> I do not hold anything technical as "religion", nor do I consider
>> holding really strong views.
>
> I'm not so sure any of us are free of treating the technical as religion.
>
well, maybe none of us are free totally, but people can be more or less
free. personally I think it has to do with "worldview", which as far as I
can tell I hold a "post-modernist" worlview.
I do understand your point.
> I'll try to elaborate on what I mean by religion in this context.
>
> First, it is a property of religions that (with respect to science, at
> least), they are based on the arbitrary rather than the necessary. Of
> course, "faith" requires that one believe the arbitrary matters; but
> if one doesn't offer "faith", that doesn't leave one nearly so
> constrained.
>
> In Physical Science, the fact that gravity attracts rather than repels
> is perhaps arbitrary, but we don't have the option of a universe
> constructed any other way. (I'm sure there are aspects of physics
> that are not so obvious and that do also rely on the arbitrary in the
> absence of evidence, but even then, a process exists for discerning
> new evidence and for dislodging the aribtrary.)
>
normally referred to a guess and check, and often just guess...
personally I believe in string theory, and I had thought up an acceptably
sensible means by which the kind of system described could be emulated
(what I considered a "variable dimension" system, where the number of
dimensions can vary from point to point and dimensions may be
collapsed/expanded without interference to others...). I doubt my system is
at all "real", but at least for me it seems "interesting".
I am not really into physics, so I don't know what they think.
brief: in my system space would be a point, a point can be expanded into a
circle, a circle into a cylinder (with a coiled dimension spiraling along
the inside), that may be intern a nother cylinder and so forth. this
however was only one way of looking at it, as from another perspective
(given with some not too obvious definitions) it would resemble normal
space (11dimensions, smaller ones used for polarity/nuclear attraction/...).
this will be too much a pain to explain here...
the problem: space is "integral", below a certain distance there is no
"partial" location...
> In Computer "Science", the fact that even one means true and zero
> means false is an arbitrary choice. In Lisp, for example, 0 is true
> and NIL is false. In MOO both 0 and {} are false. These matters are
> simply definitional, not scientific.
>
> To test these facts in computer science is therefore to test the
> ability to take in and store trivia--internal consistency among the
> arbitrary. An argument can be constructed that the ability to store
> and regurgitate the history of my favorite soap opera, The Young and
> the Restless, uses the same skills.
>
not too much into soaps. ok, on my own do I even really watch tv? not
really, not too long ago I watched tv and the "verichip" thing seemed
disturbing for some reason...
> I'd bet the careers of some people can be made and broken over whether
> they can remember that ";" goes _after_ a statement in some languages
> or _between_ statements in another... when perhaps all we should
> diagnose is that if they think it should be a different way, they
> belong in another programming language.
>
reasonably simple to rember (one of the trivia I almost forgot about
pascal...).
> Second, it is a property of religions that ritual matters as much as
> accomplishing a goal.
>
ok, I guess I am guilty of that, as often I am more concerned with the code
quality over actually getting it done (though I tend to try new things
along the way).
I have seen this a bit in the linux community as well, as they tend to be
more concerned with unix tradition than making things good.
> What are we to say of people who when presented with a problem are
> able to solve it but not using the technique that is offered?
>
like at school, gaussian vs. gauss-jordan elimination vs. "normal"
elimination. I use whatever one fits best (when inversing a matrix by hand
I am damn well using gauss-jordan, as to me it is less a pain, as back
substitution is just added work).
it doesn't really help in math classes that I have taught myself math to a
higher degree than hs goes... just making class all the more boring.
at least if they were talking about calculus or logic or something, at
least something I know not as well (instead of algebra, which I have been
using since I was young).
personally I believe that math classes butcher the stuff they are teaching,
then they act like people are incapable of understanding. much less they
teach "how to do it", but not "what it is", or "why use this teqnique?",
nor do they offer proof.
this is just my oppinion.
> One of the first things I learned in the study of computers at MIT was
> the notion of the black box--that if you knew the behavioral spec of
> something, you could reason about it without concern about what was
> inside. This is the core of all informational technology that allows
> us to talk about anything from Babbage's machines to Turing's machines
> to Intel's machines as if they are the same. And yet, I was told I
> could not graduate in Computer Science without a strong mathematical
> understanding of what happens at the wave electronics level of circuit
> components. I'm sorry, but I had important stuff to study and I just
> did not care. Repeatedly I was told I must waste my time on such
> courses, but while I'm tremendously grateful that _someone_ makes
> hardware, I just don't think it needs to be me. And, moreover, it has
> not hindered my career in the so-called science of computers that I
> ultimately left for the Philosophy department and never did really get
> that wave form understanding.
>
black box is a useful metaphore (except when it reaches hype porpotions...).
> That it mattered was religion, because any reasonable definition of
> science said that it was provable that I could get away without
> knowing these things. If there were not the ability to abstract above
> a particular layer of technology, all of us would be drowning in
> complexity right now. Mind you, I didn't mind knowing circuits even
> down to the flip/flop level, because that was all digital. And I
> didn't mind a day spent on someone telling me what was below digital.
> But I didn't need to be sitting in labs measuring electrical levels
> and doing Z-transforms in order to be competent to reason about
> closures; indeed, I would make the bold (and equally religious) claim
> that _had_ I spent that time in that class, I might not have taken
> something that I ended up taking that turned out to be more relevant.
>
yep...
> I'm not saying that computer science is bunk because it involves
> religion. I'm just saying that we should understand when we're doing
> science and when we're merely pushing propaganda. Because we move in
> and out of both of these and they are very different activities.
>
> We should arm students to _cope_ with propaganda, not try to deny that
> it's happening when it does. Back to relevance to Lisp, the fact that
> we don't do this is probably one reason that people have trouble
> defending Lisp against other languages when there are often perfectly
> good reasons right at hand, or when the arguments on the other side
> are nothing more than blind allegiance to an alternate religion.
>
understood.
before lisp I supported c, my view was: sure we can do better but as long
as they aren't worse. I would rather code in c than c++ or java as
arguably: c is more portable than the others, a c compiler is far more
common than a c++ compiler, and especially more common than a java vm; c++
only really offers "sugar" features compared with c; and finally java is
just weak and slow.
but I will not argue this as fact, as this is my oppinion.
now I see lisp, and I know that there is better (at least in certain
respects), in my mind c still has an edge over lisp in a few contexts (ie:
ease of kernel dev), but one can feel welcome to prove me wrong.
if I were to design a language I would: add some cool security features
(albeit not to the "core" language); merge functions and macros; and make
plans on how it is to run well on "bare metal" (I am aware that many cl
implementations can do this already...); maybe I will add some c/assembler
style weirdness (ie: byte mapped structures, ...).
no real work has been done.
my current os uses a scheme variant (ease of implemetation mostly). I know
scheme a little better than cl, but I am learning cl as well.
I am not looking for any scheme vs. cl arguments here.
I have also looked at some "functional" languages, last time I looked I
didn't particularly understand them, but I can allways try again.
sorry I can't seem to reply to your main point, the concept seems difficult
to reply to...
hype is allways a problem and the best one can do is try to avoid spreading
hype, and maybe take a good look at whatever and also take a look at the
competition...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
> First, it is a property of religions that (with respect to science,
> at least), they are based on the arbitrary rather than the
> necessary. Of course, "faith" requires that one believe the
> arbitrary matters; but if one doesn't offer "faith", that doesn't
> leave one nearly so constrained.
I think you've managed to come up with a definition of religion that
almost no religious person would agree with....
I note that the scientific method says that you can, as it were,
`doubt your way to knowledge' while the religious viewpoint, or at
least that of religions that are based on faith, is that you can
`believe your way to knowledge'.
Both methods aim at knowledge.
One might call the religious viewpoint `the science of person' (using
the word `science' in its more primitive sense to mean knowing), where
its methodological postulate, analogous to that of systematic doubt in
the scientific method, is that one can only know persons and their
relationships by stepping into those relationships with those people
(the I-THOU that Martin Buber talks about).
This fits in with the thread in the newsgroup a while ago, where
people were talking about knowing things from the inside as opposed to
knowing them as observers only.
It's possible that there are things that can only be known by this
method, in the same way that there are things that we've only been
able to learn about through the scientific method.
Because programming languages are at the boundary of person and
machine, it's at least possible that a science of person is helpful in
understanding them.
> Second, it is a property of religions that ritual matters as much as
> accomplishing a goal.
There are those who would see this as a confusion of paradigms, trying
to apply a mechanical mode of thinking to an area where it does not
apply. `True religion' can be understood relationally.
For those, doubtless few, who are curious, the Christian teaching of
the trinity, rather than simply being dismissable as obscurantist
nonsense, can be seen as involving the assertion that relationship is
central to the nature of God and therefore central to the nature of
reality. It's also central to our natures as being `in the image of
God'.
I think your article would be better if you substituted the term
`politics' for `religion'. Politics is the, uh, discipline that
involves allocation of resources, and a sub-discipline of that is to
get people to do things they don't want, or that aren't in their own
immediate (and sometimes ultimate) best interest. Your experiences at
MIT were political, not religious. You gave this away when you
remarked (in a previous posting) that it matters whether the Computer
Science department came from EE or math. People in the EE department
desire, for resource-allocation (i.e. political) reasons that people
study EE, so they make CS students do it, whereas people in the math
department are free from this agenda.
Propaganda is another political sub-discipline. To the extent that it
is used in the name of religion, it is false religion, since
propaganda avoids any attempt at relationship and seeks to `interfere
with the will,' as Goebbels puts it, of the hearer. It's possible,
and there is, perhaps, historical warrant to believe, that people who
are conscious of the `science of person' will be more sensitive to
having their personhood interfered with and so more resistant to
propaganda.
--
Fred Gilham ······@csl.sri.com
"In the 20th century, more citizens were killed by their own
governments than by foreign enemies....totalitarianism first of all
regards its own people as the enemy." --- Arnold Beichman
"Fred Gilham" <······@snapdragon.csl.sri.com> wrote a lot of sensible stuff
in message ···················@snapdragon.csl.sri.com...
I basically agree. For me religion has to do with "private" yet
transpersonal experience, which is a kind of subjective experience, whereas
science has to do with the objective, preferably repeatable. Since the
notion of objectivity (or intersubjectivity) is based on the subjective,
religion lies at the core of science (as does philosophy, but in a
different way).
Within a religious community a science-like process can occur when enough
people have had experiences that are comparable enough to discuss them at
the intersubjective level. This is not really different from people
discussing a repeated measurement - there too, the discussion is ultimately
about the comparable subjective experiencing that measurement. Maybe both
were hallucinating when reading the meter..
This is no longer even on a tangent. Are Lisp concepts objective?
--
Biep
Kent M Pitman <······@world.std.com> wrote in message news:<···············@shell01.TheWorld.com>...
> IMO, this particular decision, more than any single other, accounts
> for why I ultimately was forced out of the EE&CS department and ended
> up getting a degree in Philosophy. (As I understand it, this kind of
> "taking refuge" in another department happened to several other well
> known Lisp people, though usually it was the Math or Architecture
> department they ended up in.
I hadn't heard this story about Pitman's odyssey from novice to
Grandmaster of LISP. That must have been around when I moved from
Math to EE�mainly because, as a young professor, they offered me much
more time to hack. (In the 80s I moved to the Media Lab, I think for
much the same reason.)
> In the days when Sussman was a novice, Minsky once came to
> him as he sat hacking at the PDP-6.
[some lines deleted]
> Minsky then shut his eyes.
>
> "Why do you close your eyes?", Sussman asked his teacher.
>
> "So that the room will be empty."
>
> At that moment, Sussman was enlightened.
In fact that story is basically true, except that my reply was not so
obscure; it was,
"It will still have as many preconceptions, only now you won't know
what they are."
······@media.mit.edu (Marvin Minsky) writes:
> Kent M Pitman <······@world.std.com> wrote in message
> news:<···············@shell01.TheWorld.com>...
> > In the days when Sussman was a novice, Minsky once came to
> > him as he sat hacking at the PDP-6.
> [some lines deleted]
> > Minsky then shut his eyes.
> > "Why do you close your eyes?", Sussman asked his teacher.
> > "So that the room will be empty."
> > At that moment, Sussman was enlightened.
> In fact that story is basically true, except that my reply was not so
> obscure; it was,
> "It will still have as many preconceptions, only now you won't know
> what they are."
One of the few cases where myth is less admirable than the fact, at
least IMO. This response makes one think more directly of the
relationship between the NN, the game, and the programmer, which, I
think, is better than the vague notion of you wandering around a room
with your eyes closed. :)
Unfortunately, the real version not quite so pithy as the one in the
popularized version of the story, and I suppose that it doesn't fit in
with the Koan style. At least the popularized version did have the
desired impact on me, and remains tied for my favorite Koan.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Kent M Pitman <······@world.std.com> writes:
> The best example of this was a mid-term in compiler design where I
> was asked if gotos were (a) good or (b) bad.
I guess the "correct" comp-sci answer would have been: "Yes".
p.s. you're shredding my illusions about MIT. :-)
--
It would be difficult to construe Larry Wall, in article
this as a feature. <·····················@netlabs.com>
From: Thien-Thi Nguyen
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <kk9ofger8f4.fsf@glug.org>
Alain Picard <·······················@optushome.com.au> writes:
> p.s. you're shredding my illusions about MIT. :-)
"tool and die" read my ex-gf to me. i knew it would be ex, pre-ex.
thi
[sorry for the lateness of this response.]
Kent M Pitman <······@world.std.com> writes:
[interesting MIT years]
> ... And anwyay, how can any teacher be
> passionate about something they teach without exposing more than just
> the topic domain. If you can make a topic relevant, you have driven
> connective tethers into the fabric of the real world, and in so doing
> you have made it hard to indulge change without at least the risk of
> picking up some of those stakes.
this is a good point, though i don't really know how much passionate
teaching people get these days for their early programming language
education. also, young minds are impressionable, but also very elastic;
so perhaps nothing very important happens under most circumstances in
most modern teaching enviroments.
> > that it itself may lessen its (claimed) impact. moreover, what is it that
> > is so important, so sticky and hard to relearn?
>
> Why are some religions harder to unlearn than others? Have you ever had
> a family member taken in by a cult? Or can you imagine what it would be
> like to hear someone say "religion can be unlearned" or the fights that
> result if you even suggest it "should" be unlearned?
i don't know, and i have not had a family member in a cult. i suppose i can
imagine about unlearning a religion, though i never thought it as appropriate
to quickly classify different language groups, whether scheme or whatever as
religions, given the impact of real religions in people's lives. sure, we see
many people who display religious zeal in their pursuit of their language and
distaste of other languages and people who use them, but hand-picked examples
never make for worthwhile generalizations...
> > what is the real claim
> > about learning? what is the claim about cognition? is the claim supportable?
> Formally? Statistically? Religious claims are hard to make supportable
> because it's hard to care enough to take data without being strongly
> on one side of the religious gap or another, and by virtue of your own
> position you become scientifically distrusted. And it's hard to get someone
> on the other side of the gap to perform a similar experiment in good faith,
> if such were even meaningful.
someone should first spell out in respectable detail what learning scheme
is supposed to have done to the learner. but whatever that is, it is not an
an issue that divides the world in two; it is at best, as someone once put
it colorfully, another adolescent pimple in the face of computer science.
it is not hard to find disinterested researchers who could (if they wanted
to) build and perform appropriate experiments.
> I don't like to see these discussions get contentious and
> mean-spirited, but I also don't like to see things for which there are
> only anecdotal observations not get logged because it contributes to a
> false sense that just because an effect is not measurable, that there
> is nothing there to be measured.
perhaps i'm confused about the difference between opinion pieces and
anecdotal observations; i see more of the former. anyhow, i don't assume
there is nothing there to measure.
> > one may as well claim that those who learn french or turkish are
> > forever damaged to ever do good lisp programming... :-/
>
> Actually, a good argument can be made linguistically that learning certain
> languages hinders others. There is good standing evidence that certain
> concept formation happens through puberty and then reifies in brain
> structures that are far less maleable in adulthood.
i knew i should have chosen something other than natural languages; you
assumed a native language vs some other later language. the example meant
to suggest french as a second language, and turkish as a second language
and their effects when learned (say) in puberty...
> It's not a documented issue that there are equivalent effects in computation
> that we will see more of as langauge instruction moves earlier into childhood
> learning, but that doesn't make it unworthy of discussion.
right. i have friends who thought lisp1.5, perl, tcl and other languages
to their youngsters. i will do that too someday, so i'm very interested and
actually think the point is very worthy of discussion.
> Serious scientific
> discussion probably begins with heated proto-discussion just like this.
indeed. and you know, there already was a language experiment we can
look at. whatever happened to all those logo kids? how is their cognitive
development? have learning logo improved them? are they worse programmers
now than they may have been, given that they started with logo instead of
the real thing? ;) maybe we can ask papert.
thanks for the nice koan. i note with some disappointment that not many
koans came about after that MIT batch. i wonder what happened... no zen
in CS anymore?
oz
---
imagined forest -
we would be lost
without it. [oz/2002]
ozan s yigit <··@blue.cs.yorku.ca> writes:
> Patrick W:
>
> > It seems that getting over Scheme can be a difficult task.
>
> i am sceptical. it is only a programming language, and in a very large
> majority of young programmers, not even close to being the first language;
> that it itself may lessen its (claimed) impact. moreover, what is it that
> is so important, so sticky and hard to relearn? what is the real claim
> about learning? what is the claim about cognition? is the claim supportable?
> is this sapir/worf rearing its head again? it is so much fun to bash basic,
> perl, scheme or whatever we hate today, but the actual cognitive effects
> of learning these languages are not properly studied, so far as i know.
> one may as well claim that those who learn french or turkish are
> forever damaged to ever do good lisp programming... :-/
It's likely that you overlooked my second point, which was the main
one. But let me explain what I meant anyway.
My "knowledge" of Scheme comes entirely from reading c.l.l. I don't
know the Scheme language, but that doesn't matter in this context. I
was talking about what Scheme (apparently) symbolises to some people.
As I understand it, Kent regards languages as political parties which
represent the values and goals of their respective communities. He
argues that the values and goals of the Scheme and CL communities are
so fundamentally different that languages like Java are closer in
spirit to Common Lisp than Scheme is.
If I understand Erik's position correctly, he's:
(a) Extremely annoyed by the widely held notion that Scheme is a kind
of "clean", "pure", distilled essence of Lisp.
(b) Pissed off that Common Lisp's reputation as an industrial strength
development tool is warped by association with a beautiful but useless
academic curio.
(c) Extremely annoyed by his perception that Scheme advocates have
misappropriated the qualities that are regarded as beautiful and
elegant in programming languages, which has the effect of making
anything but Scheme (and worse, anything designed to ease the
difficulties of "real world" programming) somehow "dirty" or "impure".
As for how Scheme might be a hindrance to learning Common Lisp, that
wasn't my main point to begin with. But I would guess, based on what
I've gleaned from reading this newsgroup, that Schemers are more
likely to employ a strictly side-effect free style, use recursion when
iteration would be simple and natural, and generally use a small
Scheme-like subset of Common Lisp, overlooking natural CL idioms. It
may be that Scheme has a more insidious influence (eg. as Erik claims,
the attitude that they already know "Lisp" makes them blind to what
they don't know), but all I can see are _minor_ and easily corrected
influences.
Hence my second point. _Getting over getting over_ Scheme seems to be
harder (or take longer) than getting over Scheme. I meant that in
several ways:
1. If one has bought the Scheme "religion" eg. cherishing the ideas of
beauty, elegance, simplicity and minimalism at the expense of
practicality (which, incidentally isn't specific to Scheme; it's
present in Eiffel and FP communities, and probably many other
places), it seems to leave a psychological scar when one eventually
loses that religion. As with real world religions or cults, it
sometimes causes those who have lost their "faith" to take it upon
themselves to "disabuse" others of their "affliction", even if
those people do not believe themselves to be afflicted.
2. Since I've been reading c.l.l., I have not seen much, if any,
Scheme advocacy here. I haven't seen "Scheme freaks" denigrating
Common Lisp. (Not that I can recall anyway, or none that I took
seriously). And I've been reading the group fairly regularly for
more than two years. This makes me believe there are probably
either deeper personal issues or long-standing historical political
issues that are not easy to "get over".
3. Erik's story about the reasons for O'Reilly's reluctance to publish
new Lisp books suggests that many people who were introduced to
Scheme at university (and were frightened off by it) will not
consider using *any* Lisp again. That is, they find it easy to "get
over" Scheme, but find it hard to "get over getting over"
Scheme.
Patrick W <······@yahoo.com.au> writes:
> 2. Since I've been reading c.l.l., I have not seen much, if any,
> Scheme advocacy here. I haven't seen "Scheme freaks" denigrating
> Common Lisp. (Not that I can recall anyway, or none that I took
> seriously). And I've been reading the group fairly regularly for
> more than two years. This makes me believe there are probably
> either deeper personal issues or long-standing historical political
> issues that are not easy to "get over".
I haven't seen any either.
But there is the perception from some (Erik Naggum, included) that
Scheme fans do nothing but post pro-Scheme propaganda here. I've
reviewed the messages in question, and I've discovered that (as usual)
Erik is entirely right. It is only due to the block-headedness of
people like my bad old self that thought Scheme could be discussed
without propaganda. I have since discovered (thanks to Erik) exactly
what kind of messages he considers "propaganda".
When I had asked him for specific article references that exhibited
this pro-Scheme propagandizing, he didn't provide any. But I
misunderstood his motives; I incorrectly thought that he didn't have
any to point to, but I see now that it was like asking a fish to point
out where the water is.
Thomas
[sorry, did not see this message earlier]
Patrick W:
> It's likely that you overlooked my second point, which was the main
> one. But let me explain what I meant anyway.
i skipped the second part; the first part is an old refrain [substitute
basic, cobol, lisp, apl, prolog ... and reformulate :-] that has not been
discussed much for some reason (probably not too many people take it
seriously) so i responded.
> My "knowledge" of Scheme comes entirely from reading c.l.l. I don't
> know the Scheme language, but that doesn't matter in this context. I
> was talking about what Scheme (apparently) symbolises to some people.
OK. i have no comment on that. i cannot argue the politics, values or goals
of a language that is no longer a part of my daily programming. i'm however
interested in any (real or imagined) cognitive issues with these languages.
[*]
> As for how Scheme might be a hindrance to learning Common Lisp, that
> wasn't my main point to begin with. But I would guess, based on what
> I've gleaned from reading this newsgroup, that Schemers are more
> likely to employ a strictly side-effect free style, use recursion when
> iteration would be simple and natural, and generally use a small
> Scheme-like subset of Common Lisp, overlooking natural CL idioms.
OK.
> It may be that Scheme has a more insidious influence ...
> but all I can see are _minor_ and easily corrected
> influences.
well, that is all i see as well but i am not in a good position to
see better. anyhow, perhaps something for a panel discussion in the
next PLDI conference.
oz
---
[*] Linda McIver, Damian Conway, "Seven Deadly Sins of Introductory
Programming Language Design" Proc. Software Engineering: Education and
Practice (SE:E&P'96) University of Otago, Dunedin, NZ, pp.309-316,
IEEE Computer Society, 1996.
"Patrick W" <······@yahoo.com.au> wrote in message
···················@acropolis.localdomain...
> [Maybe] Schemers are more likely to [...] use recursion
> when iteration would be simple and natural.
I know I am on a tangent, but, generalising, Schemers just don't see a
difference between the two. A Schemer would't speak of "tail call
elimination" (which would main e.g. turning them into non-tail calls), and
would gladly use the do-loop or let-loop provided in Scheme. It is just
that on a theoretical plane they see iteration as a special case of
recursion, with some nice properties.
In practice, that means that they may not think of using the specific
iteration constructs that CL provides because they expect that the
equivalent recursive code will lead to the same efficiency behaviour.
This is a point indeed, as a proficient Scheme programmer using CL may at
times forget to accommodate to the reality of the difference in CL, and end
up writing inefficient code. I should not think this to be a major point,
however.
Does anybody have real-life data on this happening with people who came
from Scheme (or an FP) but had programmed CL for, say, more than a month?
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> A Schemer would't speak of "tail call elimination" (which would main
> e.g. turning them into non-tail calls),
Okay, the thing with terminology is that if there are two potentially
obvious meanings, and one is insane, you should give the people using
the term the benefit of the doubt and figure they mean the non-insane
meaning. "Tail call elimination" doesn't mean eliminating the "tail"
part, it means eliminating the "call" part.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
"Thomas F. Burdick" <···@apocalypse.OCF.Berkeley.EDU> wrote in message
····················@apocalypse.OCF.Berkeley.EDU...
> "Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
>
> > A Schemer would't speak of "tail call elimination" (which would main
> > e.g. turning them into non-tail calls),
>
> Okay, the thing with terminology is that if there are two potentially
> obvious meanings, and one is insane, you should give the people using
> the term the benefit of the doubt and figure they mean the non-insane
> meaning.
In this group? Surely you jest.
"Thomas F. Burdick" <···@apocalypse.OCF.Berkeley.EDU> wrote in message
····················@apocalypse.OCF.Berkeley.EDU...
> "Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
>
> > A Schemer would't speak of "tail call elimination" (which would main
> > e.g. turning them into non-tail calls),
>
> Okay, the thing with terminology is that if there are two potentially
> obvious meanings, and one is insane, you should give the people using
> the term the benefit of the doubt and figure they mean the non-insane
> meaning. "Tail call elimination" doesn't mean eliminating the "tail"
> part, it means eliminating the "call" part.
Take it easy - I should have labelled the parenthesised part with a
smiley..
But in fact you don't want to eliminate the call either: the second
function needs to be called.
What you don't want is to introduce a useless return frame. In a standard
rewriting implentation, no such stack frame turns up unless you perform
what Schemers tend to call "tail call pessimisation", i.e. you have to go
out of your way to make a tail call INefficient.
All I meant to say was that the notion "tail call elimination" in the
context of Scheme rests on a false premiss, to wit that there is something
nasty that needs to be eliminated, whereas the whole nasty something simply
doesn't turn up in the first place.
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote in message
···················@ID-63952.news.dfncis.de...
>
> In a standard rewriting implentation, no such stack frame turns up
> unless you perform what Schemers tend to call "tail call pessimisation",
> i.e. you have to go out of your way to make a tail call INefficient.
>
> All I meant to say was that the notion "tail call elimination" in the
> context of Scheme rests on a false premiss, to wit that there is something
> nasty that needs to be eliminated, whereas the whole nasty something simply
> doesn't turn up in the first place.
I don't know what you mean by `standard rewriting implementation', but
I can assure you that proper tail recursion *is* an issue in many
Scheme implementations. These two papers,
Marc Feeley, James S. Miller, Guillermo J. Rozas, Jason A. Wilson.
"Compiling Higher-Order Languages into Fully Tail-Recursive Portable C".
d�partement d'informatique et r.o., Universit� de Montr�al.
Rapport technique 1078. Aout 1997.
and
Miller, James S. and Guillermo J. Rozas.
"Garbage Collection is Fast, But a Stack is Faster".
MIT AI Lab. AIM-1462. March 1994.
address this issue. The first is a comparison of various techniques used
by Scheme -> C compilers to ensure proper tail recursion. The authors note
that among diverse implementations, the `cost' of supporting tail recursion
amounts to about a factor of two.
The second paper compares traditional technique of allocating continuations
on the stack to the currently popular technique of allocating them on the
heap. The conclude that using a stack can be up to three times faster than
using a heap for allocating continuation frames.
Both of these papers illustrate that using a stack is an important implementation
technique. However, using a stack will make your program non-tail recursive
unless you make the effort to free the continuation frame before the
tail call, i.e., you perform `tail call elimination'. (Note that if you
design the hardware right, you can get the benefits of both the stack and
the heap without the drawbacks of either.)
"Joe Marshall" <·············@attbi.com> wrote in message
··························@typhoon.ne.ipsvc.net...
> I don't know what you mean by `standard rewriting implementation',
I meant something like in this toy implementation:
http://groups.google.com/groups?hl=nl&lr=&newwindow=1&selm=9fnhkt%2450v0e%2
41%40ID-63952.news.dfncis.de
> but I can assure you that proper tail recursion *is* an issue
> in many Scheme implementations.
I don't disagree with that, but I consider these problems to be primarily
related to the optimisation techniques used, not to the notion of tail
calling per se. Of course the use of a call stack is a pretty common kind
of optimisation, but it is still something that in my mind should be
separated out. Using a stack is not inherent in the notion of evaluating a
Lisp expression.
But I agree one can defend the other view by taking an applied, as opposed
to theoretical, stand.
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> I know I am on a tangent, but, generalising, Schemers just don't see a
> difference between the two.
No. Schemers generally describe iteration as a subset of recursion.
CL programmer have the right to be annoyed at Scheme being discussed in the
CL newsgroup.
Lispers have the right to discuss Scheme vs. CL in the Lisp family
newsgroup.
The problem is that these seem to be the same newsgroup.
Possible solution:
(1) Create comp.lang.lisp.common, and write a charter limiting Scheme
discussions there
(2) Assign comp.lang.lisp to the Lisp family, or create
comp.lang.lisp.family for that purpose.
I for one should like to see some full-fledged advocacy discussions between
adherents of both sprouts of Lisp 1.5, because such a discussion is apt to
bring out a lot of interesting information about the pros and cons of the
two in various domains.
Does anybody else deem a comp.lang.lisp.common group a good thing?
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote in message
···················@ID-63952.news.dfncis.de...
> CL programmer have the right to be annoyed at Scheme being discussed in the
> CL newsgroup.
> Lispers have the right to discuss Scheme vs. CL in the Lisp family
> newsgroup.
>
> The problem is that these seem to be the same newsgroup.
>
> Possible solution:
> (1) Create comp.lang.lisp.common, and write a charter limiting Scheme
> discussions there
> (2) Assign comp.lang.lisp to the Lisp family, or create
> comp.lang.lisp.family for that purpose.
I don't think either solution would work in practice.
There are too many people reading comp.lang.lisp to expect them
to change and comp.lang.lisp is where Common Lisp ought to be
discussed.
Comp.lang.lisp.family sounds good in theory, but the majority of
people that start and persist in `Scheme vs. CommonLisp' flamefests
seem to be completely unaware that comp.lang.scheme exists, that
the subject has been done to death here, and that most people here
are sick of it. (Or perhaps they are all too aware.)
The idea of a separate news group has been brought up many times
before. I don't want to discourage you from trying, though. Cutting
down the amount of useless rhetoric in this group is a noble goal.
> I for one should like to see some full-fledged advocacy discussions between
> adherents of both sprouts of Lisp 1.5, because such a discussion is apt to
> bring out a lot of interesting information about the pros and cons of the
> two in various domains.
Discussions that focus on technical differences between Common Lisp
and other languages that have drawn from the example of Lisp 1.5 or were
an influence on the design of Common Lisp (such as ZETALISP, MACLISP, Scheme,
Portable standard lisp, NIL, T, S1 Lisp, Spicelisp, UCI Lisp) are,
for the most part, reasonable fodder for rational discussion. Even
the more outspoken of the regular contributers have been known to discuss
these sort of issues with a calm and thoughtful demeanor.
However opinions along the lines of:
* Common Lisp should dispense with two namespaces.
* Common Lisp ought to be properly tail-recursive.
* Common Lisp ought to support first-class continuations.
are just as unwelcome as
* Common Lisp should distinguish between upper and lower case
by default.
* Common Lisp should dispense with prefix notation and adopt an
algabraic notation.
* ``Get out of the Common Lisp backwater and adopt C++, Java, Python,
XML, etc.''
"Joe Marshall" <·············@attbi.com> wrote in message
··························@typhoon.ne.ipsvc.net...
> Comp.lang.lisp.family sounds good in theory, but the majority of
> people that start and persist in `Scheme vs. CommonLisp' flamefests
> seem to be completely unaware that comp.lang.scheme exists, that
> the subject has been done to death here, and that most people here
> are sick of it. (Or perhaps they are all too aware.)
But why should comp.lang.scheme have to suffer? That newsgroup is at least
as inappropriate as the current (the current at least doesn't SAY it is
CL-specific).
In my experience there haven't been many flamefests, except that someone
stating (with arguments) "I prefer this specific Scheme feature" gets
attacked. If this is a CL-specific group, probably rightly so, but
currently there is no group where this would go, and where the argued
retort "But I prefer the corresponding CL feature" could go as well.
--
Biep
On Thu, 9 May 2002 17:50:12 +0200,
Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote:
>
> In my experience there haven't been many flamefests, except that someone
> stating (with arguments) "I prefer this specific Scheme feature" gets
> attacked. If this is a CL-specific group, probably rightly so, but
What makes you think that it is right to attack another person
verbally, just because he or she states that "I prefer..."?
It is not.
s.
"Stefan Schmiedl" <·@xss.de> wrote in message ···················@ID-57631.news.dfncis.de...
> On Thu, 9 May 2002 17:50:12 +0200,
> Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote:
> >
> > In my experience there haven't been many flamefests, except that someone
> > stating (with arguments) "I prefer this specific Scheme feature" gets
> > attacked. If this is a CL-specific group, probably rightly so, but
>
> What makes you think that it is right to attack another person
> verbally, just because he or she states that "I prefer..."?
>
> It is not.
Perhaps not, but since this is a virtual forum, physical assault
is out of the question.
"Joe Marshall" <·············@attbi.com> writes:
> Perhaps not, but since this is a virtual forum, physical assault
> is out of the question.
if memory serves, one infamous usenet poster has, on occasion, called other
hostile parties to a duel with their choice of weaponery. he was known to be
an expert marksman. i don't think anyone took him up on his offer. :)
[also, state of massachusetts does not issue duelling permits]
oz
---
you take a banana, you get a lunar landscape. -- j. van wijk
ozan s yigit wrote:
>
> if memory serves, one infamous usenet poster has, on occasion, called other
> hostile parties to a duel with their choice of weaponery. he was known to be
> an expert marksman. i don't think anyone took him up on his offer. :)
> [also, state of massachusetts does not issue duelling permits]
The appropriate weapon in such a case is of course, watermelons at
twenty paces. :-/
Bear
On Thu, 9 May 2002 17:50:12 +0200, I (Biep) wrote:
> In my experience there haven't been many flamefests, except that someone
> stating (with arguments) "I prefer this specific Scheme feature" gets
> attacked. If this is a CL-specific group, probably rightly so, but
"Stefan Schmiedl" <·@xss.de> wrote in message
···················@ID-57631.news.dfncis.de...
> What makes you think that it is right to attack another person
> verbally, just because he or she states that "I prefer..."?
>
> It is not.
All right, "attacked" may have been too strong a word. Let me (partly re-)
state my position:
(1) If postings are inappropriate, it is probably correct to confront the
prepetrator, if necessary including a reprimand.
(2) Verbal abuse, such as calling others fools or idiots, is in principle
totally unacceptable to me.
- This is a place to discuss ideas and opinions, maybe passionately;
not people
- Anybody posting here is obviously from that fact not an idiot in the
clinical sense. Therefore calling someone an idiot is meant to hurt (and
it DOES hurt). Comparable arguments hold for many of the other terms used
in verban abuse.
(3) Even though I do not accept verbal abuse:
- This is an unmoderated forum, where something doesn't and shouldn't
simply go away because I or somebody else would like so. Therefore the
correct option, I think, is to filter the content to include only what one
wants to read, e.g. through the use of kill files.
- I know that there exist several disorders, the most common of which
probably is BPD, that make people behave badly even while they may
basically be nice people. One can try to react in an appropriate manner
(http://www.bpdcentral.com/nook/puvas.htm), which may still boil down to
filtering. (BTW, a small self-test is on
http://www.4degreez.com/misc/personality_disorder_test.mv).
But if some of the heat can be removed by creating another newsgroup, why
not?
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> But if some of the heat can be removed by creating another
> newsgroup, why not?
because distance increases misundertanding in this case. (there
are cases where the opposite is true, but figuring out what is
appropriate c.l.l traffic and how to handle variations is best
done in the open.)
if you take the analysis presented and apply it universally, the
net effect on society is to increase intolerance, which has the
usual sad consequences. more importantly, it is impossible to
apply universally, anyway, so the (doomed to fail) attempts to
do so lead to cynicism in reformed optimists, instead of letting
these optimists perhaps infect others.
thi
In an attempt to throw the authorities off his trail, Thien-Thi Nguyen <···@glug.org> transmitted:
> "Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
>> But if some of the heat can be removed by creating another
>> newsgroup, why not?
>
> because distance increases misundertanding in this case. (there
> are cases where the opposite is true, but figuring out what is
> appropriate c.l.l traffic and how to handle variations is best
> done in the open.)
There would indeed be new "fights" started; we'd see "splinter
factions" like:
-> Those that think Scheme is pretty much satanic, and should have
no association at all with the name "Lisp";
-> Those that think Common Lisp is pretty much satanic, and that
there should be no association betwixt it and Scheme
-> Those that feel equally strongly that there _should_ be an
association;
Those three groups _do_ exist, are of significant size, and pretty
much guarantee that there will be some strife. The result of an
attempt to divide them up would work out for the first two groups, but
the third would draw the lot back into the fray when it comes time to
wonder about the differences between Scheme and Lisp from a
"non-aggressive" perspective.
--
(reverse (concatenate 'string ····················@" "454aa"))
http://www.cbbrowne.com/info/x.html
"A good system can't have a weak command language." -- Alan Perlis
[This explains why MS-DOS and Windows can't possibly be good
systems...]
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> But if some of the heat can be removed by creating another
> newsgroup, why not?
Thien-Thi Nguyen <···@glug.org> objected:
> because distance increases misundertanding in this case.
"Christopher Browne" <········@acm.org> elaborated
in message ···················@ID-125932.news.dfncis.de...
> There would indeed be new "fights" started; we'd see "splinter
> factions" like:
> -> Those that think Scheme is pretty much satanic, and should have
> no association at all with the name "Lisp";
> -> Those that think Common Lisp is pretty much satanic, and that
> there should be no association betwixt it and Scheme
> -> Those that feel equally strongly that there _should_ be an
> association;
>
> Those three groups _do_ exist, are of significant size, and pretty
> much guarantee that there will be some strife. The result of an
> attempt to divide them up would work out for the first two groups, but
> the third would draw the lot back into the fray when it comes time to
> wonder about the differences between Scheme and Lisp from a
> "non-aggressive" perspective.
I still should see two advantages, corresponding to different meanings of
the word "removed" as used in my original sentence:
(1) This strife would occur in another newsgroup than the CL and Scheme
groups, and therefore not bother the monolinguals (in preference if not in
ability).
(2) Some of the satanists from either party would not visit the overall
group, so their oil would stay out of the fire altogether.
[In fact, several hierarchies have specific advocacy groups where people
who like it hot can go. Personally I am not interested in advocacy in that
sense, but it does show that Usenet has ways to deal with even that kind of
demand.]
--
Biep
* "Biep @ http://www.biep.org/" <·········@my-web-site.com>
| (1) If postings are inappropriate, it is probably correct to confront the
| prepetrator, if necessary including a reprimand.
|
| (2) Verbal abuse, such as calling others fools or idiots, is in principle
| totally unacceptable to me.
| - This is a place to discuss ideas and opinions, maybe passionately;
| not people
Then why do you attack me viciously the way you do? You have provided
some clues: you are a deeply religious person and appear to believe that
the ethics you demand of others does not apply to yourself at all. This
is the kind of evil that mankind has had to deal with for ages, usually
by having to kill the religious morons. This still goes on. Please move
to a country where they would treat you like you deserve.
| - Anybody posting here is obviously from that fact not an idiot in the
| clinical sense. Therefore calling someone an idiot is meant to hurt (and
| it DOES hurt). Comparable arguments hold for many of the other terms
| used in verban abuse.
No, idiot, it is an indication that the behavior displayed, such as your
behavior and hypocrisy, is that of an idiot, and that if that person
wishes _not_ to appear to be an idiot, he better change it. You would
never understand this, because you have already given enough clues to
suspect that you think you areare always the righteous guy and everybody
else is wrong. Thus your hypocrisy is not even a problem to you.
| But if some of the heat can be removed by creating another newsgroup, why
| not?
Why not shut the fuck up with your hypocrisy and just go away, instead?
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
* "Biep @ http://www.biep.org/" <·········@my-web-site.com>
| But why should comp.lang.scheme have to suffer?
Because the only people who are interested in Scheme vs Common Lisp are
those who are interested in Scheme. Nobody else could possibly care.
| In my experience there haven't been many flamefests
Of course, your experience is such a wonderful basis upon which to form
intelligent opinions, since you just came out of nowhere to attack me
viciously. We must assume that your concept of what people have a right
to discuss includes such vicious, unprovoked attacks. In other words,
you are stark raving mad and should be locked up, or at least ignored.
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
From: Ray Dillinger
Subject: Re: Newsgroups [Was: Your introduction to Lisp...]
Date:
Message-ID: <3CDA9511.8020902@sonic.net>
Biep @ http://www.biep.org/ wrote:
> CL programmer have the right to be annoyed at Scheme being discussed in the
> CL newsgroup.
> Lispers have the right to discuss Scheme vs. CL in the Lisp family
> newsgroup.
>
> The problem is that these seem to be the same newsgroup.
>
> Possible solution:
> (1) Create comp.lang.lisp.common, and write a charter limiting Scheme
> discussions there
> (2) Assign comp.lang.lisp to the Lisp family, or create
> comp.lang.lisp.family for that purpose.
>
> I for one should like to see some full-fledged advocacy discussions between
> adherents of both sprouts of Lisp 1.5, because such a discussion is apt to
> bring out a lot of interesting information about the pros and cons of the
> two in various domains.
>
> Does anybody else deem a comp.lang.lisp.common group a good thing?
It would be more in line with existing practice if it were named
comp.lang.common-lisp. But yes, if people want a place to discuss
common lisp and where other dialects of lisp are off-topic, a group
split is probably the right thing to do.
The question is whether the split would leave enough traffic
on comp.lang.lisp to continue to justify its continued existence,
and whether the CL-only versus Lisp-family factionalization
currently in the group is severe enough to justify the split.
Bear
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> Does anybody else deem a comp.lang.lisp.common group a good thing?
My understanding of newsgroup procedure is that you are first supposed
to show that there is adequate traffic and only then spawn a new
group, not create new groups in anticipation of traffic. CL is
discussed here and properly so. If there is ssubstantial demand to
discuss something else, I suggest those other things should identify
with [MYLISP] or [YOURLISP] or whatever in the subject-line. If it
looks like we have a sustained number of these things, as opposed to
just a few threads, we could talk about spawning a whole new group.
I personally don't perceive a problem with the present situation, though.
We have sometimes referred people to other, more appropriate, groups when
such groups exist. I don't think we've told anyone who has no group to
post to that they're just out of luck.
"Biep @ http://www.biep.org/" <·········@my-web-site.com> asked:
> Does anybody else deem a comp.lang.lisp.common group a good thing?
"Kent M Pitman" <······@world.std.com> replied
····················@shell01.TheWorld.com...
> If there is substantial demand to discuss something else [than CL],
> I suggest those other things should identify with [MYLISP] or
> [YOURLISP] or whatever in the subject-line. If it looks like we
> have a sustained number of these things, as opposed to just a few
> threads, we could talk about spawning a whole new group.
>
> I personally don't perceive a problem with the present situation, though.
All right, I'll try to mention Scheme in the title whenever appropriate.
(But I do have some anecdotal evidence - emails I received about a year
ago - that some people have refrained from comparing CL and Scheme here
because of the verbal abuse.)
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> "Biep @ http://www.biep.org/" <·········@my-web-site.com> asked:
> > Does anybody else deem a comp.lang.lisp.common group a good thing?
>
> "Kent M Pitman" <······@world.std.com> replied
> ····················@shell01.TheWorld.com...
> > If there is substantial demand to discuss something else [than CL],
> > I suggest those other things should identify with [MYLISP] or
> > [YOURLISP] or whatever in the subject-line. If it looks like we
> > have a sustained number of these things, as opposed to just a few
> > threads, we could talk about spawning a whole new group.
> >
> > I personally don't perceive a problem with the present situation, though.
>
> All right, I'll try to mention Scheme in the title whenever appropriate.
> (But I do have some anecdotal evidence - emails I received about a year
> ago - that some people have refrained from comparing CL and Scheme here
> because of the verbal abuse.)
I personally have to say I think it's flamebait unless you say why you
are doing it. The communities enjoy a healthy separation because they
disagree in fundamental ways on very core value issues.
While I do not _think_ I plan to "verbally abuse" you (partly, one
never knows what others will classify as verbal abuse), I do not
consider point-by-point feature comparisons appropriate in this forum
to be a productive use of anyone's time unless you think you have a
specific and achievable goal.
I personally think (and it's just my opinion) that you should post
remarks about Scheme on the Scheme newsgroup, and remarks about CL on
the CL newsgroup, and that any overlapping remarks should be framed in
terms of an action you want to have happen. If you don't have a specific
action in mind, then you are probably whipping people into a frenzy over
nothing, and that is the nature of what people call 'flamebait'.
Just my personal opinion.
Biep asked:
> Does anybody else deem a comp.lang.lisp.common group a good thing?
"Kent M Pitman" <······@world.std.com> replied
> ····················@shell01.TheWorld.com...
> If there is substantial demand to discuss something else [than CL],
> I suggest those other things should identify with [MYLISP] or
> [YOURLISP] or whatever in the subject-line.
"Biep @ http://www.biep.org/" <·········@my-web-site.com> took this up:
> All right, I'll try to mention Scheme in the title whenever appropriate.
"Kent M Pitman" <······@world.std.com> then commented
in message ····················@shell01.TheWorld.com:
> I personally have to say I think it's flamebait unless you say why you
> are doing it. The communities enjoy a healthy separation because they
> disagree in fundamental ways on very core value issues.
Well, my personal stance is that there are too few live varieties of Lisp
around, and that new ideas can grow from confronting varieties. But that
is not the point here: I may be wrong, or someone else may have a quite
different reason for comparing the two. The point seems to me that there
are three options:
(1) Exclude certain subjects from discussion on Usenet.
This seems to me very much against the nature of Usenet,
and not a good idea, esp. if the subjects are not proven
to be worthless.
(2) Discuss them in the CL or Scheme (or even more inappropriate)
newsgroups.
This is bound to generate a lot of heat, as you seem to agree,
and probably goes against the charter of either group.
(3) Let them have a place of their own.
This was my proposal.
Do I understand correctly that (1) is your opinion (with "certain subjects"
being 'non-action-oriented CL/Scheme comparisons')?
--
Biep
* "Biep @ http://www.biep.org/" <·········@my-web-site.com>
| (3) Let them have a place of their own.
| This was my proposal.
Look, web dude, just create a web forum where you can attack people out
of the blue, which you seem to prefer to do when you are not instigating
trouble among groups of people who would prefer to be apart, and where
you can exclude people and topics all you like. That is, after all, the
only reason you want your own newsgroup. Go away, now, web boy.
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> Biep asked:
> > Does anybody else deem a comp.lang.lisp.common group a good thing?
>
> "Kent M Pitman" <······@world.std.com> replied
> > ····················@shell01.TheWorld.com...
> > If there is substantial demand to discuss something else [than CL],
> > I suggest those other things should identify with [MYLISP] or
> > [YOURLISP] or whatever in the subject-line.
>
> "Biep @ http://www.biep.org/" <·········@my-web-site.com> took this up:
> > All right, I'll try to mention Scheme in the title whenever appropriate.
>
> "Kent M Pitman" <······@world.std.com> then commented
> in message ····················@shell01.TheWorld.com:
> > I personally have to say I think it's flamebait unless you say why you
> > are doing it. The communities enjoy a healthy separation because they
> > disagree in fundamental ways on very core value issues.
>
> Well, my personal stance is that there are too few live varieties of Lisp
> around, and that new ideas can grow from confronting varieties. But that
> is not the point here: I may be wrong, or someone else may have a quite
> different reason for comparing the two. The point seems to me that there
> are three options:
>
> (1) Exclude certain subjects from discussion on Usenet.
> This seems to me very much against the nature of Usenet,
> and not a good idea, esp. if the subjects are not proven
> to be worthless.
> (2) Discuss them in the CL or Scheme (or even more inappropriate)
> newsgroups.
> This is bound to generate a lot of heat, as you seem to agree,
> and probably goes against the charter of either group.
> (3) Let them have a place of their own.
> This was my proposal.
>
> Do I understand correctly that (1) is your opinion (with "certain subjects"
> being 'non-action-oriented CL/Scheme comparisons')?
No.
Biep wrote:
> The point seems to me that there are three options:
> (1) Exclude certain subjects from discussion on Usenet.
> (2) Discuss them in the CL or Scheme (or even
> more inappropriate) newsgroups.
> (3) Let them have a place of their own.
> Do I understand correctly that (1) is your opinion (with "certain subjects"
> being 'non-action-oriented CL/Scheme comparisons')?
Kent M Pitman <······@world.std.com> in message
news:<···············@shell01.TheWorld.com> curtly replied:
> No.
Now I am lost. Have I omitted a possibility?
(1) is not your position - that is what you are saying here, isnt' it?
(2) is what you consider flamebait - which I take to imply that it is
not your position. Am I wrong there?
(3) is my proposal, which, as you pointed out, cannot be implemented
until (through (1) or (2)?) traffic has been established.
Biep.
[For those who don't care for anything Lispy outside CL: as it is unlikely
that I shall in the near future post any purely CL-specific material,
putting my name in a kill file is probably a better solution than killing
the various threads.]
For those who do care: there is a not uninteresting discussion on Scheme
vs. CL going on in news:comp.lang.scheme. Of course there is a lot of
rehash that will only be interesting for newcomers, but there is for
instance quite a bit of analysis regarding how certain features in a
language work together to create a local optimum.
If all you can do is flame, please leave the discussion alone: it currently
has a quite acceptable content-to-noise ratio, and I don't think anybody
would be helped if that were to change.
A thought linking this to the subject of this thread:
Of course this discussion doesn't really belong in a Scheme newsgroup, or
as little there as in a CL group. Since and as long as no general Lisp
group exists apart from a CL group, maybe misuse of comp.std.lisp or
comp.org.lisp-users might be the best option for such discussions. They
will probably cause less irritation there because these groups are not as
busy.
--
Biep
Reply via http://www.biep.org
In article <··············@ID-63952.news.dfncis.de>, Biep @
http://www.biep.org/ wrote:
> [For those who don't care for anything Lispy outside CL: as it is unlikely
> that I shall in the near future post any purely CL-specific material,
> putting my name in a kill file is probably a better solution than killing
> the various threads.]
>
> For those who do care: there is a not uninteresting discussion on Scheme
> vs. CL going on in news:comp.lang.scheme. Of course there is a lot of
> rehash that will only be interesting for newcomers, but there is for
> instance quite a bit of analysis regarding how certain features in a
> language work together to create a local optimum.
>
> If all you can do is flame, please leave the discussion alone: it currently
> has a quite acceptable content-to-noise ratio, and I don't think anybody
> would be helped if that were to change.
The biggest thing I learned in that thread is that Schemers know what the truth
is, and as a result have an inferiority complex which manifests itself when
someone merely mentions a feature of Lisp that is not present in Scheme. Such a
mention is instantly interpreted as a flaming attack. This is simply evidence
that they know what the truth is, but simply refuse to accept it.
Rational debate is difficult with Schemers, because their positions tend to be
undefined and contradictory. They believe the lack of functionality in the
language as a virtue---Lisp is said to have a lot of unneeded ``cruft'' in it.
But then it comes to light that Scheme implementations have their own
ad hoc imitations of some of this cruft, which Schemers are happy to use in
their programs, at the cost of portability. They believe that they are still
programming in Scheme, when much of the code is written in an implementation's
dialect. The term Scheme is elastic, undefined. It would be nice to be able
to get them to commit to a definition of ``Scheme'' that is as precise as the
meaning of ``Common Lisp''.
Schemers prefer to believe in some unspecificed notions like ``purity'',
instead of reasoning from facts. It's important to them to have a *feeling*
that they are working with something pure, determined by some arbitrary
emotional standard.
I suspect that, demographically, Schemers are simply a younger, dumber crowd.
That is, if we had a histogram breaking down Lispers and Schemers by age, the
Scheme one would be fatter in the younger years. This is the natural
consequence of Scheme having been flogged at Universities.
Moreover, people are drawn to programming tools according to their
personalities and maturity. Inferior tools naturally attract only those people
who are not able to think clearly and boldly enough to recognize inferiority,
and name it for what it is. The culture that forms around tools consists of
those people whom those tools are able to attract and captivate. When people
change, they move on, and are replaced by an influx of replacements who inherit
their discarded attitudes; so what is observed is that the cultures appear
static, despite membership turnover.
It has been my consistent observation that immature programmers revel in
undefined concepts like simplicity and purity. They like small languages, and
don't mind reinventing wheels and building complex things from scratch. The
effort of continuous reinventing somehow justifies the saving of effort from
not having to initially absorb a larger set of axioms. The justification is,
they can do it better than anyone who came before them, so those extra axioms
are worthless anyway! To convince themselves that they can do it better,
despite not being any smarter than their predecessors, they resort to the
argument that they are more ``in touch'' with the current world and its
technology. Whatever they do is better simply because it is modern, and it is
modern simply because it is more recent. A binary tree module written in C
yesterday is exciting and new. An equivalent one from eighteen years ago is
antiquated crud. This is a form of denial, an emotional response to the pain
that comes from knowing that someone did it eighteen years ago just as well,
and that he would laugh at the modern reinvention effort.
Moreover, immature programmers don't appreciate the role of precise
specifications and standards; to specify an interface or behavior means to code
it. If two or more groups implement a common specification, they are simply
wasting their time doing redundant, ungratifying, inferior work. Those people
must be mechanical drones if they need someone to specify to them how something
should work; real programmers never work from someone else's designs, they just
sit down and crank out the system according to their whims. Also, they don't
interface with specifications, they interface with implementations. The
implementation is always right, so why bother with documents? If requirements
are imposed on these programmers, they must never be so precise that they can't
be loosely interpreted or tweaked to suit their tastes. Something as precise as
a programming language standard is so abhorrent, so that if there must be a
standard, it must be the smallest possible document. Nobody has the right to
impose a precise design on someone else; there must always be room left for the
human element: esthetic taste, creative interpretation, the license to
cull or embelish.
In article <············@luna.vcn.bc.ca>,
Kaz Kylheku <···@ashi.footprints.net> wrote:
>In article <··············@ID-63952.news.dfncis.de>, Biep @
>http://www.biep.org/ wrote:
>> <some garbage omitted>
> <a whole lot of crap omitted>
Kaz:
You got treated a whole lot better in comp.lang.scheme with your CL versus
Scheme trolls than similarly ignorant schemers usually get treated here
in c.l.l. Why don't you leave well-enough alone and stop this petty
bullshit.
Oh, oh. I just fed a troll, and I know I'm going to pay for it.
Brad
In article <··········@arthur.cs.purdue.edu>, Bradley J Lucier wrote:
> In article <············@luna.vcn.bc.ca>,
> Kaz Kylheku <···@ashi.footprints.net> wrote:
>>In article <··············@ID-63952.news.dfncis.de>, Biep @
>>http://www.biep.org/ wrote:
>>> <some garbage omitted>
>> <a whole lot of crap omitted>
>
> Kaz:
>
> You got treated a whole lot better in comp.lang.scheme with your CL versus
> Scheme trolls than similarly ignorant schemers usually get treated here
> in c.l.l.
I don't recall complaining about any personal ill-treatment. I'm, quite
simply, not involved in this at that level.
The troll you refer to was simply a statement outlining what is in Lisp and
what is in Scheme, in point form; this was in response to someone's indirect
question. (I got one or two things wrong; for instance, I had forgotten that
R5RS has multiple values).
I didn't expect anyone to interpret a statement of fact as a personal affront.
It isn't, after all, my *opinion* that Lisp has an object oriented programming
system, or a package mechanism.
In article <············@luna.vcn.bc.ca>,
Kaz Kylheku <···@ashi.footprints.net> wrote:
>In article <··········@arthur.cs.purdue.edu>, Bradley J Lucier wrote:
>> You got treated a whole lot better in comp.lang.scheme with your CL versus
>> Scheme trolls than similarly ignorant schemers usually get treated here
>> in c.l.l.
>
>I don't recall complaining about any personal ill-treatment.
And you can't read. I said that you were *not* mistreated.
>It isn't, after all, my *opinion* that Lisp has an object oriented programming
>system, or a package mechanism.
No, but after being treated relatively nicely in comp.lang.scheme,
it is your opinion that Schemers "have an inferiority complex",
take "undefined and contradictory positions", are "younger", "dumber",
and "immature", and "are not able to think clearly".
And you're brave enough to reveal this to the readers of comp.lang.lisp.
It is my *opinion* that you're an asshole.
Brad
Kaz Kylheku <···@ashi.footprints.net> writes:
>
> <a very long insult of Schemers snipped>
>
I think we've got another troll in here :-\
You come here and insult all Scheme programmers as being young, inferior,
unprofessional and just plain stupid. This rather strong insult is based
on nothing more than a bunch of personal opinions and assumptions that
aren't even supported by any sort of facts whatsoever.
Please take your trolling somewhere else...
P.S. BTW, you must surely know that Guy Steele, the same person who put
considerable work into Common Lisp standard was also a co-author of
Scheme standard.
--
Richard Krushelnitskiy "I know not with what weapons World War III will
rkrush (at) gmx.net be fought, but World War IV will be fought with
http://rkrush.cjb.net sticks and stones." -- Albert Einstein
In article <··············@valhalla.localnet>, Richard Krush wrote:
> You come here and insult all Scheme programmers as being young, inferior,
^^^^^^^^^^^^^^^^^^^^^^
That is clearly, pitifully wrong; I apologize for writing so stupidly.
I should have been clear that my comments apply only to a faction of
programmers (and not just Schemers!). I don't condemn anyone for
being at a particular level of programming maturity; and I did not
intend any insult.
Kaz Kylheku: [most of the flame bait elided]
> It would be nice to be able to get them to commit to a definition
> of ``Scheme'' that is as precise as the meaning of ``Common Lisp''.
surely you jest. the language is carefully defined in IEEE standard and
R^5RS. as someone who spent many years with scheme [unlike someone like
you looking from the outside] i observe that if anything, most schemers
are far too committed to those documents; the language does not grow as
well as it should.
oz
---
if you want to have your head in the clouds
you need to keep your feet on the ground. -- terry pratchett
I don't know about the demographics of scheme programmers, and don't want to
characterize them. I believe Kaz's comments here refer to the subset of
programmers who demonstrate immaturity.
I found these comments are pretty much on the mark--I don't see much respect
among software engineers these days for all the great work which has been done
in the past. They will use it, but only so they can reinvent wheels faster. I
also feel that a larger, more complex language tends to be preferred by the more
experienced, mature and talented programmers. Personally, I prefer a bigger bag
of tools! The more the language offers, the more expressivity you gain. The fact
that Common Lisp has many ways to say the same thing means there are subtleties
of meaning that can be part of your code and coding style. As an avid code
reader, I greatly appreciate code written in a big language. Once you have
mastered the language, you can read great works. Until you have mastered it, you
keep referring to a dictionary. In the case of a larger language, that
dictionary is more often a language standard (such as the ever-handy CLHS). In a
smaller language it is more likely to be custom libraries. Where would you
rather invest your mental energies?
A small language is a quick read, a quick learn, andd something to add to your
resume. A large language is one you can spend a considerable amount of your
career mastering, and write great things with it.
By the way, I like C++, which I consider a very big language (preparing my
flame-resistent suit!). It has many weaknesses, but it is huge, powerful, and
once you have a lot of experience with it you can write code which in my opinion
is powerful, elegant and expressive. But of course, I prefer Common Lisp
usually. :-)
However, I have seen more *awful* code written in C++ than I care to think
about. It is not a good language for immature programmers--they would probably
be better with Java, C or Scheme.
Roger
On Fri, 19 Jul 2002 19:00:38 +0000 (UTC), Kaz Kylheku <···@ashi.footprints.net>
wrote:
>
>I suspect that, demographically, Schemers are simply a younger, dumber crowd.
>That is, if we had a histogram breaking down Lispers and Schemers by age, the
>Scheme one would be fatter in the younger years. This is the natural
>consequence of Scheme having been flogged at Universities.
>Moreover, people are drawn to programming tools according to their
>personalities and maturity. Inferior tools naturally attract only those people
>who are not able to think clearly and boldly enough to recognize inferiority,
>and name it for what it is. The culture that forms around tools consists of
>those people whom those tools are able to attract and captivate. When people
>change, they move on, and are replaced by an influx of replacements who inherit
>their discarded attitudes; so what is observed is that the cultures appear
>static, despite membership turnover.
>
>It has been my consistent observation that immature programmers revel in
>undefined concepts like simplicity and purity. They like small languages, and
>don't mind reinventing wheels and building complex things from scratch. The
>effort of continuous reinventing somehow justifies the saving of effort from
>not having to initially absorb a larger set of axioms. The justification is,
>they can do it better than anyone who came before them, so those extra axioms
>are worthless anyway! To convince themselves that they can do it better,
>despite not being any smarter than their predecessors, they resort to the
>argument that they are more ``in touch'' with the current world and its
>technology. Whatever they do is better simply because it is modern, and it is
>modern simply because it is more recent. A binary tree module written in C
>yesterday is exciting and new. An equivalent one from eighteen years ago is
>antiquated crud. This is a form of denial, an emotional response to the pain
>that comes from knowing that someone did it eighteen years ago just as well,
>and that he would laugh at the modern reinvention effort.
>
·····@corman.net (Roger Corman) writes:
> By the way, I like C++, which I consider a very big language
> (preparing my flame-resistent suit!). It has many weaknesses, but it
> is huge, powerful, and once you have a lot of experience with it you
> can write code which in my opinion is powerful, elegant and
> expressive. But of course, I prefer Common Lisp usually. :-)
>
> However, I have seen more *awful* code written in C++ than I care to
> think about. It is not a good language for immature
> programmers--they would probably be better with Java, C or Scheme.
>
> Roger
Sorry, that I am so late to follow up your post. May I ask which C++
IDE you are using? Is software development in this IDE comparable
with development in a Lisp environment, where you can test and debug
every small function interactively? (Does something like that exist
for C++ or Java?)
Nicolas.
Kaz Kylheku <···@ashi.footprints.net> writes:
> Schemers prefer to believe in some unspecificed notions like
> ``purity'', instead of reasoning from facts. It's important to them
> to have a *feeling* that they are working with something pure,
> determined by some arbitrary emotional standard.
>
> I suspect that, demographically, Schemers are simply a younger,
> dumber crowd.
Dunno about "dumber", but you're probably right about "younger". It
*may* be because Scheme is more often taught at university, but it's
also very natural for younger people to want something that does not
"feel" too heavily encumbered by the weight of the past, and leaves
plenty of scope for them to flex their mental muscles.
It takes time to grow out of that, and to realise that the people who
came before us were (often) much smarter then we are.
> It has been my consistent observation that immature programmers revel in
> undefined concepts like simplicity and purity. They like small languages, and
> don't mind reinventing wheels and building complex things from scratch. The
> effort of continuous reinventing somehow justifies the saving of effort from
> not having to initially absorb a larger set of axioms. The justification is,
> they can do it better than anyone who came before them, so those extra axioms
> are worthless anyway!
Without meaning to have a dig at you personally (I think we've all
been there one way or another), this "they" routine sounds a bit
'sus', considering your own opinions w.r.t. C. It wasn't all that long
ago, even though you've become much ... older this year) ;-)
> To convince themselves that they can do it better, despite not being
> any smarter than their predecessors, they resort to the argument
> that they are more ``in touch'' with the current world and its
> technology. Whatever they do is better simply because it is modern,
> and it is modern simply because it is more recent. A binary tree
> module written in C yesterday is exciting and new. An equivalent one
> from eighteen years ago is antiquated crud. This is a form of
> denial, an emotional response to the pain that comes from knowing
> that someone did it eighteen years ago just as well, and that he
> would laugh at the modern reinvention effort.
That's probably a large part of it, but it's not the whole story.
Young people don't don't like to be handed stuff in black boxes from
on high. When they first learn about binary trees and suchlike, the
issue of how to implement one is just as interesting as the issue of
how and when to use it. Nothing wrong with that at all, AFAICT. And
sometimes (rarely, to be sure) they *will* invent something new and
better, but not unless they have the audacity to try.
In article <··············@athens.localdomain>, Patrick W wrote:
> Kaz Kylheku <···@ashi.footprints.net> writes:
>
>> Schemers prefer to believe in some unspecificed notions like
>> ``purity'', instead of reasoning from facts. It's important to them
>> to have a *feeling* that they are working with something pure,
>> determined by some arbitrary emotional standard.
>>
>> I suspect that, demographically, Schemers are simply a younger,
>> dumber crowd.
>
> Dunno about "dumber", but you're probably right about "younger". It
> *may* be because Scheme is more often taught at university, but it's
> also very natural for younger people to want something that does not
> "feel" too heavily encumbered by the weight of the past, and leaves
> plenty of scope for them to flex their mental muscles.
>
> It takes time to grow out of that, and to realise that the people who
> came before us were (often) much smarter then we are.
Yes! You must recognize your younger self in my comments, as I do. We can't
condemn anyone for being at any point in his sequence of awakenings; that was
not my intent. I only wish I had written this so that it doesn't come off like
an attack of the users of Scheme. I'm kicking myself for that now.
> Without meaning to have a dig at you personally (I think we've all
> been there one way or another), this "they" routine sounds a bit
> 'sus', considering your own opinions w.r.t. C. It wasn't all that long
> ago, even though you've become much ... older this year) ;-)
I deny nothing. ;)
Kaz Kylheku <···@ashi.footprints.net> writes:
> In article <··············@athens.localdomain>, Patrick W wrote:
>
> > It takes time to grow out of that, and to realise that the people who
> > came before us were (often) much smarter then we are.
>
> Yes! You must recognize your younger self in my comments, as I do.
Absolutely. I think people who recognise their ignorance at a young
age are either really smart or really stupid. And, like most of us,
I'm somewhere in between. So it took a while ;-)
"Biep @ http://www.biep.org/" <·········@my-web-site.com> wrote in message news:<··············@ID-63952.news.dfncis.de>...
> I think that your arguments, while not invalid, do not address the
> kind of discussion I should like to see. I want to see Lisp survive
> after Scheme and CL have died. Lisp is flexible, but someday people
> may wonder whether, once everybody is programming in "little language
> X with all the modern features", there is any valid reason that
> language X is implemented on top of an outdated Lisp with all the 20th
> century features that remained because they were standardised, and
> they will simply remove the underlying level. (Painted in broad
> black-and-white strokes for clarity..)
> What if Lisp 1.5 had been standardised (which in itself is a good
> thing), and (the bad thing) general discussion about what Lisp should
> be and why had been marginalised. Would Lisp have survived until now?
> I think one of the strengths of Lisp is the ability that Lispers have
> always had of seeing the Lisp behind the dialect differences. There
> wouldn't have been a CL if they hadn't seen Lisp behind the Mac, Zeta,
> Standard, Inter-, etc., and, individually, each of these languages
> might well have died out.
> Well, I hope I have succeeded in bringing my point across..
Unfortunately google groups seems to break on the message that this
was from, but I think it's important to reply.
I think you are right on the money here.
It will not do to confuse the Common Lisp _dialect of lisp_ with Lisp.
The result of that would simply be a continuing stranglehold on
evolution.
If people cannot accept this, then the answer is a
comp.lang.lisp.common-lisp where they can go and be as exclusive and
as conservative as they like, without harming lisp in general.
Regards,
Brian.
"Brian Spilsbury" <·····@designix.com.au> wrote in message
·································@posting.google.com...
> It will not do to confuse the Common Lisp _dialect of lisp_ with Lisp.
> The result of that would simply be a continuing stranglehold on
> evolution.
> If people cannot accept this, then the answer is a
> comp.lang.lisp.common-lisp where they can go and be as exclusive and
> as conservative as they like, without harming lisp in general.
Thanks. Unfortunately, it seems that you and I are about the only ones
willing to say so in public, and before a new newsgroup is created, traffic
needs to be proven.
Now, obviously, the amount of CL-specific traffic in the general Lisp group
is high enough to warrant a newsgroup for CL, but I have a feeling the
burden of proof will be reversed in this case.. :-)
--
Biep
Reply via any name whatsoever at the main domain corresponding to
http://www.biep.org
[I've been busy with some realworld issues, and so I've not been posting here
much recently, so I hate to jump back in on an administrative point, but this
post did address me and no one has seemed to reply to it, so I'll field it...]
······@biep.org (Biep) writes:
> Biep wrote:
> > The point seems to me that there are three options:
> > (1) Exclude certain subjects from discussion on Usenet.
> > (2) Discuss them in the CL or Scheme (or even
> > more inappropriate) newsgroups.
> > (3) Let them have a place of their own.
>
> > Do I understand correctly that (1) is your opinion (with "certain subjects"
> > being 'non-action-oriented CL/Scheme comparisons')?
>
> Kent M Pitman <······@world.std.com> in message
> news:<···············@shell01.TheWorld.com> curtly replied:
> > No.
>
> Now I am lost. Have I omitted a possibility?
> (1) is not your position - that is what you are saying here, isnt' it?
> (2) is what you consider flamebait - which I take to imply that it is
> not your position. Am I wrong there?
> (3) is my proposal, which, as you pointed out, cannot be implemented
> until (through (1) or (2)?) traffic has been established.
You seem to suggest that if comp.lang.lisp and comp.lang.scheme are
not the correct forum, then either there is no appropriate forum or
one must be created. This is to deny the existence of several
thousand other newsgroups, any one of which might be appropriate
without the creation of a new newsgroup and without denying a right to
discuss things.
I believe a discussion group about comparative languages, for example,
would be a good place for such an academic discussion. But there
could be a number of such places.
Your suggestion that these topics necessarily belong here is the same
as saying that a critical comparison of Spanish and Greek necessarily
belongs on either a Spanish or a Greek discussion group. I don't
think that's so. For such a topic, only linguists and rare people
with statistically rare upbringings are going to find this
interesting; to round numbers, no actual speakers of either Spanish or
Greek is going to find this interesting. As such a comparative
languages group would be appropriate.
Do I think that a group has to be created for every such discussion? No.
Do I think you should absolutely be forbidden from having the
discussion here? I don't know how I'd stop it, so again: No.
However, if you are asking my opinion on whether this is a good forum for
such a discussion, the answer is no.
Incidentally, the fact that Scheme and Lisp are perhaps closer
relatives than Spanish and Greek is not argument that it should be
more likely. It is often the case that tiny divergences in culture
are more raw and painful to discuss than large divergences. Closest
cousins are often separated for extremely good reasons. For just a
few examples, pick any political hotspot on the news today (you'll
have several choices) and note how few of them are between widely
differing cultures; the recent holy war on the US is one of the few
such. Almost all extant wars are not among widely disparate cultures
but rather between cultures that have a large amount of overlap, yet
differ in some detail that one or both cultures have decided are
material. The attempt to trivialize those differences and to force
people into a shared space as if these differences did not matter is
the reason for a great deal of useless hostility... I'd rather not see
that here.
JMO.
[Please see my "apology" message elsewhere in this group.]
······@biep.org (Biep) wrote:
> The point seems to me that there are three options:
> (1) Exclude certain subjects from discussion on Usenet.
> (2) Discuss them in the CL or Scheme (or even
> more inappropriate) newsgroups.
> (3) Let them have a place of their own.
(some discussion omitted)
Kent M Pitman <······@world.std.com> wrote in message news:<···············@shell01.TheWorld.com>...
> You seem to suggest that if comp.lang.lisp and comp.lang.scheme are
> not the correct forum, then either there is no appropriate forum or
> one must be created. This is to deny the existence of several
> thousand other newsgroups, any one of which might be appropriate
> without the creation of a new newsgroup and without denying a right to
> discuss things.
Thanks for your reply. I definitely do not deny the existence (you
didn't really think I did, did you :-), but yes, I think they are
inappropriate. Hence the bracketed phrase in point (2).
I should be highly interested in discussions regarding the inclusion
or exclusion of various features into Lisp (no matter what the name of
that Lisp should be): what about standard laziness, reified locations,
you name it.
I am not here interested in generalising this discussion into one
about "the perfect programming language", because my experience is
that such discussions tend to be fruitless. I want to stay solidly
inside the Lisp family.
Point-by-point comparisons may play a (minor) role in such a
discussion, but do not have my special interest. The whys behind
differences do, as do the ways in which such whys translate to new
Lisp-linguistic environments, and possible reconciliation between
seemingly clashing requirements and outlooks.
While comp.lang.lisp may not be the appropriate forum, as the root of
the lisp language hierarchy it still is the *obvious* forum, and I
think that it would be hard to provide - not a reason, but - a valid
reason to have such a Lisp-specific discussion outside of the Lisp
hierarchy. I may very well be wrong, and I have no doubt that if so,
that valid reason will be posted here before long. :-)
I think that your arguments, while not invalid, do not address the
kind of discussion I should like to see. I want to see Lisp survive
after Scheme and CL have died. Lisp is flexible, but someday people
may wonder whether, once everybody is programming in "little language
X with all the modern features", there is any valid reason that
language X is implemented on top of an outdated Lisp with all the 20th
century features that remained because they were standardised, and
they will simply remove the underlying level. (Painted in broad
black-and-white strokes for clarity..)
What if Lisp 1.5 had been standardised (which in itself is a good
thing), and (the bad thing) general discussion about what Lisp should
be and why had been marginalised. Would Lisp have survived until now?
I think one of the strengths of Lisp is the ability that Lispers have
always had of seeing the Lisp behind the dialect differences. There
wouldn't have been a CL if they hadn't seen Lisp behind the Mac, Zeta,
Standard, Inter-, etc., and, individually, each of these languages
might well have died out.
Well, I hope I have succeeded in bringing my point across..
Biep.
[Please see my "apology" message elsewhere in this group.]
······@biep.org (Biep) wrote:
> The point seems to me that there are three options:
> (1) Exclude certain subjects from discussion on Usenet.
> (2) Discuss them in the CL or Scheme (or even
> more inappropriate) newsgroups.
> (3) Let them have a place of their own.
(some discussion omitted)
Kent M Pitman <······@world.std.com> wrote in message news:<···············@shell01.TheWorld.com>...
> You seem to suggest that if comp.lang.lisp and comp.lang.scheme are
> not the correct forum, then either there is no appropriate forum or
> one must be created. This is to deny the existence of several
> thousand other newsgroups, any one of which might be appropriate
> without the creation of a new newsgroup and without denying a right to
> discuss things.
Thanks for your reply. I definitely do not deny the existence (you
didn't really think I did, did you :-), but yes, I think they are
inappropriate. Hence the bracketed phrase in point (2).
I should be highly interested in discussions regarding the inclusion
or exclusion of various features into Lisp (no matter what the name of
that Lisp should be): what about standard laziness, reified locations,
you name it.
I am not here interested in generalising this discussion into one
about "the perfect programming language", because my experience is
that such discussions tend to be fruitless. I want to stay solidly
inside the Lisp family.
Point-by-point comparisons may play a (minor) role in such a
discussion, but do not have my special interest. The whys behind
differences do, as do the ways in which such whys translate to new
Lisp-linguistic environments, and possible reconciliation between
seemingly clashing requirements and outlooks.
While comp.lang.lisp may not be the appropriate forum, as the root of
the lisp language hierarchy it still is the *obvious* forum, and I
think that it would be hard to provide - not a reason, but - a valid
reason to have such a Lisp-specific discussion outside of the Lisp
hierarchy. I may very well be wrong, and I have no doubt that if so,
that valid reason will be posted here before long. :-)
I think that your arguments, while not invalid, do not address the
kind of discussion I should like to see. I want to see Lisp survive
after Scheme and CL have died. Lisp is flexible, but someday people
may wonder whether, once everybody is programming in "little language
X with all the modern features", there is any valid reason that
language X is implemented on top of an outdated Lisp with all the 20th
century features that remained because they were standardised, and
they will simply remove the underlying level. (Painted in broad
black-and-white strokes for clarity..)
What if Lisp 1.5 had been standardised (which in itself is a good
thing), and (the bad thing) general discussion about what Lisp should
be and why had been marginalised. Would Lisp have survived until now?
I think one of the strengths of Lisp is the ability that Lispers have
always had of seeing the Lisp behind the dialect differences. There
wouldn't have been a CL if they hadn't seen Lisp behind the Mac, Zeta,
Standard, Inter-, etc., and, individually, each of these languages
might well have died out.
Well, I hope I have succeeded in bringing my point across..
Biep.
Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote:
> CL programmer have the right to be annoyed at Scheme being discussed in
> the CL newsgroup. Lispers have the right to discuss Scheme vs. CL in the
> Lisp family newsgroup.
>
> The problem is that these seem to be the same newsgroup.
Why is it a problem for CL discussions to be in the lisp newsgroup? It's
only a problem if people are going to make it one.
MJ Ray <··········@cloaked.freeserve.co.uk> wrote in message news:<·························@cloaked.freeserve.co.uk>...
> Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote:
> > CL programmer have the right to be annoyed at Scheme being discussed in
> > the CL newsgroup. Lispers have the right to discuss Scheme vs. CL in the
> > Lisp family newsgroup.
> >
> > The problem is that these seem to be the same newsgroup.
>
> Why is it a problem for CL discussions to be in the lisp newsgroup? It's
> only a problem if people are going to make it one.
Not CL discussions, but discussions that cross boundaries between
Lisps. Sorry if I have been unclear.
From: Jeffrey Siegal
Subject: Re: Newsgroups [Was: Your introduction to Lisp...]
Date:
Message-ID: <3D079318.10805@quiotix.com>
Biep wrote:
>MJ Ray <··········@cloaked.freeserve.co.uk> wrote in message news:<·························@cloaked.freeserve.co.uk>...
>
>
>>Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote:
>>
>>
>>>CL programmer have the right to be annoyed at Scheme being discussed in
>>>the CL newsgroup. Lispers have the right to discuss Scheme vs. CL in the
>>>Lisp family newsgroup.
>>>
>>>The problem is that these seem to be the same newsgroup.
>>>
>>>
>>Why is it a problem for CL discussions to be in the lisp newsgroup? It's
>>only a problem if people are going to make it one.
>>
>>
>
>Not CL discussions, but discussions that cross boundaries between
>Lisps. Sorry if I have been unclear.
>
>
I'm annoyed by discussion about what annoys people in comp.lang.lisp
being discussed in comp.lang.scheme. Please go back where you came from.
MJ Ray <··········@cloaked.freeserve.co.uk> wrote in message news:<·························@cloaked.freeserve.co.uk>...
> Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote:
> > CL programmer have the right to be annoyed at Scheme being discussed in
> > the CL newsgroup. Lispers have the right to discuss Scheme vs. CL in the
> > Lisp family newsgroup.
> >
> > The problem is that these seem to be the same newsgroup.
>
> Why is it a problem for CL discussions to be in the lisp newsgroup? It's
> only a problem if people are going to make it one.
Not CL discussions, but discussions that cross boundaries between
Lisps. Sorry if I have been unclear.
MJ Ray <··········@cloaked.freeserve.co.uk> wrote in message news:<·························@cloaked.freeserve.co.uk>...
> Biep @ http://www.biep.org/ <·········@my-web-site.com> wrote:
> > CL programmer have the right to be annoyed at Scheme being discussed in
> > the CL newsgroup. Lispers have the right to discuss Scheme vs. CL in the
> > Lisp family newsgroup.
> >
> > The problem is that these seem to be the same newsgroup.
>
> Why is it a problem for CL discussions to be in the lisp newsgroup? It's
> only a problem if people are going to make it one.
Not CL discussions, but discussions that cross boundaries between
Lisps. Sorry if I have been unclear.
"ozan s yigit" <··@blue.cs.yorku.ca> wrote in message
····················@blue.cs.yorku.ca...
> one may as well claim that those who learn french or turkish are
> forever damaged to ever do good lisp programming... :-/
In fact, Turkish speakers seem to have a natural bend for Scheme (data from
some Turks on Internet), and I wouldn't be surprised if that were related
to the languages being so exceptionally regular and modular: very few base
words, and a generous set of very powerful suffixes to build new words from
existing ones. Once they make the swap from Polish to inverse Polish they
are almost there, in a way.
In the same way, mostly using participles also is like functional
programming.
I have no data on their Turkish and CL, unfortunately. Anybody else?
Ozan, are you a native Turkish (or Turkic) speaker?
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> In fact, Turkish speakers seem to have a natural bend for Scheme (data from
> some Turks on Internet), and I wouldn't be surprised if that were related
> to the languages being so exceptionally regular and modular: very few base
> words, and a generous set of very powerful suffixes to build new words from
> existing ones.
hmm, an interesting point. the reason i mentioned Turkish and French
was the difference in structural regularity of course [perhaps someone
with linguistics training can find better language examples, say navajo
and basque or whatever]. the point was that there is no research i know
of that learning these languages have any disabling effect. i suppose
i could have found examples that are closer to a artifical language
of limited domain, but with strong regularity.
> Ozan, are you a native Turkish (or Turkic) speaker?
native.
oz
--
time is a drug. too much of it kills you. -- terry pratchett (small gods)
>>>>> "biep" == "Biep @ http://www.biep.org/" writes, previously:
>>>>> "ozan" == ozan s yigit <··@blue.cs.yorku.ca> writes:
biep>> In fact, Turkish speakers seem to have a natural bend for
biep>> Scheme (data from some Turks on Internet), and I wouldn't be
biep>> surprised if that were related to the languages being so
biep>> exceptionally regular and modular: very few base words, and a
biep>> generous set of very powerful suffixes to build new words
biep>> from existing ones.
ozan> i suppose i could have found examples that are closer to a
ozan> artifical language of limited domain, but with strong
ozan> regularity.
I'd imagine Hungarian (Magyar) to be a wonderful language for these kind
of studies, having an immensely complex grammar and a large number of
modifiers - twenty declensions per noun (as opposed to closer to five in
English).
You could argue[1] that languages like these make those who think in
them smarter, or better programmers. A Hungarian has been the recipient
of a Nobel Prize fourteen times since 1905[2], which is certainly higher
than most, and than you'd expect for a small, fairly poor country.
- Chris.
[1]: In a different group, though, perhaps.
[2]: Cite: http://www.hungary.org/~hipcat/nobel.htm
--
$a="printf.net"; Chris Ball | ·····@void.$a | www.$a | finger: ·····@$a
As to luck, there's the old miners' proverb: Gold is where you find it.
In article <····················@void.printf.net>, ·····@void.printf.net
(Chris Ball) wrote:
>>>>>> "biep" == "Biep @ http://www.biep.org/" writes, previously:
>>>>>> "ozan" == ozan s yigit <··@blue.cs.yorku.ca> writes:
>
> biep>> In fact, Turkish speakers seem to have a natural bend for
> biep>> Scheme (data from some Turks on Internet), and I wouldn't be
> biep>> surprised if that were related to the languages being so
> biep>> exceptionally regular and modular: very few base words, and a
> biep>> generous set of very powerful suffixes to build new words
> biep>> from existing ones.
[snip]
>
>I'd imagine Hungarian (Magyar) to be a wonderful language for these kind
>of studies, having an immensely complex grammar and a large number of
>modifiers - twenty declensions per noun (as opposed to closer to five in
>English).
Suffix mania gets you Hungarian notation -- ouch!
>You could argue[1] that languages like these make those who think in
>them smarter, or better programmers. A Hungarian has been the recipient
>of a Nobel Prize fourteen times since 1905[2], which is certainly higher
>than most, and than you'd expect for a small, fairly poor country.
There are folk tales about how the complexity of the Hungarian
language leads to superior thinking skills; hence their
prodigous scientific output. (A Whorfian hypothesis of
sorts.) Then again, people used to believe that studying
Latin strengthened the ol' "mental muscle", leading to
superior performance in other domains. This belief has
been debunked from what I understand.
Finnish and Estonian are Uralic languages like Hungarian --
anyone know if speakers of these languages also win Nobels
at higher-than-average rates?
····@none.org (sv0f) writes:
> In article <····················@void.printf.net>, ·····@void.printf.net
> (Chris Ball) wrote:
>
> >>>>>> "biep" == "Biep @ http://www.biep.org/" writes, previously:
> >>>>>> "ozan" == ozan s yigit <··@blue.cs.yorku.ca> writes:
> >
> > biep>> In fact, Turkish speakers seem to have a natural bend for
> > biep>> Scheme (data from some Turks on Internet), and I wouldn't be
> > biep>> surprised if that were related to the languages being so
> > biep>> exceptionally regular and modular: very few base words, and a
> > biep>> generous set of very powerful suffixes to build new words
> > biep>> from existing ones.
> [snip]
> >
> >I'd imagine Hungarian (Magyar) to be a wonderful language for these kind
> >of studies, having an immensely complex grammar and a large number of
> >modifiers - twenty declensions per noun (as opposed to closer to five in
surely two? (nominative and genitive) ^^^^
> >English).
>
> Suffix mania gets you Hungarian notation -- ouch!
>
> >You could argue[1] that languages like these make those who think in
> >them smarter, or better programmers. A Hungarian has been the recipient
> >of a Nobel Prize fourteen times since 1905[2], which is certainly higher
> >than most, and than you'd expect for a small, fairly poor country.
>
> There are folk tales about how the complexity of the Hungarian
> language leads to superior thinking skills; hence their
> prodigous scientific output. (A Whorfian hypothesis of
> sorts.) Then again, people used to believe that studying
> Latin strengthened the ol' "mental muscle", leading to
> superior performance in other domains. This belief has
> been debunked from what I understand.
>
> Finnish and Estonian are Uralic languages like Hungarian --
> anyone know if speakers of these languages also win Nobels
> at higher-than-average rates?
Erik already reminded us how far fetched counting Nobels per capita as
a function of nationality is, but here goes anyway.
There are three Finnish nobelists, Artturi Ilmari Virtanen in
Chemistry in 1945, Franz Eemil Sillanp�� in Literature in 1939, and
Ragnar Granit in Medicine in 1967. Of course Granit is listed as
Swedish in any reasonable accurate listing, as he was Swedish at the
time of receiving the prize. Also his native language was Swedish. I
don't know is two-and-a-half nobelists for a five million population
is above or below average, but it is certainly less than the Hungarian
fourteen (for, what, ten million people?)
I'd also like to remind people that natural languages do not vary as
much in complexity as some might be inclined to think. It is true
that English is morphologically simpler than, say, Hungarian, but the
same complexity exists in English, only at the level of syntax; mostly
as prepositions coding precisely the same semantic functions as
morphological cases do in Hungarian.
I'm still thinking about what to say about the effect of the basic
word order of a programmer's native language on his preferences about
and competence in programming languages with differing preferred
orders of elements (think Lisp vs. Forth
vs. Algol-with-objects-of-the-year). It was mentioned quite a time
ago on c.l.lisp. The only productive thing I can think of after all
these weeks is that 1) programmers tend to know English anyway and 2)
a surprisingly large proportion of the world's population is actually
fluent in more than one language from very early age (about half, says
Suzanne Romaine in her book Bilingualism), and the viewpoint of people
having a single native language is unlikely to be true universally.
The languages people know can have, and often do have, wildly
different grammatical properties, so the speakers might not have even
the surface evidence of having an inbuilt sense of an Order That
Things Are In that would then match some programming language. 3)
Furthermore, many linguists won't buy the hypothesis that thoughts as
such take place in a language. To accomplish some resemblance of
rigour that is associated with the hard sciences, especially, is a
good candidate of being internally processed in a non-linguistic way,
and I personally think this extends to programming as well. So, I
think that whatever shapes our programming language preferences, it is
not our native language(s).
Of course, the latter part of the previous paragraph is about
processes not known about in the strong sense of the word, and perhaps
not even knowable.
--
Teemu Kalvas
From: Lieven Marchand
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <871ycnk5w7.fsf@wyrd.be>
Teemu Kalvas <·····@s2.org> writes:
> ····@none.org (sv0f) writes:
> > >I'd imagine Hungarian (Magyar) to be a wonderful language for these kind
> > >of studies, having an immensely complex grammar and a large number of
> > >modifiers - twenty declensions per noun (as opposed to closer to five in
>
> surely two? (nominative and genitive) ^^^^
>
> > >English).
There are remnants of some of the other cases, like whom.
> I'd also like to remind people that natural languages do not vary as
> much in complexity as some might be inclined to think. It is true
> that English is morphologically simpler than, say, Hungarian, but the
> same complexity exists in English, only at the level of syntax; mostly
> as prepositions coding precisely the same semantic functions as
> morphological cases do in Hungarian.
I'd actually be inclined to say there is no absolute complexity of
natural languages. I've never seen results about native language
acquisition that give large age differences for a certain level of
competence, which you would expect if some languages are inherently
complexer than others. For languages acquired later on the complexity
to learn a language is very dependent on the languages you already
know. If you know French, Latin and Spanish, learning Portugese isn't
going to be much of a problem. On the other hand, going from these to
Finnish would be much harder.
--
Lieven
"biep" == "Biep @ http://www.biep.org/" writes, previously:
biep>> In fact, Turkish speakers seem to have a natural bend for
biep>> Scheme (data from some Turks on Internet), and I wouldn't be
biep>> surprised if that were related to the languages being so
biep>> exceptionally regular and modular: very few base words, and a
biep>> generous set of very powerful suffixes to build new words
biep>> from existing ones.
"Teemu Kalvas" <·····@s2.org> wrote in message
···················@gobi.s2.org...
> I'd also like to remind people that natural languages do not vary as
> much in complexity as some might be inclined to think. It is true
> that English is morphologically simpler than, say, Hungarian, but the
> same complexity exists in English, only at the level of syntax; mostly
> as prepositions coding precisely the same semantic functions as
> morphological cases do in Hungarian.
I am not sure you meant this in reply to my text above (I have edited out a
set of intermediate participants), but complexity is not what I meant. In
fact, Turkish is (to me) surprisingly simple - not to speak, but in terms
of linguistic complexity.
In English (and even more so in French), one learns "the correct way". If
I want an adjective for "mouth", and I say "mouthly", people do not simply
consider this a less common word, but they consider it *wrong*. In other
words: I am discouraged from reassembling the language pieces I know in
whatever form seems useful, and instead of this "combine what you have
until you get what you want" I learn to learn "the correct way" to say
things.
In my experience, Turkish is (mostly) not like that. I keep "inventing"
words by adding, say, -ci, or -lik, or -li/-siz to other words, and time
and again the result is acceptable. I build verbs by adding sometimes up
to ten suffixes, and people understand me without so much as batting an
eye. So Turkish encourages the excercise of the compositionality principle
to a much higher degree than other languages.
Ozan, what was that disparaging expression from the time of Ataturk again?
Something like "Avrupalila,stiramayandlardandir" ?
--
Biep
>>>>> "Biep" == Biep @ http://www biep org/ <·········@my-web-site.com> writes:
[...]
Biep> ... In my experience, Turkish
Biep> is (mostly) not like that. I keep "inventing" words by
Biep> adding, say, -ci, or -lik, or -li/-siz to other words, and
Biep> time and again the result is acceptable.
Yes you can do that with a few exceptions. If the root word is
Arabic or Farsi (it used to be the case that) it is 'improper' to apply
Turkish suffix rules. Eg Arabic ihtimal (probability) can be turned into
muhtemel (probable) using Arabic rules, but not into ihtimalli(?) using
Turkish rules. People who read a lot usually pick up these foreign rules
just fine, others just learn both words or use the "pure" Turkish
equivalents. The same goes for some common Turkish words which people use
without thinking where they came from like yogurt (which you could derive
from yogusmak (to condense), but it wouldn't occur to people to do that --
instead they learn it as a word.)
Biep> I build verbs by
Biep> adding sometimes up to ten suffixes, and people understand
Biep> me without so much as batting an eye.
Yes.
Biep> So Turkish encourages
Biep> the excercise of the compositionality principle to a much
Biep> higher degree than other languages.
While that might be so, I highly doubt it carries over to programming.
I don't know where Ozan got the Turks/Scheme aptitude idea, I have not
noticed any such thing with myself. More importantly, neither did others.
Biep> Ozan, what was that disparaging expression from the time of
Biep> Ataturk again? Something like
Biep> "Avrupalila,stiramayandlardandir" ?
Maybe, Avrupalilastiramadiklarimizdandir (one of those who we could not
Europeanize) or Avrupalilastirilamayanlardandir (same in passive). This
is easy to come up with and say for me, but I had to read it twice to make
sure I wrote it down correctly. So it isn't all roses when it gets this
long. Note that one could make this longer to say by putting it in
question form but happily question suffixes are written separately (they
should be, the younger functionally illiterate crowd don't do it) or by
getting fancy with the tense (esp with the "double hearsay past tense"
like mismis!).
cheers,
BM
Bulent Murtezaoglu <··@acm.org> writes:
> While that might be so, I highly doubt it carries over to programming.
> I don't know where Ozan got the Turks/Scheme aptitude idea, I have not
> noticed any such thing with myself. More importantly, neither did others.
i never had such an idea. someone (biep?) suggested it, as anecdotal
observation. i am interested in questions about learning programming
languages; in a thread that had to do with supposed negative effects
of scheme, i made a rhetorical point about how one may just as well
argue that learning turkish and french. (obviously poor examples
because others simply *assumed* that one of the languages was
chosen for my native knowledge of it, rather than its special
linguistic characteristics).
[i hope this topic would go away from c.l.l a different group where
there may be actual professionals who are working on related fields.]
oz
--
you take a banana, you get a lunar landscape. -- j. van wijk
From: Biep @ http://www.biep.org/
Subject: Compositionality and native language [Was: Your introduction to Lisp]
Date:
Message-ID: <abe6u3$hccqr$1@ID-63952.news.dfncis.de>
"Biep" == Biep @ http://www biep org/ <·········@my-web-site.com> writes:
> What was that disparaging expression
> from the time of Ataturk again?
> Something like "Avrupalila,stiramayandlardandir" ?
"Bulent Murtezaoglu" <··@acm.org>, in message
···················@nkapi.internal...
> Maybe, Avrupalilastiramadiklarimizdandir (one of those who we could not
> Europeanize) or Avrupalilastirilamayanlardandir (same in passive).
Yep. I forgot the passive -il. Thanks!
> Yes you can do that with a few exceptions. If the root word is
> Arabic or Farsi (it used to be the case that) it is 'improper' to apply
> Turkish suffix rules. Eg Arabic ihtimal (probability) can be turned into
> muhtemel (probable) using Arabic rules, but not into ihtimalli(?) using
> Turkish rules.
What would you feel if you heard it? "Shudder, wrong! No Turk would say
that!", or "Typical for an uneducated person"? Of course the 'h' labels
the word as quite audibly non-Turkish, I gather..
> People who read a lot usually pick up these foreign rules
> just fine, others just learn both words or use the "pure" Turkish
> equivalents. The same goes for some common Turkish words which people
use
> without thinking where they came from like yogurt (which you could derive
> from yogusmak (to condense), but it wouldn't occur to people to do
that --
> instead they learn it as a word.)
What does -irt mean? It seems to be derived directly from yogmak..
> I don't know where Ozan got the Turks/Scheme aptitude idea
Oh, that is not from Ozan - I once read a discussion by some other Turks on
this, but I haven't remembered their names.. Sorry if I gave the
impression that Ozan held this position.
--
Biep
From: Bulent Murtezaoglu
Subject: Re: Compositionality and native language [Was: Your introduction to Lisp]
Date:
Message-ID: <87adr96ol8.fsf@nkapi.internal>
>>>>> "Biep" == Biep @ http://www biep org/ <·········@my-web-site.com> writes:
>> ... Eg Arabic ihtimal (probability)
>> can be turned into muhtemel (probable) using Arabic rules, but
>> not into ihtimalli(?) using Turkish rules.
Biep> What would you feel if you heard it? "Shudder, wrong! No
Biep> Turk would say that!", or "Typical for an uneducated
Biep> person"?
Depends, I wouln't shudder because I spend enough time back there to hear
the langauge to be used to people speaking "wrong." I'd probably interject
"muhtemel" possibly with simultaneous eye-rolling if the person is younger.
45+ year olds should get it right and if they don't it would be indicative
of education/social class so I would keep my mouth shut. It really is a
stupid rule, but it is one.
Biep> Of course the 'h' labels the word as quite audibly
Biep> non-Turkish, I gather..
I did not know that! But couldn't find a counter-example.
[...]
Biep> What does -irt mean? It seems to be derived directly from
Biep> yogmak..
I was hoping you wouln't call me on that. I don't know quite where
that suffix comes from. I don't think it is "irk" though, I am thinking
"kopmak"->"kopuk" as being derived the same way. I am pretty sure the
root is "yogusmak" though.
>> I don't know where Ozan got the Turks/Scheme aptitude idea
Biep> Oh, that is not from Ozan - I once read a discussion by some
Biep> other Turks on this, but I haven't remembered their names..
Biep> Sorry if I gave the impression that Ozan held this position.
No you didn't, I was confused. My apologies to Ozan.
cheers,
BM
sv0f schrieb:
> There are folk tales about how the complexity of the Hungarian
> language leads to superior thinking skills; hence their
> prodigous scientific output. (A Whorfian hypothesis of
> sorts.) Then again, people used to believe that studying
> Latin strengthened the ol' "mental muscle", leading to
> superior performance in other domains. This belief has
> been debunked from what I understand.
> Finnish and Estonian are Uralic languages like Hungarian --
> anyone know if speakers of these languages also win Nobels
> at higher-than-average rates?
Hallo
This sounds very interesting. Is there a qualified link(s) around where
I can read more about this? (Thinking about China)
stefan
·····@void.printf.net (Chris Ball) writes:
> You could argue[1] that languages like these make those who think in
> them smarter, or better programmers.
i would not, without some serious career change. :)
oz
---
you take a banana, you get a lunar landscape. -- j. van wijk
* Chris Ball
| You could argue[1] that languages like these make those who think in them
| smarter, or better programmers. A Hungarian has been the recipient of a
| Nobel Prize fourteen times since 1905[2], which is certainly higher than
| most, and than you'd expect for a small, fairly poor country.
Before you go too far on this line of argumentation, you should realize
that there is a not insignificant amount of politics involved in all the
Nobel Price. This is not to say that those who get it do not deserve it
-- far from it, the Nobel Prize is unparalleled in integrity -- but which
of the several exceptionally outstanding nominees get it is not as free
from bias as we might hope. Also be careful that you do not believe that
countries and cultures are awarded Nobel Prizes. The flip side of giving
cultures credit for the achievement of exceptional individuals is that
you give cultures the blame for excecptional evil-doing, too. While some
cultures are clearly rotten to the core, they still "produce" singular
achievement -- sports achievements is the archetypical alibi for a rotten
culture, because cultures that have no intellectual capital always resort
to sports, both for their highest achievenments and their entertainment.
However, I would not want to hold France as such responsible for Le Pen
any more than Hungary as such for Hungarian notation. Poor countries may
also have an astonishing concentration of power and money that make it
more likely that they can afford to invest in their geniuses. All in
all, national pride because of some accident of birth place is generally
a phenomenally bad idea, and leads to such things as national guilt, too.
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
70 percent of American adults do not understand the scientific process.
On Tue, 07 May 2002 13:32:59 -0700, Len Charest <········@my.inbox> wrote:
>Erik Naggum wrote:
>
>> some cultures are clearly rotten to the core
>
>I'm curious: which ones? How can you tell?
One obvious consideration is whether the culture condones, or even
institutionalizes cruelty toward identifiable groups, and to what degrees.
Len Charest <········@my.inbox> writes:
> Erik Naggum wrote:
>
> > some cultures are clearly rotten to the core
>
> I'm curious: which ones? How can you tell?
I'd rather know which ones are *not*, and how they're identifiable.
Patrick schrieb:
> Len Charest <········@my.inbox> writes:
> > Erik Naggum wrote:
> > > some cultures are clearly rotten to the core
Well. Erik sometimes can use words like a knife. *huch*
> > I'm curious: which ones? How can you tell?
> I'd rather know which ones are *not*, and how they're identifiable.
The problem seems to bee: how to bring them back again. Isn't it one
world?
stefan
On Tue, 7 May 2002 13:20:35 +0200, Biep @ http://www.biep.org/
<·········@my-web-site.com> wrote:
>"ozan s yigit" <··@blue.cs.yorku.ca> wrote in message
>····················@blue.cs.yorku.ca...
>> one may as well claim that those who learn french or turkish are
>> forever damaged to ever do good lisp programming... :-/
>
>In fact, Turkish speakers seem to have a natural bend for Scheme (data from
>some Turks on Internet),
I sense a disturbance in the bogon field.
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> Once they make the swap from Polish to inverse Polish they
> are almost there, in a way.
I like that - the Turkish, making the swap from Polish to inverse
Polish :-)
'Andreas
--
Wherever I lay my .emacs, there�s my $HOME.
Kent M Pitman <······@world.std.com> writes:
> > � http://www.oreilly.com/oreilly/author/writeforus_1101.html
>
> Thanks for the page reference.
>
> I'll see if I can follow up with O'Reilly to find out what the issue
> is here. If I can get a contact address. I got a 404 when I
> clicked on the "O'Reilly Contacts" item at the bottom of that page.
> Maybe they don't want a book on web training because it would
> challenge the job security of their webmaster. ;)
Hehe, maybe he himself has added 'web training' to the list of
'not-wanted' subjects... :)
Anyway, the page you were looking for seems to be this one:
<http://www.oreilly.com/oreilly/contact.html>
It would be nice to hear what they answer to your questions.
Edi.
--
Dr. Edmund Weitz
Hamburg
Germany
The Common Lisp Cookbook
<http://cl-cookbook.sourceforge.net/>
On Thu, 11 Apr 2002 17:16:08 GMT, Kent M Pitman <······@world.std.com>
wrote:
> Erik Naggum <····@naggum.net> writes:
[...]
> > However, we're NOT looking for: Any books on LISP, LaTeX, or
> > Web-based training.
>
> Could this just mean one is in the pipe? Does anyone know why this would
> be there? If it is a bad experience, can we find out what?
[...]
> > � http://www.oreilly.com/oreilly/author/writeforus_1101.html
I have this Nutshell Series handbook:
"Making TeX work"
Norman Walsh
O'Reilly, 1994 (first edition)
ISBN 1-56592-051-1
It mentions LaTeX[2e] in a few chapters. There's also a Nusthell handbook
on Emacs Lisp.
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
[http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/]
In an attempt to throw the authorities off his trail, Paolo Amoroso <·······@mclink.it> transmitted:
> On Thu, 11 Apr 2002 17:16:08 GMT, Kent M Pitman <······@world.std.com>
> wrote:
>
>> Erik Naggum <····@naggum.net> writes:
> [...]
>> > However, we're NOT looking for: Any books on LISP, LaTeX, or
>> > Web-based training.
>>
>> Could this just mean one is in the pipe? Does anyone know why this would
>> be there? If it is a bad experience, can we find out what?
> [...]
>> > � http://www.oreilly.com/oreilly/author/writeforus_1101.html
>
> I have this Nutshell Series handbook:
>
> "Making TeX work"
> Norman Walsh
> O'Reilly, 1994 (first edition)
> ISBN 1-56592-051-1
>
> It mentions LaTeX[2e] in a few chapters. There's also a Nutshell handbook
> on Emacs Lisp.
... A handbook published back in 1997.
There hasn't been any Lisp material published by O'Reilly in, what,
five years?
I expect that they got burned by one or another project, and concluded
that they wanted nothing more to do with these technologies.
--
(concatenate 'string "aa454" ·@freenet.carleton.ca")
http://www.ntlug.org/~cbbrowne/multiplexor.html
"For systems, the analogue of a face-lift is to add to the control
graph an edge that creates a cycle, not just an additional node."
-- Alan Perlis
Christopher Browne <········@acm.org> writes:
> >> Erik Naggum <····@naggum.net> writes:
> > [...]
> >> > However, we're NOT looking for: Any books on LISP, LaTeX, or
> >> > Web-based training.
>
> There hasn't been any Lisp material published by O'Reilly in, what,
> five years?
I wonder whether employing L*rry W*ll might have something to do with
this. maybe not.
--
You cannot really appreciate "Dilbert" unless you've read it in the
original Klingon.
-- Klingon Programmer
* Michael Livshin
| I wonder whether employing L*rry W*ll might have something to do with
| this. maybe not.
According my off-the-record inside information, it has very much to do
with the psychotic hatred L*rry W*ll has for Lisp, but it is precisely
Scheme that he has such phenomenal problems with, and then he thinks that
the whole family of languages that uses parentheses is similarly evil,
like a good old southern racist who has met one bad black guy. Common
Lisp does _not_ suffer from the same problems that Scheme does, and it is
such a different language that nothing anybody know about Scheme should
be presumed to apply to Common Lisp without checking thoroughly that it
actually does. This is lost on people who have invested too much in
their own culture to be able to think anything valuable can come from any
other.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <··············@yahoo.com.cmm>,
Michael Livshin <········@yahoo.com> wrote:
>Christopher Browne <········@acm.org> writes:
>
>> >> Erik Naggum <····@naggum.net> writes:
>> > [...]
>> >> > However, we're NOT looking for: Any books on LISP, LaTeX, or
>> >> > Web-based training.
>>
>> There hasn't been any Lisp material published by O'Reilly in, what,
>> five years?
>
>I wonder whether employing L*rry W*ll might have something to do with
>this. maybe not.
The better speculation -- since O'Reilly has not been
averse to Emacs Lisp -- is that they have a book on
Guile in the works, and don't want to confuse a
skittish public with a similar "competing" book of
their own.
In the case of TeX, the canonical books have already
been written. The need is for practical books that
describe the fast-growing and -changing "suburbia" of
programs that have clumped up around TeX. O'Reilly's
_Making TeX Work_ did indeed try to deal with this.
Unfortunately, it got obsolete pretty fast.
* Dorai Sitaram
| The better speculation -- since O'Reilly has not been averse to Emacs
| Lisp -- is that they have a book on Guile in the works, and don't want to
| confuse a skittish public with a similar "competing" book of their own.
Please read the page to which I provided a link. This speculation may be
"better", but it is extremely far-fetched.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
····@goldshoe.gte.com (Dorai Sitaram) writes:
> In article <··············@yahoo.com.cmm>,
> Michael Livshin <········@yahoo.com> wrote:
> >
> >I wonder whether employing L*rry W*ll might have something to do with
> >this. maybe not.
>
> The better speculation -- since O'Reilly has not been
> averse to Emacs Lisp -- is that they have a book on
> Guile in the works, and don't want to confuse a
> skittish public with a similar "competing" book of
> their own.
::sound of jaw dropping on the floor::
is it according to some inside information?
anyway, the audiences of Guile and CL are not really overlapping, are
they?
--
Computer Science is embarrassed by the computer.
-- Alan Perlis
In article <··············@yahoo.com.cmm>,
Michael Livshin <········@yahoo.com> wrote:
>····@goldshoe.gte.com (Dorai Sitaram) writes:
>
>> In article <··············@yahoo.com.cmm>,
>> Michael Livshin <········@yahoo.com> wrote:
>> >
>> >I wonder whether employing L*rry W*ll might have something to do with
>> >this. maybe not.
>>
>> The better speculation -- since O'Reilly has not been
>> averse to Emacs Lisp -- is that they have a book on
>> Guile in the works, and don't want to confuse a
>> skittish public with a similar "competing" book of
>> their own.
>
>::sound of jaw dropping on the floor::
>
>is it according to some inside information?
No. Don't worry! :-)
>anyway, the audiences of Guile and CL are not really overlapping, are
>they?
They may not, but I am talking about the publisher's
risk. Remember how easy it was to go along with the
postulate that O'Reilly's alleged anti-LISP stance was
really anti-Scheme, and that it was because they
couldn't tell the difference, etc? Draw your own
conclusions.
O'Reilly is very into glue, script, extension
languages. That's the niche Guile wants. And it is
too much of an 800-pound gorilla (as Olin Shivers,
author of a competing Scheme, memorably described
it) for O'Reilly to ignore.
In an attempt to throw the authorities off his trail, ····@goldshoe.gte.com (Dorai Sitaram) transmitted:
> In article <··············@yahoo.com.cmm>,
> Michael Livshin <········@yahoo.com> wrote:
>>····@goldshoe.gte.com (Dorai Sitaram) writes:
>>> In article <··············@yahoo.com.cmm>,
>>> Michael Livshin <········@yahoo.com> wrote:
>>> >I wonder whether employing L*rry W*ll might have something to do
>>> >with this. maybe not.
>>> The better speculation -- since O'Reilly has not been averse to
>>> Emacs Lisp -- is that they have a book on Guile in the works, and
>>> don't want to confuse a skittish public with a similar "competing"
>>> book of their own.
>>::sound of jaw dropping on the floor::
>>
>>is it according to some inside information?
>
> No. Don't worry! :-)
>
>>anyway, the audiences of Guile and CL are not really overlapping,
>>are they?
> They may not, but I am talking about the publisher's risk. Remember
> how easy it was to go along with the postulate that O'Reilly's
> alleged anti-LISP stance was really anti-Scheme, and that it was
> because they couldn't tell the difference, etc? Draw your own
> conclusions.
There's a good question...
They _can't_ have the "truly definitive" works on CL; between CLTL2
and the HyperSpec, there are _quite_ definitive works that they would
have a horribly hard time beating.
Parallel that with the LaTeX/TeX world; the _definitive_ works on
LaTeX/TeX are largely produced by Addison Wesley, and O'Reilly can't
readily compete with that.
And I'd judge that the "can't readily compete" issue _is_ quite
relevant. It's a good reason for them not to bother with TeX-related
books, and I think it's a reasonably good cause for them to stay out
of CL.
> O'Reilly is very into glue, script, extension languages. That's the
> niche Guile wants. And it is too much of an 800-pound gorilla (as
> Olin Shivers, author of a competing Scheme, memorably described it)
> for O'Reilly to ignore.
I would see Scheme fitting into O'Reilly's "mindspace" quite a bit
more comfortably than Common Lisp.
It is a very interesting thing that there _hasn't_ been a book
produced on Guile; I could chalk up a chunk of that to anti-RMS
politics; RMS would, of course, want a "manual" about Guile to be
released under the FDL, and would likely be quite critical of ORA on
the matter.
The somewhat sporadic release schedule for Guile can't have been
helpful; the "glue nature" of the early intent hasn't turned out
nearly so strongly. Everybody _isn't_ embedding it in GNOME
applications, which is actually quite disappointing. The GNOME folks
have jumped fairly firmly into the XML camp, where instead of having a
powerful Scheme around (pun intended!) for managing configuration, you
embed an XML library, and have to code any extensibility into the
application. Well, I guess that's not really "extensibility"...
If the plans to have a compiled form of Guile (originally intended via
the "Hobbit" Scheme-to-C transformer) had turned out, things might
have turned out quite differently.
But as it stands, Guile is used by a couple of GNOME applications, and
has a CLOS-quasi-clone that nobody can _realistically_ use because Red
Hat doesn't keep their install of Guile anywhere near up to date, so
that if an application depended on "GOOPS," it wouldn't be able to run
on common Linux distributions, thereby making the application
essentially worthless.
You know what? I think the reason for ORA to not publish on Guile
just yet is that it's not nearly ready. And by the time it is, there
will probably be a more definitive work published by someone else.
--
(reverse (concatenate 'string ········@" "enworbbc"))
http://www.ntlug.org/~cbbrowne/lisp.html
I'm not born again -- my mother got it right the first time.
"Erik Naggum" <····@naggum.net> ha scritto nel messaggio ·····················@naggum.net...
> I think "Your introductoin to Scheme" should go in comp.lang.scheme.
What are you talking about? What introduction to Scheme?
P.
Pierpaolo BERNARDI wrote:
>
> "Donald Fisk" <················@enterprise.net> ha scritto nel messaggio ······················@enterprise.net...
>
> > Shortly after that I was using PC Scheme (cue: Is
> > Scheme a Lisp?)
>
> Well, the front cover of the manual says:
>
> "PC Scheme
> a simple, modern Lisp"
I vaguely remember this. All I can say is that before I used PC
Scheme,
I was already familiar with Common Lisp through CLTL1, though I had
never
programmed in it; and one of the first things I did was write a whole
load
of Scheme functions and macros to provide some of the functionality
present
in Common Lisp. I suppose I'm a Lisper at heart rather than a Schemer.
This was when I worked at Texas Instruments. After I left, their
office
acquired an Explorer, and I was offered access to it, an offer I now
regret not taking up more than the once that I did.
> P.
--
Le Hibou
You know you've been hacking too long if, when someone
asks you if you have a son, you reply, "No, but I've
got a Symbolics 3630".
Hey everybody,
I am new to LISP and wanted to know how to change the value in a nested
list? for example,
(w (t u) (t r)) change it to (X (X X) (X X))??
Sherif
Posted Via Usenet.com Premium Usenet Newsgroup Services
----------------------------------------------------------
** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
----------------------------------------------------------
http://www.usenet.com
From: Christian Nyb�
Subject: Re: introduction to Lisp...
Date:
Message-ID: <87d6x3bs01.fsf@nybo.no>
"Sherif Elbanhawy" <················@hotmail.com> writes:
> I am new to LISP and wanted to know how to change the value in a nested
> list? for example,
> (w (t u) (t r)) change it to (X (X X) (X X))??
How would you change the value in a flat list? For example (w t r u)
=> (x x x x)?
--
chr
How do i use a list of characters as an argument to char-code???
help
desperate.
"Sherif Elbanhawy" <················@hotmail.com> wrote in message
·················@Usenet.com...
> Hey everybody,
>
> I am new to LISP and wanted to know how to change the value in a nested
> list? for example,
> (w (t u) (t r)) change it to (X (X X) (X X))??
>
> Sherif
>
>
>
>
>
> Posted Via Usenet.com Premium Usenet Newsgroup Services
> ----------------------------------------------------------
> ** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
> ----------------------------------------------------------
> http://www.usenet.com
Posted Via Usenet.com Premium Usenet Newsgroup Services
----------------------------------------------------------
** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
----------------------------------------------------------
http://www.usenet.com
"Sherif Elbanhawy" <················@hotmail.com> writes:
> How do i use a list of characters as an argument to char-code???
> help
> desperate.
CHAR-CODE takes a character and returns its code. It doesn't take a list
of characters. You might want to look up how functions that operate on
lists work. See the documentation on MAPCAR, for example.
> "Sherif Elbanhawy" <················@hotmail.com> wrote in message
> ·················@Usenet.com...
> > Hey everybody,
> >
> > I am new to LISP and wanted to know how to change the value in a nested
> > list? for example,
> > (w (t u) (t r)) change it to (X (X X) (X X))??
(subst-if 'x (complement #'listp) '(w (t u) (t r)))
See the documentation for SUBST-IF, COMPLEMENT, and LISTP for further
explanation.
Documentation on Common Lisp functions can be found in the Common Lisp
HyperSpec at
http://www.xanalys.com/software_tools/reference/HyperSpec/Front/index.htm
You can download a copy of the HyperSpec for your personal use from
http://www.xanalys.com/software_tools/reference/HyperSpec/
Hey guys,
Is this a lisp technical discussion group or what....I did not even receive
a comment about my questions....
desperate here...:)
"Sherif Elbanhawy" <················@hotmail.com> wrote in message
···············@Usenet.com...
> How do i use a list of characters as an argument to char-code???
> help
> desperate.
> "Sherif Elbanhawy" <················@hotmail.com> wrote in message
> ·················@Usenet.com...
> > Hey everybody,
> >
> > I am new to LISP and wanted to know how to change the value in a nested
> > list? for example,
> > (w (t u) (t r)) change it to (X (X X) (X X))??
> >
> > Sherif
> >
> >
> >
> >
> >
> > Posted Via Usenet.com Premium Usenet Newsgroup Services
> > ----------------------------------------------------------
> > ** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
> > ----------------------------------------------------------
> > http://www.usenet.com
>
>
>
> Posted Via Usenet.com Premium Usenet Newsgroup Services
> ----------------------------------------------------------
> ** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
> ----------------------------------------------------------
> http://www.usenet.com
Posted Via Usenet.com Premium Usenet Newsgroup Services
----------------------------------------------------------
** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
----------------------------------------------------------
http://www.usenet.com
"Sherif Elbanhawy" <················@hotmail.com> wrote in message news:<············@Usenet.com>...
> Hey guys,
>
> Is this a lisp technical discussion group or what....I did not even receive
> a comment about my questions....
Kent Pitman referred you to the aprropriate documentation for your
question(s) - <http://www.xanalys.com/software_tools/reference/HyperSpec/Front/index.htm>
These are very basic questions, (the kind of problem that one
encounters in the first week of an introductory course) so you should
be able to find the answers yourself by reading the HyperSpec - Kent
even gave you an additional hint, and suggested that you should take a
look at mapcar.
Please don't take offense, but we get a lot of students here
essentially asking correspondents to c.l.l to do their homework for
them. Yours are such elementary questions, that they look like a first
week homework set. If you're not asking for help with homework, but
are merely a newcomer to Common Lisp, then your should *really*
familiarize yourself with the HyperSpec - a document which is one of
the best references for any subject anywhere - the Common Lisp
community is *extremely* fortunate to have it.
BTW, Kent, who was too modest to say so in his post, is the author of
the HyperSpec.
On Sun, 14 Apr 2002 11:00:32 -0400,
Sherif Elbanhawy <················@hotmail.com> wrote:
> Hey guys,
>
> Is this a lisp technical discussion group or what....I did not even receive
> a comment about my questions....
>
you might want to check your news setup, as there have been
replies to your post. If you search on google, you will
find:
http://groups.google.com/groups?hl=en&newwindow=1&frame=right&
th=b1c827a816d47c6c&seekm=sfw1ydj85s0.fsf%40shell01.TheWorld.com
(the above is just one very long link)
s.
"Sherif Elbanhawy" <················@hotmail.com> writes:
> Is this a lisp technical discussion group or what....I did not even receive
> a comment about my questions....
>
> desperate here...:)
You did get replies.
However, it's hardly surprising you didn't see them and that's your
own fault. You should also always start a new thread when starting a
new topic and put a clear subject line on it. (This is standard
newsgroup procedure, not just for comp.lang.lisp.) Your question was
not about "introduction to Lisp..." so you should have started a new topic.
Having a proper subject line would have made it very much easier to search
for the replies.
You also even followed up your own original post about substitution
with an apparently-unrelated post about char-code. If those two were
related questions, you did not say how. If they were not releated, you
needed to start a new thread again.
I replied to both of your queries.
Incidentally, you didn't say if this was homework. If it was, you should
have said so in the problem description, and you should also have provided
a sample of what code you'd written so far...
Kent, all,
You are absolutely right about what you said. this is the first time I use
newsgroups for such things...
Thanks for replying to me. and here are the questions in a clear way and
what I did so far:
i wanted to construct a function that will sort this list:
(b (c (d (e f)) ) g h k)
i was able to write the function to sort a list like this but that has
integers and not characters.
(defun print_list(L)
(cond
((NULL L) nil)
((atom L) (list L))
(t (append (print_list (car list1)) (print_list (cdr list1)) ) )
))
I was able to get all the values of the list in one list (b c d e f g h k)
then I wanna pass this list to char-code to have all the values changed to
their ASCII code.
I used this function that I wrote
(sort (mapcar #'char-code '(#\t #\y)) #'>)
but the problem is I wanna feed the characters in the list to char-code and
not characters that I hardcoded (ex. (#\t #\y in the above example)
Hope I am clear this time:)
Sherif
"Kent M Pitman" <······@world.std.com> wrote in message
····················@shell01.TheWorld.com...
> "Sherif Elbanhawy" <················@hotmail.com> writes:
>
> > Is this a lisp technical discussion group or what....I did not even
receive
> > a comment about my questions....
> >
> > desperate here...:)
>
> You did get replies.
>
> However, it's hardly surprising you didn't see them and that's your
> own fault. You should also always start a new thread when starting a
> new topic and put a clear subject line on it. (This is standard
> newsgroup procedure, not just for comp.lang.lisp.) Your question was
> not about "introduction to Lisp..." so you should have started a new
topic.
> Having a proper subject line would have made it very much easier to search
> for the replies.
>
> You also even followed up your own original post about substitution
> with an apparently-unrelated post about char-code. If those two were
> related questions, you did not say how. If they were not releated, you
> needed to start a new thread again.
>
> I replied to both of your queries.
>
> Incidentally, you didn't say if this was homework. If it was, you should
> have said so in the problem description, and you should also have provided
> a sample of what code you'd written so far...
>
Posted Via Usenet.com Premium Usenet Newsgroup Services
----------------------------------------------------------
** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
----------------------------------------------------------
http://www.usenet.com
"Sherif Elbanhawy" <················@hotmail.com> writes:
> i wanted to construct a function that will sort this list:
>
> (b (c (d (e f)) ) g h k)
>
> i was able to write the function to sort a list like this but that has
> integers and not characters.
Your tree doesn't contain characters, it contains symbols. Had it
contained characters, Lisp would have printed it like this:
(#\B (#\C (#\D (#\E #\F))) #\G #\H #\K)
> then I wanna pass this list to char-code to have all the values changed to
> their ASCII code.
>
> I used this function that I wrote
> (sort (mapcar #'char-code '(#\t #\y)) #'>)
>
> but the problem is I wanna feed the characters in the list to char-code and
> not characters that I hardcoded (ex. (#\t #\y in the above example)
You can perform limited conversion of symbols into characters with
either the COERCE or CHARACTER functions. For example, a function
which would translate your tree of symbols into a tree of characters
could look like this:
(defun characterify-tree (tree &optional acc)
(cond ((null tree)
acc)
((consp (car tree))
(characterify-tree (cdr tree)
(append acc (list (characterify-tree (car tree) nil)))))
(t
(characterify-tree (cdr tree)
(append acc (list (character (car tree))))))))
Or, using more contemporary Common Lisp functionality, like this:
(defun characterify-tree (tree)
(loop for elt in tree
collect (if (consp elt) (characterify-tree elt) (character elt))))
Either way, you should get results like this:
(characterify-tree '(a b (c d (e f) g) h))
=> (#\A #\B (#\C #\D (#\E #\F) #\G) #\H)
If any of this seems useful, you really ought to read the Common Lisp
HyperSpec entry for the CHARACTER function. It has a brief discussion
of the situations where coercion between symbols and characters will
(and will not) work.
Ok guys,
Why is this not working??
(defun print_list(L)
(cond
((null L) nil)
((atom L) (list L))
(t (append (print_list (car L)) (print_list (cdr L)))
(stable-sort (L) #'char-lessp))
I am trying to >(print_list '(#\f (#\h (#\b (#\e #\d)) ) #\g #\c #\k))
to get a sorted list (b c d e f g h k)
What is missing here?? please help!!!
If I wanted to use prog() here what do I need to do......
Appreciate all the help.
"Carl Shapiro" <·············@panix.com> wrote in message
····················@panix3.panix.com...
> "Sherif Elbanhawy" <················@hotmail.com> writes:
>
> > i wanted to construct a function that will sort this list:
> >
> > (b (c (d (e f)) ) g h k)
> >
> > i was able to write the function to sort a list like this but that has
> > integers and not characters.
>
> Your tree doesn't contain characters, it contains symbols. Had it
> contained characters, Lisp would have printed it like this:
>
> (#\B (#\C (#\D (#\E #\F))) #\G #\H #\K)
>
> > then I wanna pass this list to char-code to have all the values changed
to
> > their ASCII code.
> >
> > I used this function that I wrote
> > (sort (mapcar #'char-code '(#\t #\y)) #'>)
> >
> > but the problem is I wanna feed the characters in the list to char-code
and
> > not characters that I hardcoded (ex. (#\t #\y in the above example)
>
> You can perform limited conversion of symbols into characters with
> either the COERCE or CHARACTER functions. For example, a function
> which would translate your tree of symbols into a tree of characters
> could look like this:
>
> (defun characterify-tree (tree &optional acc)
> (cond ((null tree)
> acc)
> ((consp (car tree))
> (characterify-tree (cdr tree)
> (append acc (list (characterify-tree (car
tree) nil)))))
> (t
> (characterify-tree (cdr tree)
> (append acc (list (character (car tree))))))))
>
> Or, using more contemporary Common Lisp functionality, like this:
>
> (defun characterify-tree (tree)
> (loop for elt in tree
> collect (if (consp elt) (characterify-tree elt) (character elt))))
>
> Either way, you should get results like this:
>
> (characterify-tree '(a b (c d (e f) g) h))
> => (#\A #\B (#\C #\D (#\E #\F) #\G) #\H)
>
> If any of this seems useful, you really ought to read the Common Lisp
> HyperSpec entry for the CHARACTER function. It has a brief discussion
> of the situations where coercion between symbols and characters will
> (and will not) work.
Posted Via Usenet.com Premium Usenet Newsgroup Services
----------------------------------------------------------
** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
----------------------------------------------------------
http://www.usenet.com
"Sherif Elbanhawy" <················@hotmail.com> writes:
> (defun print_list(L)
Given the style of this function and the desire to use PROG, I get the
impression that this class is being taught in an antedilluvian (before
the flood of dialects?) style. Did people actually use underscores as
word separators back then? I thought the underscore was a very rare
character to have before ASCII was in nearly universal use. Or is this
just an attempt to make the C programmers taking the class feel
better?
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
From: Sherif Elbanhawy
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <3cba4ad4$1_3@Usenet.com>
Ok Rahul, since you were the first one to know I am a C programmer, let me
ask you this:
This is my code now:
(defun print_list(L)
(progn()
(cond
((null L) nil)
((atom L) (list L))
(t (append (print_list (car L)) (print_list (cdr L)))))
(stable-sort L #'char-lessp)))
All I want now is to make the stable-sort function use the list output by
the (con..... statement and not the original list. I think that is all I
need, right???
"Rahul Jain" <·····@sid-1129.sid.rice.edu> wrote in message
······················@photino.sid.rice.edu...
> "Sherif Elbanhawy" <················@hotmail.com> writes:
>
>
> > (defun print_list(L)
>
> Given the style of this function and the desire to use PROG, I get the
> impression that this class is being taught in an antedilluvian (before
> the flood of dialects?) style. Did people actually use underscores as
> word separators back then? I thought the underscore was a very rare
> character to have before ASCII was in nearly universal use. Or is this
> just an attempt to make the C programmers taking the class feel
> better?
>
> --
> -> -/ - Rahul Jain - \- <-
> -> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
> -> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
> -> -\ people if [they] try to walk around on their own. I really /- <-
> -> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
> |--|--------|--------------|----|-------------|------|---------|-----|-|
> (c)1996-2002, All rights reserved. Disclaimer available upon request.
Posted Via Usenet.com Premium Usenet Newsgroup Services
----------------------------------------------------------
** SPEED ** RETENTION ** COMPLETION ** ANONYMITY **
----------------------------------------------------------
http://www.usenet.com
"Sherif Elbanhawy" <················@hotmail.com> writes:
> Ok Rahul, since you were the first one to know I am a C programmer, let me
> ask you this:
> This is my code now:
>
> (defun print_list(L)
> (progn()
> (cond
> ((null L) nil)
> ((atom L) (list L))
> (t (append (print_list (car L)) (print_list (cdr L)))))
> (stable-sort L #'char-lessp)))
>
> All I want now is to make the stable-sort function use the list output by
> the (con..... statement and not the original list. I think that is all I
> need, right???
People here are trying to be helpful. They are giving you all sorts
of information. E.g. the fact that your input list does not have
characters but symbols.
And the fact that you should use a better editor (since your
indentation is "less-than-optimal").
Have you understood the difference between symbols and characters?
Here is the solution BTW. Hope it will help you homework.
Given your last post, I will assume that your input list L is a nested
list of characters.
(defun sort-the-homework-list (L)
(sort (flatten L) #'char<=))
Now. If you want you can also check L
(defun sort-the-homework-list-2 (L)
(let ((flattened-list (flatten L)))
(unless (every #'characterp flattened-list)
(error "Some element in the list (~S) is not a character."
(find-if (complement #'characterp) flattened-list)))
(sort flattened-list #'char<)))
Does this help? Note that this is a good answer. If your instructor
wnats something different it is his problem.
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
From: Erik Naggum
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <3227863232118899@naggum.net>
* Rahul Jain
| Did people actually use underscores as word separators back then? I
| thought the underscore was a very rare character to have before ASCII was
| in nearly universal use.
The underscore is quite young. The character in that position in ASCII and
its precursors has a long history, but generally, _ was a back-arrow and
^ was an up-arrow. _ has come to replace blank, which many have rendered
as an underscore with very short vertical bars on each side. Primitive
syntax descriptions have a serious problem with whitespace, so they claim
that a-b is three tokens, a_b one. This arbitrariness is frustrating to
people who know better. OfCoursePeopleWhoWriteLikeThisDoNotSeeTheProblem.
| Or is this just an attempt to make the C programmers taking the class
| feel better?
It is probably a feebleminded attempt to learn real syntaxes in stages,
slow adaptability or something. I mean, no textbooks on Lisp or Scheme
or any other sufficiently similar language uses _ in identifiers, so this
is an independent creation of the student who is unable to observe what
others are doing. Generally, I consider poor indentation and _ in symbol
names a clear sign that the requestor is more lost that I would consider
it in my interest to try to rectify.
But more generally, space should be a valid character in identifiers, and
with ISO 8859 and Unicode, it can be: just use the non-breaking-space. I
think this really _rules_ for extra super-high readability.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
>
> But more generally, space should be a valid character in identifiers,
and
> with ISO 8859 and Unicode, it can be: just use the non-breaking-space.
I
> think this really _rules_ for extra super-high readability.
Provided there is *some* way to visually distinguish it from a breaking
space!
In article <························@typhoon.ne.ipsvc.net>, Joe Marshall wrote:
>
> "Erik Naggum" <····@naggum.net> wrote in message
> ·····················@naggum.net...
>>
>> But more generally, space should be a valid character in identifiers,
> and
>> with ISO 8859 and Unicode, it can be: just use the non-breaking-space.
> I
>> think this really _rules_ for extra super-high readability.
>
> Provided there is *some* way to visually distinguish it from a breaking
> space!
Ask your editor to underline them ;-)
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
From: Dorai Sitaram
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <a9etsi$f7r$1@news.gte.com>
In article <························@typhoon.ne.ipsvc.net>,
Joe Marshall <·············@attbi.com> wrote:
>
>"Erik Naggum" <····@naggum.net> wrote in message
>·····················@naggum.net...
>>
>> But more generally, space should be a valid character in identifiers,
>and
>> with ISO 8859 and Unicode, it can be: just use the non-breaking-space.
>I
>> think this really _rules_ for extra super-high readability.
>
>Provided there is *some* way to visually distinguish it from a breaking
>space!
CL practice is tolerant of visually indistinguishable
programs behaving differently, as came up in the
discussion of the ~<newline> format directive.
····@goldshoe.gte.com (Dorai Sitaram) writes:
> CL practice is tolerant of visually indistinguishable
> programs behaving differently, as came up in the
> discussion of the ~<newline> format directive.
FORMAT does not use the CL reader to parse the format string.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
From: Erik Naggum
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <3227875929073628@naggum.net>
* "Joe Marshall"
| Provided there is *some* way to visually distinguish it from a breaking
| space!
None whatsoever if the font is right...
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
> * "Joe Marshall"
> | Provided there is *some* way to visually distinguish it from a breaking
> | space!
>
> None whatsoever if the font is right...
I suppose someone will hack Emacs such that non-breaking spaces
are suppressed and the following word capitalized.
From: Erik Naggum
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <3227890707208178@naggum.net>
* "Joe Marshall"
| I suppose someone will hack Emacs such that non-breaking spaces are
| suppressed and the following word capitalized.
Are you serious? It does not look like you are playing along.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
> * "Joe Marshall"
> | I suppose someone will hack Emacs such that non-breaking spaces are
> | suppressed and the following word capitalized.
>
> Are you serious? It does not look like you are playing along.
It's scary when the truly absurd is indistiguishable from the
all too plausible.
> > | I suppose someone will hack Emacs such that non-breaking spaces are
> > | suppressed and the following word capitalized.
> >
> > Are you serious? It does not look like you are playing along.
>
> It's scary when the truly absurd is indistiguishable from the
> all too plausible.
This brings to mind a problem I had with emacs.
When I started using emacs 21, I noticed I was seeing code something
like the following:
(let ((var 2))
(if (> *var* 1) (print "foo") (print "bar")))
I'd try the code and it wouldn't work. Because of all the syntax
highlighting etc that GNUS does, it didn't really hit me that the var
in
(let ((var 2))
was bold-face.
Turns out that GNUS now takes
*something*
and turns it into
something
where the latter "something" is in bold face.
Not good when it does it in program code.
But at least now I get this little smiley icon instead of the ascii
smilies. :-)
--
Fred Gilham ······@csl.sri.com
Communism is a murderous failure.
Socialism is communism with movie stars.
Fred Gilham <······@snapdragon.csl.sri.com> writes:
> Turns out that GNUS now takes
> *something*
> and turns it into
> something
> where the latter "something" is in bold face.
[...]
> But at least now I get this little smiley icon instead of the ascii
> smilies. :-)
Actually, the two features are completely separate, so you can
enable/disable them independently. e.g., I have the fontification
turned on and the smileys turned off (far too many false positives). I
should disable the fontification soon...
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Fred Gilham <······@snapdragon.csl.sri.com> writes:
> Turns out that GNUS now takes
>
> *something*
>
> and turns it into
>
> something
>
> where the latter "something" is in bold face.
I think I prefer what slrn does, which is boldface the "emphasized"
text, but keep the emphasis characters around. That way false
positives will not affect the readability of the posted code.
Hrvoje Niksic <·······@arsdigita.com> writes:
> Fred Gilham <······@snapdragon.csl.sri.com> writes:
>
> > Turns out that GNUS now takes
"gnus"
> > *something*
> >
> > and turns it into
> >
> > something
> >
> > where the latter "something" is in bold face.
>
> I think I prefer what slrn does, which is boldface the "emphasized"
> text, but keep the emphasis characters around. That way false
> positives will not affect the readability of the posted code.
I think gnus can do that too (on the grounds that gnus can do
more-or-less anything, plus a vague memory). Don't remember how,
though.
Cheers,
M.
--
In that case I suggest that to get the correct image you look at
the screen from inside the monitor whilst standing on your head.
-- James Bonfield, http://www.ioccc.org/2000/rince.hint
In article <··············@pc150.maths.bris.ac.uk>, Michael Hudson wrote:
> Hrvoje Niksic <·······@arsdigita.com> writes:
>
>> Fred Gilham <······@snapdragon.csl.sri.com> writes:
>>
>> > Turns out that GNUS now takes
>
> "gnus"
>
>> > *something*
>> >
>> > and turns it into
>> >
>> > something
>> >
>> > where the latter "something" is in bold face.
>>
>> I think I prefer what slrn does, which is boldface the "emphasized"
>> text, but keep the emphasis characters around. That way false
>> positives will not affect the readability of the posted code.
>
> I think gnus can do that too (on the grounds that gnus can do
> more-or-less anything, plus a vague memory). Don't remember how,
> though.
If anyone knows, please say how. I use gnus at home, and I think
I had to hack up some very ugly Elisp code to achieve that.
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
Nils Goesche <······@cartan.de> writes:
> In article <··············@pc150.maths.bris.ac.uk>, Michael Hudson wrote:
> > Hrvoje Niksic <·······@arsdigita.com> writes:
> >
> >> I think I prefer what slrn does, which is boldface the "emphasized"
> >> text, but keep the emphasis characters around. That way false
> >> positives will not affect the readability of the posted code.
> >
> > I think gnus can do that too (on the grounds that gnus can do
> > more-or-less anything, plus a vague memory). Don't remember how,
> > though.
>
> If anyone knows, please say how. I use gnus at home, and I think
> I had to hack up some very ugly Elisp code to achieve that.
C-h v gnus-emphasis-alist, click customize, find the entry that has
face "gnus-emphasis-bold", change the "Emphasize group:" entry to "2"
(i.e. the same as the "Match group:" entry). I guess you could repeat
this for all of them if you felt like it.
I realise this is off-topic, but my email has broken, so I /can't/
take this to private email just now...
Cheers,
M.
--
It could be argued that since Suitespot is infinitely terrible,
that anything else, by very definition of being anything else,
is infinitely superior. -- ".", alt.sysadmin.recovery
From: Christophe Rhodes
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <sqvgaqs54q.fsf@cam.ac.uk>
Nils Goesche <······@cartan.de> writes:
> In article <··············@pc150.maths.bris.ac.uk>, Michael Hudson wrote:
> > I think gnus can do that too (on the grounds that gnus can do
> > more-or-less anything, plus a vague memory). Don't remember how,
> > though.
>
> If anyone knows, please say how. I use gnus at home, and I think
> I had to hack up some very ugly Elisp code to achieve that.
The variable gnus-emphasis-alist is customizeable. You can either go
through the customize, displaying the same group as you're matching
(changing 3s to 2s) engine, or (posted here because I think it's
funny... :-)
(setq gnus-emphasis-alist
(quote (("\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)" 2 2 gnus-emphasis-underline)
("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline)
("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-italic)
("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(\\*\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)\\*\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-bold)
("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-italic)
("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold)
("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-bold-italic)
("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold-italic))))
--
Jesus College, Cambridge, CB5 8BL +44 1223 510 299
http://www-jcsu.jesus.cam.ac.uk/~csr21/ (defun pling-dollar
(str schar arg) (first (last +))) (make-dispatch-macro-character #\! t)
(set-dispatch-macro-character #\! #\$ #'pling-dollar)
In an attempt to throw the authorities off his trail, Christophe Rhodes <·····@cam.ac.uk> transmitted:
> Nils Goesche <······@cartan.de> writes:
>
>> In article <··············@pc150.maths.bris.ac.uk>, Michael Hudson wrote:
>> > I think gnus can do that too (on the grounds that gnus can do
>> > more-or-less anything, plus a vague memory). Don't remember how,
>> > though.
>>
>> If anyone knows, please say how. I use gnus at home, and I think
>> I had to hack up some very ugly Elisp code to achieve that.
>
> The variable gnus-emphasis-alist is customizeable. You can either go
> through the customize, displaying the same group as you're matching
> (changing 3s to 2s) engine, or (posted here because I think it's
> funny... :-)
>
> (setq gnus-emphasis-alist
> (quote (("\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)" 2 2 gnus-emphasis-underline)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-italic)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(\\*\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)\\*\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-bold)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-italic)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-bold-italic)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold-italic))))
That's exactly the horrible sort of thing that makes it easy to
believe that regular expressions are "of the devil."
It's the sort of thing where Python has popularized a somewhat
different approach:
# 1997/07/16-05:17:50|CTEMER| 13.19
digit = '[0-9]'
date = '\(' + digit + digit + digit + digit + '/' + digit + digit + '/'
date = date + digit + digit + '\)'
hhmmss = '-' + digit + digit + ':' + digit + digit + ':' + digit + digit
datetime = date + hhmmss
stock = '\([A-Z0-9]+\)'
price = ' *\([0-9]+\)\.\([0-9]+\)'
priceexpr = string.joinfields ((datetime, stock, price), "|")
priceprog = regex.compile(priceexpr)
Remember that there is Precisely Nothing preventing you from creating
some wrapper functions to make the building of those regex strings
into a vastly more "reader-friendly" process.
Wouldn't it be a whopping lot easier to puzzle through something
looking like:
(setf regexp
(append-strings
(r:group (r:or *whitespace* *start*))
(r:multiple
(r:group "_" (r:group (r:or *word* (r:notchars #\_)))
"_"))
(r:group
(r:or *whitespace*
(r:chars #\? #\! #\. #\, #\;)))))
than to puzzle through:
"\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)"
--
(reverse (concatenate 'string ··········@" "enworbbc"))
http://www.cbbrowne.com/info/rdbms.html
"But life wasn't yes-no, on-off. Life was shades of gray, and
rainbows not in the order of the spectrum."
-- L. E. Modesitt, Jr., _Adiamante_
On Wed, 17 Apr 2002 13:11:05 -0400,
Christopher Browne <········@acm.org> wrote:
>
> Wouldn't it be a whopping lot easier to puzzle through something
> looking like:
> (setf regexp
> (append-strings
> (r:group (r:or *whitespace* *start*))
> (r:multiple
> (r:group "_" (r:group (r:or *word* (r:notchars #\_)))
> "_"))
> (r:group
> (r:or *whitespace*
> (r:chars #\? #\! #\. #\, #\;)))))
>
> than to puzzle through:
> "\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)"
What are the advantages of using *whitespace*, *start*, *word*
instead of r:*whitespace*, r:*start*, r:*word* or even
(r:whitespace), (r:start) and (r:word), where the functions
would be defined to return constant strings?
s.
From: Friedrich Dominicus
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <87wuv54k75.fsf@fbigm.here>
Christopher Browne <········@acm.org> writes:
> Wouldn't it be a whopping lot easier to puzzle through something
> looking like:
> (setf regexp
> (append-strings
> (r:group (r:or *whitespace* *start*))
> (r:multiple
> (r:group "_" (r:group (r:or *word* (r:notchars #\_)))
> "_"))
> (r:group
> (r:or *whitespace*
> (r:chars #\? #\! #\. #\, #\;)))))
>
> than to puzzle through:
>
>"\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)"
Check out Olin Shivers SCSH and you'll find something quite simular.
I even have some Common Lisp code around which uses Olins
suggestions.
Regards
Friedrich
From: Brian P Templeton
Subject: Re: Ancient Times (Was: Re: introduction to Lisp...)
Date:
Message-ID: <87662kexac.fsf@tunes.org>
Christopher Browne <········@acm.org> writes:
> In an attempt to throw the authorities off his trail, Christophe Rhodes <·····@cam.ac.uk> transmitted:
>> Nils Goesche <······@cartan.de> writes:
>>
>>> In article <··············@pc150.maths.bris.ac.uk>, Michael Hudson wrote:
>>> > I think gnus can do that too (on the grounds that gnus can do
>>> > more-or-less anything, plus a vague memory). Don't remember how,
>>> > though.
>>>
>>> If anyone knows, please say how. I use gnus at home, and I think
>>> I had to hack up some very ugly Elisp code to achieve that.
>>
>> The variable gnus-emphasis-alist is customizeable. You can either go
>> through the customize, displaying the same group as you're matching
>> (changing 3s to 2s) engine, or (posted here because I think it's
>> funny... :-)
>>
>> (setq gnus-emphasis-alist
>> (quote (("\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)" 2 2 gnus-emphasis-underline)
>> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline)
>> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-italic)
>> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(\\*\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)\\*\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-bold)
>> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-italic)
>> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold)
>> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-bold-italic)
>> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold-italic))))
>
> That's exactly the horrible sort of thing that makes it easy to
> believe that regular expressions are "of the devil."
>
> It's the sort of thing where Python has popularized a somewhat
> different approach:
>
> # 1997/07/16-05:17:50|CTEMER| 13.19
>
> digit = '[0-9]'
> date = '\(' + digit + digit + digit + digit + '/' + digit + digit + '/'
> date = date + digit + digit + '\)'
> hhmmss = '-' + digit + digit + ':' + digit + digit + ':' + digit + digit
> datetime = date + hhmmss
> stock = '\([A-Z0-9]+\)'
> price = ' *\([0-9]+\)\.\([0-9]+\)'
> priceexpr = string.joinfields ((datetime, stock, price), "|")
> priceprog = regex.compile(priceexpr)
>
> Remember that there is Precisely Nothing preventing you from creating
> some wrapper functions to make the building of those regex strings
> into a vastly more "reader-friendly" process.
>
> Wouldn't it be a whopping lot easier to puzzle through something
> looking like:
> (setf regexp
> (append-strings
> (r:group (r:or *whitespace* *start*))
> (r:multiple
> (r:group "_" (r:group (r:or *word* (r:notchars #\_)))
> "_"))
> (r:group
> (r:or *whitespace*
> (r:chars #\? #\! #\. #\, #\;)))))
>
There are the SREGEX (sregex.el) and RX (rx.el) Elisp libraries (both
included with GNU Emacs, and probably with XEmacs).
(setf regexp
(sregexq
(group (or (syntax ?-) bol))
(1+
(group "_" (group (or wordchar (not-char "_")))
"_"))
(group
(or (syntax ?-)
(char "?!.,;")))))
You could also use backquote and the `sregex' function to, for
example, use *whitespace* instead of (syntax ?-).
> than to puzzle through:
> "\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)"
> --
> (reverse (concatenate 'string ··········@" "enworbbc"))
> http://www.cbbrowne.com/info/rdbms.html
> "But life wasn't yes-no, on-off. Life was shades of gray, and
> rainbows not in the order of the spectrum."
> -- L. E. Modesitt, Jr., _Adiamante_
hth,
--
BPT <···@tunes.org> /"\ ASCII Ribbon Campaign
backronym for Linux: \ / No HTML or RTF in mail
Linux Is Not Unix X No MS-Word in mail
Meme plague ;) ---------> / \ Respect Open Standards
In article <··············@cam.ac.uk>, Christophe Rhodes wrote:
> Nils Goesche <······@cartan.de> writes:
>
>> In article <··············@pc150.maths.bris.ac.uk>, Michael Hudson wrote:
>> > I think gnus can do that too (on the grounds that gnus can do
>> > more-or-less anything, plus a vague memory). Don't remember how,
>> > though.
>>
>> If anyone knows, please say how. I use gnus at home, and I think
>> I had to hack up some very ugly Elisp code to achieve that.
>
> The variable gnus-emphasis-alist is customizeable. You can either go
> through the customize, displaying the same group as you're matching
> (changing 3s to 2s) engine, or (posted here because I think it's
> funny... :-)
>
> (setq gnus-emphasis-alist
> (quote (("\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)" 2 2 gnus-emphasis-underline)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline)
[snip]
Thanks alot, I'll try it out at home. I think what I did at home was
to walk through the default value of gnus-emphasis-alist and modify
it somehow, in some hook... IIRC, those numbers had to be made equal
or something.
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
Christophe Rhodes <·····@cam.ac.uk> writes:
> The variable gnus-emphasis-alist is customizeable. You can either go
> through the customize, displaying the same group as you're matching
> (changing 3s to 2s) engine, or (posted here because I think it's
> funny... :-)
>
> (setq gnus-emphasis-alist
> (quote (("\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)" 2 2 gnus-emphasis-underline)
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline)
[...]
> ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold-italic))))
God. A perfect example of why I hate doing regex stuff in elisp.
Imagine, for example, if Emacs did the Perl thing and the regex operators were
not escaped by default. We would instead have:
(setq gnus-emphasis-alist
(quote (("(\\s-|^)(_((\\w|_[^_])+)_)(\\s-|[?!.,;])" 2 2 gnus-emphasis-underline)
("(\\s-|^|[-\"]|\\s()(_(\\w+(\\s-+\\w+)*[.,]?)_)(\\s-|[-,;:\"]\\s-|[?!.]+\\s-|\\s))" 2 2 gnus-emphasis-underline)
[...]
("(\\s-|^|[-\"]|\\s()(_*/(\\w+(\\s-+\\w+)*[.,]?)/*_)(\\s-|[-,;:\"]\\s-|[?!.]+\\s-|\\s))" 2 2 gnus-emphasis-underline-bold-italic))))
Which is somewhat better. Considering that regular expressions play a big part
in typical elisp programs, special regex quotes, again a la Perl, would also
help:
(setq gnus-emphasis-alist
(quote ((/(\s-|^)(_((\w|_[^_])+)_)(\s-|[?!.,;])/ 2 2 gnus-emphasis-underline)
(/(\s-|^|[-\"]|\s()(_(\w+(\s-+\w+)*[.,]?)_)(\s-|[-,;:\"]\s-|[?!.]+\s-|\s))/ 2 2 gnus-emphasis-underline)
[...]
(/(\s-|^|[-\"]|\s()(_*/(\w+(\s-+\w+)*[.,]?)/*_)(\s-|[-,;:\"]\s-|[?!.]+\s-|\s))/ 2 2 gnus-emphasis-underline-bold-italic))))
Now it is almost readable.
--
Cheers, The Rhythm is around me,
The Rhythm has control.
Ray Blaak The Rhythm is inside me,
·····@telus.net The Rhythm has my soul.
From: Thomas Bushnell, BSG
Subject: Re: OT: Emacs regex control chars (was Re: Ancient Times)
Date:
Message-ID: <87ofgii7t6.fsf@becket.becket.net>
Ray Blaak <·····@telus.net> writes:
> God. A perfect example of why I hate doing regex stuff in elisp.
John had a problem. "I think I can use regexes to solve this
problem," John said.
John now has two problems.
From: René Kyllingstad
Subject: Re: OT: Emacs regex control chars (was Re: Ancient Times)
Date:
Message-ID: <7kn5xmw9.fsf@stud.ntnu.no>
Ray Blaak <·····@telus.net> writes:
> Christophe Rhodes <·····@cam.ac.uk> writes:
> > The variable gnus-emphasis-alist is customizeable. You can either go
> > through the customize, displaying the same group as you're matching
> > (changing 3s to 2s) engine, or (posted here because I think it's
> > funny... :-)
> >
> > (setq gnus-emphasis-alist
> > (quote (("\\(\\s-\\|^\\)\\(_\\(\\(\\w\\|_[^_]\\)+\\)_\\)\\(\\s-\\|[?!.,;]\\)" 2 2 gnus-emphasis-underline)
> > ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline)
> [...]
> > ("\\(\\s-\\|^\\|[-\"]\\|\\s(\\)\\(_\\*/\\(\\w+\\(\\s-+\\w+\\)*[.,]?\\)/\\*_\\)\\(\\s-\\|[-,;:\"]\\s-\\|[?!.]+\\s-\\|\\s)\\)" 2 2 gnus-emphasis-underline-bold-italic))))
>
> God. A perfect example of why I hate doing regex stuff in elisp.
>
> Imagine, for example, if Emacs did the Perl thing and the regex operators were
> not escaped by default. We would instead have:
>
> (setq gnus-emphasis-alist
> (quote (("(\\s-|^)(_((\\w|_[^_])+)_)(\\s-|[?!.,;])" 2 2 gnus-emphasis-underline)
> ("(\\s-|^|[-\"]|\\s()(_(\\w+(\\s-+\\w+)*[.,]?)_)(\\s-|[-,;:\"]\\s-|[?!.]+\\s-|\\s))" 2 2 gnus-emphasis-underline)
> [...]
> ("(\\s-|^|[-\"]|\\s()(_*/(\\w+(\\s-+\\w+)*[.,]?)/*_)(\\s-|[-,;:\"]\\s-|[?!.]+\\s-|\\s))" 2 2 gnus-emphasis-underline-bold-italic))))
>
> Which is somewhat better. Considering that regular expressions play a big part
> in typical elisp programs, special regex quotes, again a la Perl, would also
> help:
>
> (setq gnus-emphasis-alist
> (quote ((/(\s-|^)(_((\w|_[^_])+)_)(\s-|[?!.,;])/ 2 2 gnus-emphasis-underline)
> (/(\s-|^|[-\"]|\s()(_(\w+(\s-+\w+)*[.,]?)_)(\s-|[-,;:\"]\s-|[?!.]+\s-|\s))/ 2 2 gnus-emphasis-underline)
> [...]
> (/(\s-|^|[-\"]|\s()(_*/(\w+(\s-+\w+)*[.,]?)/*_)(\s-|[-,;:\"]\s-|[?!.]+\s-|\s))/ 2 2 gnus-emphasis-underline-bold-italic))))
>
> Now it is almost readable.
Stephen J. Turnbull wrote this once in comp.emacs:
I've an idea for a cute little hack for
perl-like regexps (ie, get rid of all them dang \\\\\\s, and change
the syntax of () so they're operators and \(\) are literals, etc).
But you'd be limited to already implemented Emacs regexp operators.
The basic idea is to define a new charset 'perl-ascii. It looks just
like ASCII in the buffer, but Mule knows the difference. Then some
trivial twiddles, either using normal text operations or with a CCL
coding system and you can translate to Emacs regexps in "real" ASCII.
You then advise all the regexp functions to check the regexp for
perl-ascii characters and if found automagically translate.
"untested but obviously correct
Sounds like a good start,
-- Ren�
Ray Blaak <·····@telus.net> writes:
>
> God. A perfect example of why I hate doing regex stuff in elisp.
>
Indeed. Take a look at sregex, which is now distributed with
emacs. Too bad people don't use it more to construct readable
regexes. I can't read the \\\\\|\\\\\ soup either.
Sherif Elbanhawy wrote:
>
> Ok guys,
>
> Why is this not working??
>
> (defun print_list(L)
> (cond
> ((null L) nil)
> ((atom L) (list L))
> (t (append (print_list (car L)) (print_list (cdr L)))
> (stable-sort (L) #'char-lessp))
What's with the (L) as the first arg to stable-sort? Does that compile
for you?
Anyway, fix that and you are left with a common mistake: append makes a
new list which you do not capture anywhere, it just drifts off into a
GC. then you sort good old L, which is unchanged and hence still has
depth, ie, members which are not chars. char-lessp don't play dat.
throw in (setf L ....) around that append and i think you'll be ok.
--
kenny tilton
clinisys, inc
---------------------------------------------------------------
"Harvey has overcome not only time and space but any objections."
Elwood P. Dowd
On Sun, 14 Apr 2002 14:58:45 -0400,
Sherif Elbanhawy <················@hotmail.com> wrote:
>
> i wanted to construct a function that will sort this list:
>
> (b (c (d (e f)) ) g h k)
>
> i was able to write the function to sort a list like this but that has
> integers and not characters.
>
> (defun print_list(L)
> (cond
> ((NULL L) nil)
> ((atom L) (list L))
> (t (append (print_list (car list1)) (print_list (cdr list1)) ) )
> ))
... which is an "expensive" way of reinventing a builtin function called
"flatten".
>
> I was able to get all the values of the list in one list (b c d e f g h k)
>
> then I wanna pass this list to char-code to have all the values changed to
> their ASCII code.
to satisfy my personal curiosity: which programming language(s) do you
already know?
>
> I used this function that I wrote
> (sort (mapcar #'char-code '(#\t #\y)) #'>)
you might want to take a look at other sorting functions, for
example those for strings ...
>
> but the problem is I wanna feed the characters in the list to char-code and
> not characters that I hardcoded (ex. (#\t #\y in the above example)
hmmm ... if you want to sort the characters represented by the
SYMBOL NAMES (hint hint;), why did you hardcode the symbols and
not the characters in the first place? Where do those symbols come
from?
>
> Hope I am clear this time:)
I have the feeling that you need to unlearn some old habits
to be able to write idiomatic lisp programs. You might also
want to read some introductions, referenced e.g. over at
http://www.lisp.org
s.
On 14 Apr 2002 20:10:25 GMT,
Stefan Schmiedl <·@xss.de> wrote:
> On Sun, 14 Apr 2002 14:58:45 -0400,
> Sherif Elbanhawy <················@hotmail.com> wrote:
>
> ... which is an "expensive" way of reinventing a builtin function called
> "flatten".
oops. I just (re-)discovered that flatten is only built in
my personal .lisp-init but not in the standard. sorry for
the confusion.
s.
* ·@xss.de (Stefan Schmiedl)
| ... which is an "expensive" way of reinventing a builtin function called
| "flatten".
There is no "builtin" function called "flatten". Please do not post your
beliefs as though they were facts when you can so easily check them.
| you might want to take a look at other sorting functions, for
| example those for strings ...
Maybe you mean comparison functions rather than sorting functions?
| I have the feeling that you need to unlearn some old habits to be able to
| write idiomatic lisp programs.
Maybe you should delay your advice for a while.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
On 14 Apr 2002 22:13:11 +0200,
Nils Goesche <···@cartan.de> wrote:
>
> FLATTEN is common, but not builtin, I think.
you're right. I think it appeared as a permanent part of
my lisp toolbox after a brief encounter with Mathematica
some ten years ago ... and I totally forgot about it.
s.
·@xss.de (Stefan Schmiedl) writes:
> ... which is an "expensive" way of reinventing a builtin function
> called "flatten".
builtin?
--
Dr. Edmund Weitz
Hamburg
Germany
The Common Lisp Cookbook
<http://cl-cookbook.sourceforge.net/>
"Sherif Elbanhawy" <················@hotmail.com> writes:
> Thanks for replying to me. and here are the questions in a clear way and
> what I did so far:
>
> i wanted to construct a function that will sort this list:
>
> (b (c (d (e f)) ) g h k)
>
> i was able to write the function to sort a list like this but that has
> integers and not characters.
As you write it, this tree contains symbols, not characters.
> (defun print_list(L)
> (cond
> ((NULL L) nil)
> ((atom L) (list L))
> (t (append (print_list (car list1)) (print_list (cdr list1)) ) )
> ))
Your indentation, err, sucks :-) You should indent like
everybody else, i.e.
(defun flatten (tree)
(cond ((null tree) nil)
((atom tree) (list tree))
(t (append (flatten (car tree))
(flatten (cdr tree))))))
FLATTEN is the common name for this kind of function. Call it
whatever you want, but print_list is a bad name for two reasons:
First, it doesn't print anything but returns a list; second, we
usually use hyphens instead of underscores. And consider using
NCONC instead of APPEND.
> I was able to get all the values of the list in one list (b c d e f g h k)
>
> then I wanna pass this list to char-code to have all the values changed to
> their ASCII code.
I don't think there is any guarantee that (char-code #\a) will be
the ASCII code of `a'.
> I used this function that I wrote
> (sort (mapcar #'char-code '(#\t #\y)) #'>)
>
> but the problem is I wanna feed the characters in the list to char-code and
> not characters that I hardcoded (ex. (#\t #\y in the above example)
>
> Hope I am clear this time:)
Not yet, I fear :-) First, what does your list really look like?
If you do
BLARK 12 > (flatten '(b (c (d (e f))) g h k))
(B C D E F G H K)
you have a list of /symbols/, not characters. And it is already
sorted, BTW. Note that the function STRING< works well for
symbols, too. If you really want to work with characters, you
should do something like
BLARK 17 > (flatten '(#\b (#\c (#\d (#\e #\f))) #\g #\h #\k))
(#\b #\c #\d #\e #\f #\g #\h #\k)
And if you want to sort such a thing, you might either use CHAR<
or CHAR-LESSP, or, if you insist on bringing CHAR-CODE into the
game, lookup the :KEY argument for SORT.
Regards,
--
Nils Goesche
Ask not for whom the <CONTROL-G> tolls.
PGP key ID #xC66D6E6F
From: Friedrich Dominicus
Subject: Re: introduction to Lisp...
Date:
Message-ID: <87heme5l1q.fsf@fbigm.here>
"Sherif Elbanhawy" <················@hotmail.com> writes:
> Hey guys,
>
> Is this a lisp technical discussion group or what....I did not even receive
> a comment about my questions....
You got answers do you have read them?
Again what have you tried? Where's you attempt?
Friedrich
·······@syncreticsoft.com (Damond Walker) writes:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
Okay, I'm avoiding doing useful work tonight, so I'll put my story in
this thread, too.
The first Lisp I used was Emacs Lisp, but never in any more of a
sophisticated manner than using my .emacs as a strangely-formatted
config file. I've been programming since I was 11 when my uncle
taught me BASIC, and I've been big on learning new languages ever
since I realized that there was more to the world than BASIC[*].
After a couple friends recommended that I read _The Little Schemer_, I
did. One recommended it as a cute book for me to read, the other as
something I could share with my friends and family to help explain
computer science[**], which is a lot harder than explaining the appeal
of, say, biology or chemistry. I tore though it in a couple days, and
decided to learn Scheme. After going through most of _Structure and
Interpretation of Computer Programs_, I tried doing some of my
programming in Scheme, instead of the C++ and Objective-C I was using
at the time. I found it difficult to get real work done in Scheme, so
I quit it. About 6 months later, when I was explaining my latest hack
to g++ to try to fix problems in the language, a friend recommended I
learn Common Lisp, and told me that it was related to Scheme, but more
of a language for engineers, and less for mathematicians with
chalkboards. I got Paul Graham's _ANSI Common Lisp_ and _On Lisp_
(both on sale), and started learning Lisp. At first I didn't like it
as much as Scheme ... except for macros. Macros solved that yearning
that actually had me hacking at the internals of g++. I worked
through the generally messy feeling I got from the rest of the
language, until I hit a point where I was usefully productive. Once I
knew enough of the language to see how it all fit together, it felt a
lot less messy, and I fell in love. Since that time about 2.5 years
ago, I've been writing 80%[***] or so of my non-work code in CL.
[*] I've heard accusations that BASIC damages the minds of budding
programmers, but for me it was vital to learning Lisp. The BASIC I
wrote was very structured, but not in the sense of Structured
Programming. It rarely used formal control structures (I almost never
used DO...WHILE), and was full of carefully crafted control using
GOTO. I wrote using flow-charts. When I later learned Pascal and C,
I thought the whole Structured Programming thing was very cool, but
absolutely did *not* think there was anything wrong with my old style
per se, just that it needed to be used judiciously (and I still write
that way on occaision because it's fun, and occasionally the best
way). When I learned Scheme and how to do *everything* with
recursion, I thought it was cool, but I did not think there was
anything wrong with my previous Structured Programming ways, just that
they were sometimes the clearest way to express a problem, and
sometimes not. So when I came to Lisp from Scheme, I had the
advantage of not having been a recursion-fanatic. I used it a lot
because it was fun, but I didn't think there was anything dirty about
DO (except the syntax). All thanks to BASIC and flow charts :)
[**] I do think this was a good recommendation, because it streaches
their brains in ways similar to how other parts of CS do mine.
[***] The other 20% are divvied up between Emacs Lisp -- which I
learned somewhere along the way --, C++, C, x86 assembly language,
SPARC assembly language, Smalltalk, and Perl.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
In article <····························@posting.google.com>,
Damond Walker <·······@syncreticsoft.com> wrote:
>I'm always interested in how people "came to something." In this case
>it's Lisp. How about relaying how you "came to Lisp?"
I took it throughout college. Sophmore year, I wanted to learn some new
programming languages, so I signed up to take the one hour introduction
courses into C++ and Lisp. The C++ class had 100 undergraduates, the Lisp
class had 10-20 upper level undergrads and graduate students. You can
imagine which was more challenging. :-)
At any rate, I was hooked, and looked for pretty much every other
opportunity to use the language. I took the symbolic processing class,
which was taught in Lisp, and subsequently took the compilers course. Our
assignment was to write a limited Java compiler in the language of choice.
I was sorely tempted to use Java for the sake of circularity, but ended up
picking Lisp. I wanted to use it in a bigger application than the toys I
had been writing up until then.
All I can say about that is that it was eye-opening. My roommate took
the course with me and struggled with implementing the compiler in C++.
We did a lot of work at the same time (no sharing) and asked each other
questions about various little implemtation details. While he was
struggling with the correct representation of symbols, I was building
parse trees. And so it went for the duration of the semester. It also
introduced me to Lisp I/O and broke me of the habit of making everything
recursive and functional. When I had first heard of the Compilers class, I
had heard of Lisp as one of two preferred choices. Apparantly that didn't
survive a change in professors. After the first phase was turned in,
another student asked a question on language selection. In his reply, the
professor mentioned that _one_ student was _actually_ using Lisp!!! Java
and C++ were the more popular selections.
Since then, working, I've been stuck using C, and lamenting that it's not
Lisp.
-Mike
--
http://www.mschaef.com
I bought a copy of Lisp from Software Toolworks. It ran on my
Heathkit H8, which started as an 8k machine with a 2mhz 8080 but
eventually grew to a 4mhz Z-80 with bank-selected 256k memory. I had
64k when I tried the Software Toolworks Lisp.
I couldn't make heads or tails of it.
I had programmed in assembly and BASIC before that, so I was pretty
`linear' in my thinking....I'd also tried forth but that was another
one I couldn't wrap my mind around.
I also tried logo but I couldn't really get recursion. I could use it
but I was never quite sure of myself.
I kept trying Lisp whenever I could, and I bought Winston & Horn's
LISP, first edition, and would read it from time to time with
virtually complete lack of comprehension. I got xlisp to run on my
Amiga, and my brother in law told me about a major project he did in
xlisp, a decision analysis tool for use in analyzing safety factors in
disposing of nuclear waste. He did it in his spare time and got a
paper out of it at least.
Anyway I eventually went to Stanford to get a masters in Computer
Science, and I took the only programming language course I'd ever
taken, namely Lisp. I read the lambda papers and got really excited.
I also started writing programs in Lisp for some of my coursework.
(I also read Brian Harvey's COMPUTER SCIENCE LOGO STYLE which is when
I finally got recursion. Yes, I think I'm a slow learner....)
After I got my current job, we got a Sparcstation 1 with 16M for home.
I still played with Lisp from time to time. I was interested in
graphics stuff (the logo influence I guess) but Lisp was too slow for
that. I remember trying to run CLIO compiled under AKCL or some such
on the Sparcstation, clicking on a button, hearing the disk start
swapping, and literally 5 minutes later seeing the menu pop up.
However, I kept trying it every so often, and lo and behold, one day I
decided that it was actually fast enough to use. I think this was
about at the time of the Pentium 100 but it may have been sooner.
Eventually during the startup mania I got a job offer at another
company and used it to leverage my boss into letting me get into a
project that was using Lisp. I spent a couple years working on Lisp
stuff until the funding on that project ran out. I gave a
presentation on some of the stuff I did at the LUG in 1999.
Unfortunately I'm now programming in Java, and the ideas they stole
from Lisp and implemented poorly only make the pain worse. :-)
But there's a good chance I'll be working in Lisp again soon.
--
Fred Gilham ······@csl.sri.com
During the sixteenth and seventeenth centuries, when Spanish
sovereignty extended from Italy to most of Latin America, on average
less than three persons a year were executed by the Inquisition, which
was formally constituted in all those places as well as at home.
-- Marvin R. O'Connell, professor emeritus of history at the
University of Notre Dame and priest of the Archdiocese of St. Paul.
This thread reminds of me of something from rec.arts.erotica or
Penthouse Forum. "My first time with Lisp happened late one night in
the lab..."
I got my introduction to Lisp as a student at MIT. I knew Fortran
reasonably well and had a programming job in the Ocean Engineering
deptartment, but I had heard of Lisp before. Copies of SICP were laying
around the frat house; once in I while I'd crack it open, but it
seemed completely alien to my Fortran brain. Maybe the ambience had
something to do with that.
In my senior year I took 6.001 and was blown away. I decided I really
wanted to study computer science instead of ocean engineering. I went
off to grad school at the U of Utah intending to study computer
graphics, but the group building a Common Lisp system was far cooler,
and the rest is history.
In this context, the periodic assertions that "Scheme is not Lisp,"
"Scheme ruins you for Common Lisp," "The Scheme community is hostile
to the Common Lisp community" etc. always seem bizzare to me. In 1986
it was clear that Scheme was the teaching language, Common Lisp was
the language in which you'd write real programs, and most of the
concepts were the same. So many of the Lisp concepts taught in SICP
-- functional abstraction, higher order functions, lexical scoping,
data driven programming, little languges, message passing to name a
few -- were so different from what one encountered in other
programming languages that it would have been silly to make a huge
distinction between Scheme and CL. Of course there were adjustments
to make in moving between the two, but they were pretty minor compared
to learning Scheme in the first place.
Tim
* Tim Moore
| In this context, the periodic assertions that "Scheme is not Lisp,"
| "Scheme ruins you for Common Lisp," "The Scheme community is hostile
| to the Common Lisp community" etc. always seem bizzare to me. In 1986
| it was clear that Scheme was the teaching language, Common Lisp was
| the language in which you'd write real programs, and most of the
| concepts were the same.
But this is only true when you look at Common Lisp from Scheme. If you
look at Scheme from Common Lisp, it is most of the concepts are missing,
if not different. It is actually very important to realize this. What
does rot the brain is that those who actually think that "most of the
concepts are the same" are damaged for life, because they never go beyond
what they have already learned. Essentially, they write Scheme in Common
Lisp for the rest of their lives, just like some people write Pascal in
any language, or Fortran in any language. This is precisely why _not_
exposing a malleable young mind to Scheme is so important if they are
ever going to use Common Lisp for production programming.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
| If you look at Scheme from Common Lisp, it is most of the concepts are
| missing, if not different. [...] What does rot the brain is that those
| who actually think that "most of the concepts are the same" are damaged
| for life, because they never go beyond what they have already learned.
I am not young, my mind is likely not very malleable, and I have read
SICP. Are there any specific Scheme-ish ideas that you would suggest I,
as a rank beginner in CL, should make it a priority to unlearn?
* Arjun Ray <····@nmds.com.invalid>
| I am not young, my mind is likely not very malleable, and I have read
| SICP. Are there any specific Scheme-ish ideas that you would suggest I,
| as a rank beginner in CL, should make it a priority to unlearn?
Primarily that Scheme has done it the right or only way.
Scheme is actually a hard language to learn. It forces you into a
mindset that is very artificial. Common Lisp is much less artificial.
At some point in your learning about some artificial reality, accepting a
it as if it were real sets in. Scheme is actually the only programming
language I have seen this happen with -- it affects people in subtle ways
that reorient their value system and begin to accept what they hear and
not what they see. The same happens to young minds who meet Scientology
or Objectivism or even Communism unprepared for the multiplicity of what
might be true, and they start to confuse the fact that something is true
with everything else being false. Theories that are so attractive that
they become _more_ attractive than reality are probably wrong from the
outset, in some fundamental way. This notion of "purity", for instance,
and its associated "elegance", tend to make reality look "dirty" and
drives people into a weird state of mind. This is hard to detect from
the inside, but very easy to detect from the outside.
If you need a particular example: recursion is not a _generally_ good
idea, you need to understand how and when Scheme really is iterating, and
to find iterative expressions of the same forms they use recursions for..
Calling functions that return functions only to call the return value
right away is _generally_ not a clear and perspicuous coding style --
consider binding it to a variable. An one namespace is simply wrong,
both in conflating function and variable value and in lacking packages.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum wrote:
> * Arjun Ray <····@nmds.com.invalid>
> | I am not young, my mind is likely not very malleable, and I have read
> | SICP. Are there any specific Scheme-ish ideas that you would suggest I,
> | as a rank beginner in CL, should make it a priority to unlearn?
>
> Primarily that Scheme has done it the right or only way.
>
one thing I have not really believed to begin with, not like r5rs claims
that anyways (or at least not that I have seen).
> Scheme is actually a hard language to learn. It forces you into a
> mindset that is very artificial. Common Lisp is much less artificial.
> At some point in your learning about some artificial reality, accepting
> a
> it as if it were real sets in. Scheme is actually the only programming
> language I have seen this happen with -- it affects people in subtle
> ways that reorient their value system and begin to accept what they hear
> and
> not what they see. The same happens to young minds who meet Scientology
> or Objectivism or even Communism unprepared for the multiplicity of what
> might be true, and they start to confuse the fact that something is true
> with everything else being false. Theories that are so attractive that
> they become _more_ attractive than reality are probably wrong from the
> outset, in some fundamental way. This notion of "purity", for instance,
> and its associated "elegance", tend to make reality look "dirty" and
> drives people into a weird state of mind. This is hard to detect from
> the inside, but very easy to detect from the outside.
>
I once felt this way about the relational model, but that broke down...
> If you need a particular example: recursion is not a _generally_ good
> idea, you need to understand how and when Scheme really is iterating,
> and to find iterative expressions of the same forms they use recursions
> for.. Calling functions that return functions only to call the return
> value right away is _generally_ not a clear and perspicuous coding style
my "scheme" system generally has used iteration functions (coded in
assembly), mostly as I have not really bothered with coding tail
recursion...
> consider binding it to a variable. An one namespace is simply wrong,
> both in conflating function and variable value and in lacking packages.
>
I understand the need for packages allready. I am starting to understand
why multiple namespaces are needed (mostly I would just use the functional
namespace to store compiled versions of the functions, and the data to
point to the s-structures).
from my point of view my implementation was: scheme kludged into kernel
programming... so I have much of the same mess (some parts borrowing what I
*do* like from c). the main thing is that I am trying to keep r5rs
conformance as well, though it is not like r5rs does not allow one to make
extensions.
really this here does make it sound more like cl is what I am aiming at, so
I am more definatly thinking of looking into it...
the main thing I am hoping is that it is not a massive implementation task.
hopefully people don't think I am ms-ing the specs, just in my oppinion a
*pure* scheme would be ineffective for system coding.
in any case I know far less about either than I know about os coding, but
even that is stressed as my designs are coming out unusual.
hopefully I don't sound ignorant.
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
In <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
| If you need a particular example:
You've provided three, thanks! :-)
| recursion is not a _generally_ good idea, you need to understand how
| and when Scheme really is iterating, and to find iterative expressions
| of the same forms they use recursions for..
Well, yes, recursion did come across as a big deal in SICP. Iteration
amounting to a special case (thanks to tail call optimization) didn't
impress me, however. It struck me as a "since we *can* do it this way,
we really don't *need* anything else" rejection of potentially useful
idioms directly in the language, especially when, a lot of the time, the
real idiom is using extra accumulator arguments to jigger the recursion
into tail call position. Wow, all that for this? Finger exercises are
great, but at some point one simply wants to play the piano...
| Calling functions that return functions only to call the return value
| right away is _generally_ not a clear and perspicuous coding style --
| consider binding it to a variable.
And using funcall appropriately, or have I misunderstood?
| [And] one namespace is simply wrong, both in conflating function and
| variable value and in lacking packages.
I'm still having trouble grasping whether CL has two namespaces or many.
Function versus variable is pretty clear, but what about special forms,
macros, keywords, filler (syntactic sugar), and the like? In my limited
understanding, one would exploit syntax to differentiate namespaces, so
I guess I'm really asking, how many syntactically distinguishing markers
does CL have and does/should it need more?
Arjun Ray <····@nmds.com.invalid> writes:
...
> | [And] one namespace is simply wrong, both in conflating function and
> | variable value and in lacking packages.
>
> I'm still having trouble grasping whether CL has two namespaces or many.
> Function versus variable is pretty clear, but what about special forms,
> macros, keywords, filler (syntactic sugar), and the like? In my limited
> understanding, one would exploit syntax to differentiate namespaces, so
> I guess I'm really asking, how many syntactically distinguishing markers
> does CL have and does/should it need more?
The way I like to look at things is that CL has a sort of
multidimensional set of namespaces (the metaphor is really an
overkill, but it serves the purpose).
First of all you have the PACKAGE system, which partitions the "set of
symbols" into (semi)overlapping subsets. The set of symbols is the
domain of all the functions (named themselves by symbols) that
retrieve elements in their range, i.e. in a "namespace".
On a totally different dimension, there are 2 main namespaces for
"values" and "functions", plus a select namespace for "special
operators" (like IF, COND, etc. etc.) Then you have a namespace for
"types" which includes a namespace for "classes".
When you write a language extension in CL, you can add a new
dimension. E.g. all the DEFSYSTEM utilities out there introduce the
"systems' namespace" which you can access (more or less) with the
function named "FIND-SYSTEM". This goes further of course.
As per your question, well, it depends. syntax of CL is extremely
simple yet immensely general. CL has very few special operators and a
very consistent use of the so called "keyword" arguments to express
different things. E.g.
(sort (vector '(1 2) '(3 5) '(-3 8) '(33 0)) #'> :key 'first)
or
(find -3 (vector '(1 2) '(3 5) '(-3 8) '(33 0)) :key 'first :from-end t)
Where the keywords :key and :from-end are specified for each
"sequence" operation.
The lack of keywords is one of the things most sorely missing in
Scheme.
So. You do not need anything more in CL. Just use what you have and
if you do not have enough, extend the language, like you cannot do in
many other ones.
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
* Arjun Ray <····@nmds.com.invalid>
| And using funcall appropriately, or have I misunderstood?
Well, funcall or apply, as appropriate.
| I'm still having trouble grasping whether CL has two namespaces or many.
Well, there is a crucial difference between Scheme and Common Lisp here
that I think many people miss. We have talked about symbolic programming
and how it relates to packages in this newsgroup a while, but the obvious
point that "everything" in Common Lisp is named by symbols is somehow
lost on people. When a class is named by a symbol, it may or may not be
a separate "namespace" for classes, but the fact that a symbol may be a
designator for the class so named may be an indicator. In Scheme, they
are still so fascinated by this "first-class" idea that they think they
have to pass the values around instead of names. This makes for a _very_
different mode of thinking.
| Function versus variable is pretty clear, but what about special forms,
| macros, keywords, filler (syntactic sugar), and the like?
Actually, it is operator vs variable -- the first position of a form
names an operator. (The function slot of a symbol may also hold more
than functions.) That an variable may be named the same as a operator
means that you have two namespaces, not just "one valuespace", which I
think is a better name for Scheme and that whole branch of programming
languages starting with Algol which Scheme tried to merge with Lisp.
| In my limited understanding, one would exploit syntax to differentiate
| namespaces, so I guess I'm really asking, how many syntactically
| distinguishing markers does CL have and does/should it need more?
No, syntax is not the issue. The issue is that a symbol names various
forms of things. Whether they are "in" the symbol, like the functional
and the regular values, or are keys for lookups elsewhere is immaterial.
What find-class does is not specified, except to take a symbol as a value
and return the class so named. There is no syntax for block names, throw
tags, go labels, etc, but these are all established and used in special
forms, which I guess _some_ would call "syntax", but it is not really
visually different from other forms. I therefore think it is not very
productive to call them namespaces. It is more like operator-specific
mappings of symbols that name their specific things.
But in general, using symbols to name things is the (Common) Lisp way,
and using the values directly is the Scheme way.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> But in general, using symbols to name things is the (Common) Lisp way,
> and using the values directly is the Scheme way.
It should be noted that it's quite possible to do things the Scheme Way
(on this definition) in Common Lisp. It turns out I've been writing
Scheme code in Common Lisp for years without even realizing that's what I
was doing. For many applications this is not necessarily a bad approach
IMO.
E.
···@jpl.nasa.gov (Erann Gat) writes:
> In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
>
> > But in general, using symbols to name things is the (Common) Lisp way,
> > and using the values directly is the Scheme way.
>
> It should be noted that it's quite possible to do things the Scheme Way
> (on this definition) in Common Lisp. It turns out I've been writing
> Scheme code in Common Lisp for years without even realizing that's what I
> was doing. For many applications this is not necessarily a bad approach
> IMO.
Of course it is not.
It is the other way around that does not work. You cannot write
(make-array (2 2) :initial-contents '((1 0) (0 1)))
in Scheme (lest being bitten badly when you port your code to Scheme
implementation 1 godzillion + 42).
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
In article <···············@octagon.mrl.nyu.edu>, Marco Antoniotti
<·······@cs.nyu.edu> wrote:
> ···@jpl.nasa.gov (Erann Gat) writes:
>
> > In article <················@naggum.net>, Erik Naggum
<····@naggum.net> wrote:
> >
> > > But in general, using symbols to name things is the (Common) Lisp way,
> > > and using the values directly is the Scheme way.
> >
> > It should be noted that it's quite possible to do things the Scheme Way
> > (on this definition) in Common Lisp. It turns out I've been writing
> > Scheme code in Common Lisp for years without even realizing that's what I
> > was doing. For many applications this is not necessarily a bad approach
> > IMO.
>
> Of course it is not.
>
> It is the other way around that does not work.
Right. That's one reason I don't use Scheme even though I'm often writing
Scheme-style code.
Now that I think of it, I've written assembler, Forth, and Scheme code,
all in Common Lisp, and all to good effect. In fact, just about the only
thing I haven't used Lisp for is writing Lisp code. :-)
E.
Arjun Ray <····@nmds.com.invalid> writes:
> I'm still having trouble grasping whether CL has two namespaces or many.
It depends a little on how you count.
At the level of 'pure syntax' there are four:
- variables
- functions
- go tags (established by TAGBODY and transferred to by GO)
- return tags (established by BLOCK and transferred to by RETURN-FROM)
These are the only namespaces that are specially understood by the langauge,
and it is possible to independently bind these without interfering with the
others.
The names of catch tags, class names, and so on are symbol data, not program
data (even though the program data would be symbols, we're talking the
difference between symbols visible at compile time and symbols not always
visible until runtime). Some people might count these as namespaces;
certainly in some languages these have special notational syntax and even
in some cases are not allowed to be variable at runtime.
> Function versus variable is pretty clear, but what about special forms,
> macros, keywords, filler (syntactic sugar), and the like?
As Erik noted, you're confusing naming with semantics. The simple
test of whether there are two namespaces is whether if you bound one,
you'd interfere with another. You can't define a function FOO without
replacing any macro FOO. You can't define a function LAMBDA because
it's reserved (being a special operator). So functions, macros, and
special operators are all in the same space.
> In my limited understanding, one would exploit syntax to
> differentiate namespaces, so I guess I'm really asking, how many
> syntactically distinguishing markers does CL have and does/should it
> need more?
I think it has "enough" to do the set of things it was designed for.
Therefore, I think it does not require more. Do you have a specific
suggestion to make?
- Variables are referenced as atomic forms.
- Functions are invoked as the car of a form,
or referenced through FUNCTION.
- Go tags are invoked through use of GO.
- Return tags are invoked through use of RETURN-FROM.
Kent M Pitman <······@world.std.com> writes:
> As Erik noted, you're confusing naming with semantics. The simple
> test of whether there are two namespaces is whether if you bound one,
> you'd interfere with another. You can't define a function FOO without
> replacing any macro FOO. You can't define a function LAMBDA because
> it's reserved (being a special operator). So functions, macros, and
> special operators are all in the same space.
It would seem that this argument supports the notion that class
definitions have their own namespace, perhaps shared with types.
--
Thomas A. Russ, USC/Information Sciences Institute ···@isi.edu
···@sevak.isi.edu (Thomas A. Russ) writes:
> Kent M Pitman <······@world.std.com> writes:
>
>
> > As Erik noted, you're confusing naming with semantics. The simple
> > test of whether there are two namespaces is whether if you bound one,
> > you'd interfere with another. You can't define a function FOO without
> > replacing any macro FOO. You can't define a function LAMBDA because
> > it's reserved (being a special operator). So functions, macros, and
> > special operators are all in the same space.
>
> It would seem that this argument supports the notion that class
> definitions have their own namespace, perhaps shared with types.
Yes, certainly, although you could also claim that neither was a
namespace because there is no syntax-level operation that treats
types or classes. Things like TYPEP and DEFMETHOD and :ELEMENT-TYPE
to OPEN and MAKE-ARRAY arguably operate on objects, not on primitive
language glue. Further, although you can perhaps say that type
declarations are glue, they don't have any semantic effect that is
testable by a conforming program. At least as far as I can remember.
Anyone who wants to make a counter-argument is welcome to.
It is for reasons like this, incidentally, that I conspicuously steered
clear of enumerating the namespaces ANSI CL. It wasn't necessary, and
it seemed a source of gratuitous controversy at the specification level.
The language does what it does, and we're merely discussing the terminology
for most coherently describing that effect.
One could "clean up" some of these language aspects, as ISLISP did,
for example. But you get a language that is probably both "more
compilable" and "less expressive"... depending on what you mean by those
terms, I suppose (since CL does fully compile and ISLISP is fully Turing
powerful).
In <···············@shell01.TheWorld.com>, Kent M Pitman
<······@world.std.com> wrote:
| Arjun Ray <····@nmds.com.invalid> writes:
| These [four] are the only namespaces that are specially understood by
| the langauge, and it is possible to independently bind these without
| interfering with the others.
This is what I understand principally by "namespace", and the sense in
which I found Scheme to be worrisome - if "meanings", i.e. referents, of
names can be clobbered, some syntactic means to distinguish them would
have been useful, at least to me, as opposed to an imposed discipline of
watching out for clobbering. (That is, instead of always having to
invent distinct names lest bad things happen, the ability to use syntax
to indicate intended meaning seems more conducive to productivity.)
|> Function versus variable is pretty clear, but what about special forms,
|> macros, keywords, filler (syntactic sugar), and the like?
|
| As Erik noted, you're confusing naming with semantics.
As a beginner in CL but no stranger to languages, I find comprehension
impeded by prior exposure to apparently similar terminology which has
been used elsewhere! I was trying to say what I meant, but failed:-(
My concern was with how many different kinds of things can be bound to a
name without interference, where the grammatical context would suffice
to disambiguate the correct binding. Perl, for instance, has typeglobs,
which is what all names (except "lexicals") immediately refer to; the
typeglob in turn is a tuple of pointers to different types of values
("scalar", array, hash table, function, etc); and the correct value
referent is determined by syntax. So an expression like
$foo -> foo ( @foo{ @foo } )
has determinate meaning in that an object, a method, a hash table and an
array can all concurrently be named 'foo' at the point of evaluation.
| You can't define a function FOO without replacing any macro FOO. You
| can't define a function LAMBDA because it's reserved (being a special
| operator). So functions, macros, and special operators are all in the
| same space.
Since their incidence is in the car of a form - the first or operator
position - I can see why this is so. My understanding is that operands
are variables unless indicated otherwise. If so, I was trying to refine
my understanding of the "otherwises".
My thanks to Erik, Marco and you. You've been very helpful. Back to
the books and the Hyperspec for me:-)
Arjun Ray <····@nmds.com.invalid> writes:
> | You can't define a function FOO without replacing any macro FOO. You
> | can't define a function LAMBDA because it's reserved (being a special
> | operator). So functions, macros, and special operators are all in the
> | same space.
>
> Since their incidence is in the car of a form - the first or operator
> position - I can see why this is so. My understanding is that operands
> are variables unless indicated otherwise. If so, I was trying to refine
> my understanding of the "otherwises".
Yes, "evaluation" normally occurs in the variable namespace. Go tags
and return tags are irrelevant here. #' is the way you "promote"
something in the function namespace to the place where normal
evaluation occurs, and in a sense, funcall is a vague kind of inverse,
taking a variable and causing it to be invoked as if it had occurred
in the functional position... So the rule is not terribly complicated.
It perhaps becomes more complicated because the Scheme community has a
completely different rule and we've added some compatibility syntax for
mindshare with them, but the rule actually makes our rules more complicated.
To think about it right in lisp, think of (lambda (x) x) as a "name" of
a function. So (f 1) has the function name F in the car of the form, and
((lambda (x) x) 1) has the function name (lambda (x) x) in the car of the
form; that is, lambda is an "anonymous" name, just like in English when
you can say "that man over there" in place of "Fred" if you either don't
know Fred's name or don't choose to name him, but prefer to work by
describing the effect you want. Likewise, you can say #'f or
#'(lambda (x) x) and it's pretty consistent. But we added the ability
to say (lambda (x) x) for compatibility with Scheme and that might be
confusing to a non-schemer. LAMBDA is just a macro that translates
(lambda (x) x) into #'(lambda (x) x), which is the primitive notation.
[I'm assuming you understand the #'foo == (function foo) relation.]
> My thanks to Erik, Marco and you. You've been very helpful. Back to
> the books and the Hyperspec for me:-)
Ok. Have fun / good luck.
Kent M Pitman <······@world.std.com> writes:
> It perhaps becomes more complicated because the Scheme community has a
> completely different rule and we've added some compatibility syntax for
> mindshare with them, but the rule actually makes our rules more complicated.
>
> To think about it right in lisp, think of (lambda (x) x) as a "name" of
> a function. So (f 1) has the function name F in the car of the form, and
> ((lambda (x) x) 1) has the function name (lambda (x) x) in the car of the
> form; that is, lambda is an "anonymous" name, just like in English when
> you can say "that man over there" in place of "Fred" if you either don't
> know Fred's name or don't choose to name him, but prefer to work by
> describing the effect you want. Likewise, you can say #'f or
> #'(lambda (x) x) and it's pretty consistent. But we added the ability
> to say (lambda (x) x) for compatibility with Scheme
By this, do you mean having (lambda (x) x) evaluate to a function
[thereby breaking the consistency with f, where simply evaluating f
does not (necessarily) give you a function, but whatever is bound to f
in the value namespace] ?
Jacek Generowicz <················@cern.ch> writes:
> Kent M Pitman <······@world.std.com> writes:
>
> > It perhaps becomes more complicated because the Scheme community
> > has a completely different rule and we've added some compatibility
> > syntax for mindshare with them, but the rule actually makes our
> > rules more complicated.
> >
> > To think about it right in lisp, think of (lambda (x) x) as a
> > "name" of a function. So (f 1) has the function name F in the car
> > of the form, and ((lambda (x) x) 1) has the function name
> > (lambda (x) x) in the car of the form; that is, lambda is an
> > "anonymous" name, just like in English when you can say "that man
> > over there" in place of "Fred" if you either don't know Fred's
> > name or don't choose to name him, but prefer to work by describing
> > the effect you want. Likewise, you can say #'f or
> > #'(lambda (x) x) and it's pretty consistent. But we added the
> > ability to say (lambda (x) x) for compatibility with Scheme
>
> By this, do you mean having (lambda (x) x) evaluate to a function
> [thereby breaking the consistency with f, where simply evaluating f
> does not (necessarily) give you a function, but whatever is bound to
> f in the value namespace] ?
It's not a question of what it evaluates to. #'f can only evaluate to
a function because the function namespace is thus restricted, but f
can also evaluate to a function.
I mean (lambda (x) x) evaluating _as_ a function, that is, going
through a process some call feval (pronounced "eff eval") is what's at
issue, that is, what the processing of a name or lambda expression in
the functional namespace--if it's a name, grabbing its function
binding, and if it's a lambda creating its closure, ... at least
conceptually ... In the case of lambda combinations like ((lambda (x)
x) 'a) this is probably done specially by most implementations,
without obtaining a function object, but that's an
implementation/efficiency issue, not really a definitional issue.
In CL, lambda expressions were originally things that were fevaled,
not evaled. It is arguably confusing and overcomplex that they are
now both. (I daresay CL programmers are able to handle this
complexity. I'm merely observing that it's there.) But it's only an
issue while macro forms are present, and lots of things in macro land
can be potentially syntactically confusing. Once macro expansion is
done, things are simple again and there is only #'(lambda (x) x) as a
form; no more apparent references to unguarded lambdas going into the
eval half of things.
Arjun Ray <····@nmds.com.invalid> writes:
...
> My concern was with how many different kinds of things can be bound to a
> name without interference, where the grammatical context would suffice
> to disambiguate the correct binding. Perl, for instance, has typeglobs,
> which is what all names (except "lexicals") immediately refer to; the
> typeglob in turn is a tuple of pointers to different types of values
> ("scalar", array, hash table, function, etc); and the correct value
> referent is determined by syntax. So an expression like
>
> $foo -> foo ( @foo{ @foo } )
>
> has determinate meaning in that an object, a method, a hash table and an
> array can all concurrently be named 'foo' at the point of
> evaluation.
Now I understand. You show very grave signs of Perlite. :)
In theory (and practice), in CL, you can write womething like
(funcall (find-method-named 'foo)
(gethash (find-hash-table-named 'foo)
(find-string-named 'foo)))
(lots of details missing).
Note that FUNCALL and GETSHASH are already part of the language.
FIND-METHOD is as well. To support FIND-HASH-TABLE-NAMED and
FIND-STRING-NAMED you need to add a few things. You can do do that in
Scheme as well (of course, you are missing GETHASH, but that is just
one of the problems with Scheme).
So, in general, in CL you can set up as many "namespaces" as you want,
and then use the language and the macro systems (i.e. macro characters
included) to access the underlying namespace.
E.g. you could have the macro characher @ (Perlite is getting to me)
set up some checks, like
@foo
==>
(let ((v foo))
(check-type v 'hash-table) v)
But then, why would you like to do that, just to separate things that
are already checked for?
> My thanks to Erik, Marco and you. You've been very helpful. Back to
> the books and the Hyperspec for me:-)
You are welcome.
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
From: Christopher C. Stacy
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <u8z7wy63j.fsf@theworld.com>
>>>>> On Tue, 09 Apr 2002 18:34:12 GMT, Erik Naggum ("Erik") writes:
Erik> This is precisely why _not_ exposing a malleable young mind
Erik> to Scheme is so important if they are ever going to use
Erik> Common Lisp for production programming.
Exposing the student to a variety of things is what is important,
and I think Scheme is a good addition to the package.
At MIT, the standard set of courses included both Scheme
and CLU (a strong-typing module oriented language) for starters.
But that's just the introductory material.
I'm not sure which course of study there generally includes
learning Lisp other than the AI course, and there it's incidental.
Maybe there's some problem if all the students walk away from the
courses thinking that all Lisps are like Scheme, or a warped idea
of what constitutes a "Lisp". On the other hand, as we have seen
in this discussion many times, people who are experts in Scheme
and Lisp and more, are unable to define "Lisp".
I was shocked in recent years when talking with some smart kids
who had recently graduated telling me how much they hated "Lisp"
(by which they meant Scheme).
The fact of the matter is that most kids -- even MIT hot shots --
simply want to learn enough to be able to make money programming
in the most popular language of the day. Unless they are the
very few who are on the post-graduate academic track, they are
not interested in learning any more than that. So, what they
want to know for the last 15 years or so is only: how to become
a C++ or JAVA programmer. They don't want to learn very much
about computer sofware beyond that, and they certainly don't
want to learn any languages that are not plastered all over
the Employment pages of the Boston Globe. Scheme is learned
grudgingly as an abstract mathematical treatment of largely
arcane ideas, to expand their thinking, but not because one
would ever actually develop software in that language.
Common Lisp is a marginal language of no interest at all.
Of course, that sucks, but 90% of everything in the world is shit,
so what do you expect? Shit sucking, that's what!
You got it.
"Tim Moore" <······@sea-tmoore-l.dotcast.com> wrote in message
·················@216.39.145.192...
> [..] it would have been silly to make a huge distinction between Scheme
and CL.
> Of course there were adjustments to make in moving between the two,
> but they were pretty minor compared to learning Scheme in the first
place.
There is a practical difference that is important. Overstated:
- In Scheme, if you want something, you think about how it should be, and
then build it. It will be different from what others have.
- In CL, you look around, find something that is already there, and use it.
Then, you may be dissatisfied, roll your own version, and get to weigh
whether it is more important to stick to the standard or to have the
"right", idiosyncratic, implementation.
Along a slightly different line, on the axis that roughly runs from FORTRAN
to ML, for various reasons the optimal CL solution tends to be somewhat
more in the FORTRAN direction and the optimal Scheme solution somewhat more
in the ML direction. (This is NOT to say that CL is at all close to
FORTRAN, of course!) Some reasons, I think, are:
- a different view on recursion, which makes that iteration and assignment
are more important in CL;
- a different view of namespaces, which makes that in Scheme techniques for
dealing with values in general are more easily applied to functional values
as well;
- a different view of special cases, which makes that CL solutions tend to
be more efficient, and Scheme solutions more general. As a side effect:
- Scheme compilers seem to be more intelligent in optimising general case
code;
- CL tends to have constructions that combine sets of special cases
behind a common front.
--
Biep
"Biep @ http://www.biep.org/" <·········@my-web-site.com> writes:
> "Tim Moore" <······@sea-tmoore-l.dotcast.com> wrote in message
> ·················@216.39.145.192...
> > [..] it would have been silly to make a huge distinction between Scheme
> and CL.
> > Of course there were adjustments to make in moving between the two,
> > but they were pretty minor compared to learning Scheme in the first
> place.
>
> There is a practical difference that is important. Overstated:
> - In Scheme, if you want something, you think about how it should be, and
> then build it. It will be different from what others have.
> - In CL, you look around, find something that is already there, and use it.
> Then, you may be dissatisfied, roll your own version, and get to weigh
> whether it is more important to stick to the standard or to have the
> "right", idiosyncratic, implementation.
I'd say that the description of what you do in Scheme is an
understatement. You have to re-build *a lot* of missing functionality
to get to the simple bedrock that come with a CL implementation. In
the process you may have to switch among one of the godzillion
incompatible implementation of Scheme.
>
> Along a slightly different line, on the axis that roughly runs from FORTRAN
> to ML,
I believe that the discussion why *ML main feature (type inference) is
nice, but not all that helpful while writing serious CL program has
been already dealt with in here.
> for various reasons the optimal CL solution tends to be somewhat
> more in the FORTRAN direction and the optimal Scheme solution somewhat more
> in the ML direction. (This is NOT to say that CL is at all close to
> FORTRAN, of course!) Some reasons, I think, are:
> - a different view on recursion, which makes that iteration and assignment
> are more important in CL;
Are you kidding?
> - a different view of namespaces, which makes that in Scheme techniques for
> dealing with values in general are more easily applied to functional values
> as well;
Scheme has no namespaces to speak of. And you can program in CL as
you do in Scheme.
> - a different view of special cases, which makes that CL solutions tend to
> be more efficient, and Scheme solutions more general. As a side effect:
> - Scheme compilers seem to be more intelligent in optimising
> general case code;
CMUCL (and SBCL) has a very sophisticated compiler that does type-inference for
the full CL ANSI spec (and then some). The commercial implementations
are as sophisticated.
The best Scheme compilers seem to impose restriction (as if...) on R*RS. Not a
very good thing.
> - CL tends to have constructions that combine sets of special cases
> behind a common front.
Just assuming a definition of "special cases" which you do not
provide, Scheme has no "special cases" because the main design goal of the
language is the shortness of the spec document.
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
In article <··············@snapdragon.csl.sri.com>,
Fred Gilham <······@snapdragon.csl.sri.com> wrote:
>
>I also tried logo but I couldn't really get recursion. I could use it
>but I was never quite sure of myself.
I had the good fortune to be involved in a Logo pilot program in my school
district. When I was in 3rd grade (1983), our school got a lab full of 20
Commodore 64's running the Commodore Logo. We were introduced to
functional decomposition, iteration, and recursion pretty early on. It
made an impression, as I was never truly happy with BASIC.
-Mike
--
http://www.mschaef.com
It started about 1989 with AutoCAD.
I knew prolog and forth before, so it was not too weird.
--
Reini Urban
http://xarch.tu-graz.ac.at/autocad/news/faq/autolisp.html
·······@syncreticsoft.com (Damond Walker) wrote in message news:<····························@posting.google.com>...
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
Accidentally, via the road less travelled. (Very different from the
typical hard-core engineering / math background).
I started programming relatively late in life after spending most of
my youth travelling, writing, making music and learning about people,
their lifestyles, beliefs, histories, and cultures. I always had a
peripheral interest in science, but very little interest in
technology.
That began to change when a short series of LSD experiments
unexpectedly re-opened my eyes to the beauty of mathematics and
geometry.
It occurred to me that a computer would be an excellent tool for
experimenting with the peculiar fractal-like ideas and images that
characterise the LSD state. I wanted to experiment with the generation
of complexity by applying simple feedback functions to simple motifs.
I also had a vague intuition that the principles behind fractal
geometry might also be applicable in non-graphical domains: so-called
Chaos Theory, other branches of science, and maybe even neurology.
(Hell, maybe all of nature. I was still young enough to think I'd
discovered something new).
The vision splendid faded, but the PC hung around. I dabbled a bit
with QBasic, fiddled about briefly with VB and Delphi, then moved on
to C and C++. (I spent an enormous amount of time on C++, and to my
deep regret I feel it was almost all wasted time). Eventually I became
quite interested in the process of programming itself, and began to
look for better ways of doing it. Eiffel was my first step along that
route.
My discovery of Lisp was a lucky accident. Given my late introduction
to computer science (c. 1995), I'd managed to get most of the way
through a part-time university degree without ever hearing about Lisp.
(And in hindsight I think that is a sad and disgraceful state of
affairs, akin to teaching English literature without mentioning
Shakespeare).
One day I was browsing idly in the university bookshop and found some
copies of Peter Norvig's PAIP. Nearby I found copies of Winston &
Horn's "Lisp". Bought both. Read some the first night. Soon realised
that Lisp was way ahead of its time. Was very surprised to find so
many "modern" ideas in such an ancient language. I knew straight away
that this would be an interesting language to learn.
But, given my unusual interest in computers, I found Lisp to be
something more than just an interesting language for getting things
done. In a way, I admire Lisp as a *product* as much as I appreciate
it as a tool. Lisp is itself a good example of how complexity can
flower out and proliferate from a simple motif without losing elegance
and symmetry. Whenever I see something with those qualities, I can't
help feeling it offers a glimpse of something transcendent.
Unfortunately, my daily workaday world has little place for such
mystical crap, so for now it's back down to earth and out to C ...
Damond Walker wrote:
> I'm always interested in how people "came to something." In this
> case it's Lisp. How about relaying how you "came to Lisp?"
It all started back in high school, in 1985 or so. At the time I'd been
programming in Basic and Z80 assembler only on my home computer. I might
have heard the name Lisp, but I had no idea what it was until one day
our mathematics teacher (who was giving an informal "introduction to
programming" course to some of us who were interested in computers)
handed me a floppy disk saying "You might find this interesting." It
turned out the floppy contained a copy of muLISP. It took me a while to
figure out how to use it, given the unusual environment and the almost
total lack of documentation, but I remember being able to run the
classical "Guess the animal" example.
Around the same time, a special issue of Scientific American on software
appeared; one of the articles, on artificial intelligence, showed some
Lisp code and described Lenat's Eurisko. I was hooked immediately. My
next step was to get a copy of Golden Common Lisp and to read P.H.
Winston's book. I kept playing with Lisp during my university years,
until I found out that the AI in Medicine lab owned a TI Explorer Lisp
machine. I managed to get accepted into that lab for my final
undergraduate project, and I was the last student to use the Lisp
machine before it was discarded in favor of a Sun workstation.
After graduation, I started using Lisp for my research work: my PhD
project was a distributed monitoring system for diabetic patients
written almost entirely in CL. For that project I wrote what I believe
is one of the very first CL Web servers (this was back in '94, as far as
I know only CL-HTTP is older). Since then I've used Lisp almost
exclusively, both for work and for personal pleasure :)
I currently write web-based bioinformatics applications for Harvard
Medical School. I am lucky enough to be able to do all my work in CL,
and I hope it stays this way for a very long time :)
--
Alberto Riva
Children's Hospital
Informatics Program
In article <····························@posting.google.com>, Damond Walker wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
First of all, I like your story of how you came to Lisp. Very cool.
I came to Lisp rather differently than the folks that've posted so far. I
read Douglas Hofstadter's book _Metamagical Themas_ (in, I guess, the late
1980's) which has three chapters on Lisp, and it seemed very cool. I took
Hofstadter's "spec" of Lisp and wrote a tiny Lisp interpreter in Turbo Pascal.
It didn't do much, but it could do the fundamental stuff: take a list and run
it as code. I think writing that interpreter gave me a fundamental
understanding of linked lists and pointers that many of my peers in college
lacked. Or maybe not. :) I never wrote any substantial code in my tiny
dialect, but I had a good time implementing it.
Oddly, I never encountered Lisp in college (University of South Florida BS in
Computer Science, 1991), aside from one half-remembered discussion with a
friend of a friend who said (somewhat tongue-in-cheek) that "in Lisp you can
say 'take the car of the cdr of the cdr of the car of some data structure' and
it'll wake you up and make you coffee in the morning". (USF taught Intro to
Computer Science using Modula-2.) More oddly, I took a graduate level Intro
to Neural Networks class, which also never mentioned Lisp (that I can recall
11 years later, anyway).
Anyway, I didn't do much else with Lisp for many years, though the language
continued to hold a remembered fascination for me. I bought Winston & Horn's
_Lisp_, 3rd edition, a couple years ago, and read a good bit of it, but still
didn't do much else.
Most recently, sometime in January I stumbled on Kent Pitman's interview on
Slashdot, and it wouldn't overstate the case to say I was dazzled.
These paragraphs, in particular, caught my eye and sparked my imagination:
Kent:
Lisp is dynamic. The world is ever changing and it's useful to allow
programs to change dynamically with it. I can load new or changed
functions, classes, and method definitions into a running image that I'm
debugging, or even in a deployed production application. When I do, the
code that was running will immediately start using the new definitions.
Classes can be redefined even if the new class has different slots, and,
if I care to, I can control how the update is done from old to new slot
arrangements for already-created instances. This kind of thing supports
programs that must be continually running yet must be responsive to
changes or even just bug fixes.
A /. poster named kfogel:
For myself and a number of friends, Lisp/Scheme programming has for too
long been a kind of mystical Eden, fading in our memories, from which we
have been mostly banished in our professional lives. But we can still
recall how it felt to work in a language able to shape itself to any
pattern our minds might ask: coding was more interesting and more
expressive, and the rate of increasing returns over time was tremendous,
because fine-grained -- almost continuous -- abstraction was in the nature
of the language. Life was just more fun, frankly.
I haven't *had fun* programming for quite a while. I've enjoyed it, and I've
occasionally gotten to tackle interesting problems, but I've rarely had fun.
:-\
Since then, I've read Graham's _On Lisp_ and _ANSI Common Lisp_, and I've
developed a (not-very-full-featured, but it gets the job done) facility for
sending Lisp code from Vim to CMUCL. I've read some of Graham's other papers,
including the one where he describes his work at Viaweb in some detail. I've
pondered the idea of starting an ASP of some kind (like Viaweb), or of trying
to create a neural net that would predict a series of numbers (e.g. stock
prices :), both in Lisp. But you have to walk before you can run, as they
say, so for now I read c.l.l and do exercises out of ACL.
My $0.02.
-- Larry
"Damond Walker" <·······@syncreticsoft.com> wrote in message
·································@posting.google.com...
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
In the Before Time, when human's lived in caves and Woolly Mammoths walked
the hills, there were no computers and debugging was very difficult and very
dangerous.
Later, I took AI courses and learned Lisp.
--
Coby Beck
(remove #\Space "coby 101 @ bigpond . com")
=:-B
(sorry, I wanted to add my story, but it just didn't seem interesting
enough..)
·······@syncreticsoft.com (Damond Walker) writes:
> I'm always interested in how people "came to something." In this
> case it's Lisp. How about relaying how you "came to Lisp?"
I first heard of Lisp while I was in high school in the
mid-1980s - probably from reading Steven Levy's _Hackers_, but
possibly from another book I read around the same time. At the
time, my computer was an Apple IIc and Assembler/Basic were mostly
what I worked with, though I never mastered assembler. At this
time, I also worked with Pascal [mostly used Borland Turbo Pascal on
PCs] and Logo for the Apple II [loved those turtle graphics...],
while getting exposure to Prolog, Fortran and HyperCard Scripting...
Between 1988 and 1990, I learned C and Scheme, as well as
participating in an experiment conducted by the CMU Psychology
Department related to teaching Lisp [probably Common Lisp, although
I'm not sure since it was a very small subset]. Scheme came easiest
to me, as it "just made sense." I was also impressed at how easily
we could switch to a "object oriented" [via message passing] style
in Scheme...
Between 1990 and 1997, I worked in C and various scripting
languages including Perl and Awk.
Between 1997 and 2002, I added some C++, Java, ML, as well as
revisiting Scheme. Since I prefer more abstraction in my programs,
I find writing C code to be tedious - these OO-oriented and
functional-oriented languages were more enjoyable to me than plain,
old, vanilla C.
During all this time, I was an avid Emacs user, so I hacked [in
the sense of chopping roughly with no real skill] at ELisp.
Finally, in 2002, I bit the bullet and decided to learn Common
Lisp. I *love* Common Lisp and am enthusiastically "building up"
the language to support coding the solution to my current problem in
"the native language" of the problem domain.
-jon
--
------------------
Jon Allen Boone
········@delamancha.org
> I'm always interested in how people "came to something." In this
> case it's Lisp. How about relaying how you "came to Lisp?"
Good idea. These stories are interesting!
At the school computer club, me and two other guys were interested in
computer languages. This was a problem, since the only language we
had was BASIC (on the TRS-80, mostly). So we learned assembly
language, and read books on various languages, and designed our own
language, mostly based on APL, which we thought was really powerful -
but we never got started on implementing it.
One day, another kid, Orri Erling, comes in, and he's written a Lisp
interpreter in Z80 assembly. That was quite impressive, even though
not practical to use, as he never quite finished the system, having
found something more interesting to do. So grade 10 (3rd-to-last) was
when I got the idea that Lisp was the coolest language to play with.
I must've read some book on it at this time, but I don't remember
which.
Later, we went to various Universities, but kept in touch with Orri
who was a couple of years younger than us. He developed this plan for
"taking over the world" by writing a better database management system
- in Lisp, naturally - and wanted to start a company. When he asked
the three of us to join, we were excited and said "Sure!" This was
before Oracle, so it made some sense.
By this time, Orri's Lisp interpreter had been ported to 8086 assembly
and Pascal, so I started hacking that, and really learned Lisp.
Eventually, we'd port it to 80186, 80286, 386 and 486, rewrite the
whole thing to make to make it CL-compliant (and to Do It Right), and
build a compiler, and never get to market with the DBMS. So we sold
the Lisp instead (mostly in Finland, as Mikko Lisp and ES-Lisp and the
new implementation as ECL). Not succesfully, I might add.
So, I basically learned Lisp by hacking Lisp implementations. I don't
think I ever took a class in Lisp. Taught a couple, though: for the
computer club at the old school and filling in at a vocational school.
--
Pekka P. Pirinen
"Truth is stranger than fiction because fiction has to make sense."
- Steve Smith <sgs_grebyn.com>
I'd like to post the "Intro to Lisp" stories that many of you have
submitted recently to comp.lang.lisp, on the Franz web site. I've
found them interesting, and I think other folks who may not always
read comp.lang.lisp (especially newbies), would as well.
If you'd like to be included, please send me an email (····@franz.com)
containing the following information:
* Let me know that it's okay to post your story.
* The text of your story
* A little bit of information about you -- where you work, types
of apps you build, etc. (if you wish).
Thanks!
····@franz.com (Lisa Fettner) writes:
> I'd like to post the "Intro to Lisp" stories that many of you have
> submitted recently to comp.lang.lisp, on the Franz web site. I've
> found them interesting, and I think other folks who may not always
> read comp.lang.lisp (especially newbies), would as well.
>
> If you'd like to be included, please send me an email (····@franz.com)
> containing the following information:
> * Let me know that it's okay to post your story.
> * The text of your story
> * A little bit of information about you -- where you work, types
> of apps you build, etc. (if you wish).
That is a good idea. Getting them on the ALU site would also be good.
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
I must say, this thread has been totally fun & fascinating. cll has
been more lively as of late.
My intro to lisp was in an intro to comp-sci course. Previously I had
been exposed only to C++, which at the time I thought was the bee's
knees. Unfortunately, lisp didn't appeal to me that first time
around. Though I really had wanted to like lisp (I was interested in
AI had been inspired by some of the language in our class's text book,
Graham's "ANSI Common Lisp"), I had a hard time just getting things
done in lisp.
I could never remember where the parens fell in 'cond, and ANSI CL had
a typo in the index that confused me on this matter even more. There
wasn't a "for" loop and 'do seemed insane. yada yada...
Soon after, I got a job where I had to learn perl for some web
development projects I was working on. Many of the perl constructs I
immediately recognized from common lisp: map, eval, push / pop,
automatic memory management with dynamic data structures as builtins,
runtime typing (perl has a weird type system that at this point I
don't even know how to classify), lexical and dynamic scope.
Learning perl didn't, in itself, motivate me to give lisp a second
chance. It just made me more ready to embrace lisp when I was
re-introduced to it during an AI course I took the following year. My
final project consisted of a implementing a program that solved (or
tried to solve) a complex constraint satisfaction problem using a
technique called dynamic backtracking. Quite frankly, I never would
have been able to get as far with that project as I did if it weren't
for lisp.
Lisp helped me every step of the way and it's frightening to imagine
hacking that program in something like C++, Java, or even Perl. Viva
lisp!
·······@syncreticsoft.com (Damond Walker) wrote in message news:<····························@posting.google.com>...
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
For me, I had to learn Lisp for an AI course taught by a professor in
the psychology department who didn't really know how to program, so I
was on my own. I got a copy of "Anatomy of Lisp", and it was the
first time I was really exposed to the idea of abstract data types
(constructors, accessors, and mutators). The idea certainly was not
easily expressible in Basic, and had not been done well in my Intro CS
course using PL/I. The ideas made sense to me, and Lisp was the only
language I had used that supported abstraction well, so I continued to
use it from then on.
Peter Norvig <·····@norvig.com> wrote in message
·································@posting.google.com...
> ·······@syncreticsoft.com (Damond Walker) wrote in message
news:<····························@posting.google.com>...
> > I'm always interested in how people "came to something." In this case
> > it's Lisp. How about relaying how you "came to Lisp?"
>
>
> For me, I had to learn Lisp for an AI course taught by a professor in
> the psychology department who didn't really know how to program, so I
> was on my own. I got a copy of "Anatomy of Lisp", and it was the
> first time I was really exposed to the idea of abstract data types
> (constructors, accessors, and mutators). The idea certainly was not
> easily expressible in Basic, and had not been done well in my Intro CS
> course using PL/I. The ideas made sense to me, and Lisp was the only
> language I had used that supported abstraction well, so I continued to
> use it from then on.
Peter, you have recently been cited as an example of someone of high esteem
in the Common Lisp world who has abondoned it, along with Paul Graham. I
think this is fair on the surface for Mr. Graham, given his own writings and
his focus on designing something "better".
Is this a fair characterisation of your current views/opinions? Have you
purposely "left" lisp to work in other languages? If so, why?
Do you have any hopes or concerns about lisp's future?
Curiously,
--
Coby Beck
(remove #\Space "coby 101 @ bigpond . com")
In most cases my choice of language is determined by the context of
the work -- the existing programs, libraries, and community of
co-programmers that I have to work with.
For small, new projects where this is not an issue, Common Lisp would
still be a top choice as a language I can get a lot of work done in
quickly.
I guess I got a reputation for abandoning Lisp because I am
experimenting with Python as an alternative to Lisp for the
implementation language for my AI text with Stuart Russell. The
hypothesis is that (1) instructors no longer have time to teach 2
weeks of Lisp as part of the AI course because there is so much
material in an AI course now, (2) some students have trouble learning
Lisp on their own, and (3) some students may already know Python, or
find it easier to learn than Lisp. Therefore, it makes sense to offer
Python as an alternative to Lisp. Since the code is still fairly
incomplete, I don't know yet whether the hypothesis will hold up. See
http://www.norvig.com/python/python.html for more details.
"Coby Beck" <·····@mercury.bc.ca> wrote in message news:<······················@news1.calgary.shaw.ca>...
>
> Peter, you have recently been cited as an example of someone of high esteem
> in the Common Lisp world who has abondoned it, along with Paul Graham. I
> think this is fair on the surface for Mr. Graham, given his own writings and
> his focus on designing something "better".
>
> Is this a fair characterisation of your current views/opinions? Have you
> purposely "left" lisp to work in other languages? If so, why?
>
> Do you have any hopes or concerns about lisp's future?
>
> Curiously,
On 24 Apr 2002 02:56:00 -0700, ·····@norvig.com (Peter Norvig) wrote:
>find it easier to learn than Lisp. Therefore, it makes sense to offer
>Python as an alternative to Lisp.
As an alternative or a complement to lisp? O:-) Will the new edition have
examples only in Python or in Python and Lisp?
-----------------------
Fernando Rodriguez
The second edition of the Russell & Norvig book, like the first, will
have only pseudo-code -- no Lisp or any other actual language. (It
turns out the pseudo-code does look more like Python than anything
else, although I had not seen Python when we invented the pseudo-code
format.) Don't confuse this book with my "Paradigms of AI Programming
in Common Lisp" book, for which no second edition is planned.
The online site accompanying the book will offer a complete reference
implmentation of the code in Lisp, hopefully a complete or
near-complete version in Python, and whatever code in Prolog, C++,
Java, etc. that helpful users want to contribute.
-Peter
Fernando Rodr?uez <····@wanadoo.es> wrote in message news:<··································@4ax.com>...
> On 24 Apr 2002 02:56:00 -0700, ·····@norvig.com (Peter Norvig) wrote:
>
> As an alternative or a complement to lisp? O:-) Will the new edition have
> examples only in Python or in Python and Lisp?
>
Peter Norvig wrote:
> In most cases my choice of language is determined by the context of
> the work -- the existing programs, libraries, and community of
> co-programmers that I have to work with.
>
> For small, new projects where this is not an issue, Common Lisp would
> still be a top choice as a language I can get a lot of work done in
> quickly.
>
> I guess I got a reputation for abandoning Lisp because I am
> experimenting with Python as an alternative to Lisp for the
> implementation language for my AI text with Stuart Russell. The
> hypothesis is that (1) instructors no longer have time to teach 2
> weeks of Lisp as part of the AI course because there is so much
> material in an AI course now, (2) some students have trouble learning
> Lisp on their own, and (3) some students may already know Python, or
> find it easier to learn than Lisp. Therefore, it makes sense to offer
> Python as an alternative to Lisp. Since the code is still fairly
> incomplete, I don't know yet whether the hypothesis will hold up. See
> http://www.norvig.com/python/python.html for more details.
In my experience many people I know who did not know Lisp before used
Python like they used C or Java. Lisp, being more foreign to them, forced
them to think in other terms and changed their whole style and way of
thinking. So yes - the students may know Python but they think of it *much*
different than someone with prior experience with a language like Lisp.
Will Python replace Lisp as the implementation language for AIMA or will
both languages be supported in future?
I hoped that things like fol.lisp (which seems to be unfinished) will get
developed further in future.
ciao,
Jochen
--
http://www.dataheaven.de
>> I guess I got a reputation for abandoning Lisp because I am
>> experimenting with Python as an alternative to Lisp for the
>> implementation language for my AI text with Stuart Russell. The
>> hypothesis is that (1) instructors no longer have time to teach 2
>> weeks of Lisp as part of the AI course because there is so much
>> material in an AI course now, (2) some students have trouble learning
>> Lisp on their own, and (3) some students may already know Python, or
>> find it easier to learn than Lisp. Therefore, it makes sense to offer
>> Python as an alternative to Lisp. Since the code is still fairly
>> incomplete, I don't know yet whether the hypothesis will hold up. See
>> http://www.norvig.com/python/python.html for more details.
>
> In my experience many people I know who did not know Lisp before used
> Python like they used C or Java. Lisp, being more foreign to them, forced
> them to think in other terms and changed their whole style and way of
> thinking. So yes - the students may know Python but they think of it
> *much* different than someone with prior experience with a language like
> Lisp.
>
yes, I noticed that when I started using lisp. it did effect they way I
started thinking about things, but I do not consider it really a problem.
now I end up writting lisp like stuff in c...
of course similar occured when I encountered relational dbms's, which I
also consider as having effected the way I write code...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
From: Friedrich Dominicus
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <87hem19kku.fsf@fbigm.here>
·····@norvig.com (Peter Norvig) writes:
> (1) instructors no longer have time to teach 2
> weeks of Lisp as part of the AI course because there is so much
> material in an AI course now
I think two week within a AI course is not too much.
> (2) some students have trouble learning
> Lisp on their own,
Some may have trouble learning Modula-2 on their own. At least I know
one ;-) This holds IMHO for any other language and it therefor not a
sound reason in favor of any language or againt another.
> and (3) some students may already know Python, or
> find it easier to learn than Lisp.
Well other students may know Java or C or C++ or ... and may find it
easier to learn Lisp. But it could be that some students may already
know Lisp and find it easier to learn and use than ....
> Therefore, it makes sense to offer
> Python as an alternative to Lisp.
Well you could use other alternatives with the same reasons as for
Python, Ruby seems to fit even better than Python.
Regards
Friedrich
Peter Norvig wrote:
>
> For small, new projects where this is not an issue, Common Lisp would
> still be a top choice as a language I can get a lot of work done in
> quickly.
>
Ups, i just started lisp (3weeks ago) because i would like to handle
HUGE projects and thought that lisp was a good choice for that. Am i
wrong ?
> I guess I got a reputation for abandoning Lisp because I am
> experimenting with Python as an alternative to Lisp for the
> implementation language for my AI text with Stuart Russell. The
> hypothesis is that (1) instructors no longer have time to teach 2
> weeks of Lisp as part of the AI course because there is so much
> material in an AI course now, (2) some students have trouble learning
> Lisp on their own, and (3) some students may already know Python, or
> find it easier to learn than Lisp. Therefore, it makes sense to offer
> Python as an alternative to Lisp. Since the code is still fairly
> incomplete, I don't know yet whether the hypothesis will hold up. See
> http://www.norvig.com/python/python.html for more details.
>
If it is allowed to discuss your hypothesis:
(1) --> Introductionary courses never can nor want to cover the hole
area of AI but
want to give a "toolset" for the student to continue. IMHO you
try to remove
one of the importent tools: Lisp.
I'm a newby to both AI and lisp but the first i learned in AI is
that i have
to learn Lisp to read the programs related to AI in the books.
And it was nice
to find that most of the stuff is written in lisp (and not in
five or six different
languages).
(2) --> Some students have trouble to learn calculus. Should we remove
it from the engeneering
courses ? ;-)
IMHO everyone that can learn BASIC can even learn lisp. The
problem is to understand the
concepts behind the syntax. But that holds for all languages.
And if Phyton has comparable
concepts like lisp than you will find other students who have
trouble to learn phyton.
(3) --> But more have to learn Phyton. So the instructor have to spend
the two weeks saved in (1) to
teach Phyton. And after the course the students that are
interested in AI have to learn
lisp (see above).
What i don't understand at all is what Phyton makes better than lisp. Is
there any thing that can be
done in Phyton that can't be done in lisp ?
Best regards
AHz
Andy wrote:
> Ups, i just started lisp (3weeks ago) because i would like to handle
> HUGE projects and thought that lisp was a good choice for that. Am i
> wrong ?
Well, Peter wrote:
> In most cases my choice of language is determined by the context of
> the work -- the existing programs, libraries, and community of
> co-programmers that I have to work with.
So if you are doing your own thing you are not bound by much context. PN
mentioned libraries, but Lisp can call non-Lisp libraries more or less
conveniently depending on the library.
One huge win of CL over C++ on a huge project would be eliminating the
huge compile/link delays.
Andy wrote:
>
> What i don't understand at all is what Phyton makes better than lisp.
I think the key was the third reason, that Python is riding a wave of
popularity. The authors want to make money, after all. The professors
want students in the seats.
No point in debating this, PN was simply kind enough to share a working
hypothesis:
Peter wrote:
> > Since the code is still fairly
> > incomplete, I don't know yet whether the hypothesis will hold up.
--
kenny tilton
clinisys, inc
---------------------------------------------------------------
"Harvey has overcome not only time and space but any objections."
Elwood P. Dowd
Kenny Tilton wrote:
>
> I think the key was the third reason, that Python is riding a wave of
> popularity. The authors want to make money, after all. The professors
> want students in the seats.
Yes, python may be flawed, and is definitely currently a weaker, less
well-rounded language than common lisp (particularly for metaprogramming) -
and the whitespace sensitivity is either love-it or hate-it, but it is
undeniably popular currently.
Personally, I would not pick a language with pythonesque
whitespace-sensitivity for examples in a book - with a language that
delimited with visible characters, it doesn't really matter if the
publisher screws up slightly, with a whitespace-sensitive language, it's
much more sensitive to positioning errors, and misguided "improvements".
I think it is a mistake to pick $LANGUAGE_OF_THE_MOMENT
for books - unless the book is specifically about that particular language,
programming principles are usually generally applicable - one of the reasons
why Lisp is popular in teaching books is because you _can_ illustrate,
easily, most of those principles in it.
Lisp has the advantage of standardisation, like C and Fortran.
Python is still in the "early evolution" stages, really.
And why Python? Why not TCL, Perl, or Ruby?
They're all comparably powerful, reasonably similarly popular,
comparably elegant (or otherwise*), and all doing the
reinvent-lisp-but-with-funny-syntax thang...
* I consider perl to have the organic elegance of a large rainforest...
--
Don't eat yellow snow.
In article <···················@news.iol.ie>, David Golden wrote:
> Personally, I would not pick a language with pythonesque
> whitespace-sensitivity for examples in a book - with a language that
> delimited with visible characters, it doesn't really matter if the
> publisher screws up slightly, with a whitespace-sensitive language, it's
> much more sensitive to positioning errors, and misguided "improvements".
Heh, if they want to screw up there are a million ways of doing so:
A few years ago I bought the German translation of ``ANSI Common Lisp'',
and in the chapter about macros they always mixed up tick (') and
backtick (`). Made the examples /slightly/ confusing... That was
the last time I bought a translation of a book.
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
"Nils Goesche" <······@cartan.de> wrote in message
···················@ID-125440.news.dfncis.de...
> A few years ago I bought the German translation of ``ANSI Common Lisp'',
> and in the chapter about macros they always mixed up tick (') and
> backtick (`).
I had something comparable once when I wrote a review of a CL book (Lisp
Style and Design it was, I think): the typesetter had switched all the
keyword colons with the preceding space, because (s)he supposed the colons
were meant to go with the preceding words.. And of course I wasn't asked
to proofread.
--
Biep
>
> Andy wrote:
> >
> > What i don't understand at all is what Phyton makes better than lisp.
>
> I think the key was the third reason, that Python is riding a wave of
> popularity. The authors want to make money, after all. The professors
> want students in the seats.
>
You mean like Forth or Borland Pascal some years ago. Mhhh, for me that
is a absolut "Don't do this".
For me a programming language is a tool not a pair of shoes that should
be
changed due to some hype. And if i find a better tool than i want to use
it (thats why i change currently from C/C++ to lisp).
I don't want to start a new language discussion. I currently read
Peter's
famous PAIP and was wondering why he changed from lisp to phyton. For me
it would be double work to learn AI because i now learn lisp (not only
for AI)
and then have to learn Phyton to read the next book.
And after reading Peters comparision of Phyton and Lisp i simple can not
find at least one think that points out for phyton. All i can do with
phyton
can also be done with lisp. And btw. Peter said phyton was 100 (!) times
slower.
Best regards
AHz
Andy wrote:
[snip]
> I don't want to start a new language discussion. I currently read
> Peter's
> famous PAIP and was wondering why he changed from lisp to phyton. For me
> it would be double work to learn AI because i now learn lisp (not only
> for AI)
> and then have to learn Phyton to read the next book.
If you know how to program, then learning enough Python to get you
reading examples should not take you more than a few hours.
Starting programming seriously in Python should not take more than a
week.
> And after reading Peters comparision of Phyton and Lisp i simple can not
> find at least one think that points out for phyton. All i can do with
> phyton
> can also be done with lisp. And btw. Peter said phyton was 100 (!) times
> slower.
10 - 100, if you make good use of the libraries it gets faster since
they are mostly written in C.
It seems to me that Python deserves most of the hype it gets. Maybe
it "reinvents" much of what is already in Lisp, but that need not be a
bad thing. Maybe Python will do some things better and then Common
Lisp can say "hey, I didn't think of that, lets try it out" :)
A symbioses of some sort.
--
Thomas.
Thomas Stegen wrote:
>
> If you know how to program, then learning enough Python to get you
> reading examples should not take you more than a few hours.
> Starting programming seriously in Python should not take more than a
> week.
>
But, again, what is the advantage ? Learning one more scripting language
after all the others is not the point by itself. The question for me is
what i can do better with it. If there is nothing new then it's waste of
time.
I.e using perl for system administration tasks is a advantage compared
to
core shell programming (maybe holds only for me) due to the integration
of awk, C & sed features.
>
> 10 - 100, if you make good use of the libraries it gets faster since
> they are mostly written in C.
>
Ok, but even 10 times slower is not realy an advantage ;-)
> It seems to me that Python deserves most of the hype it gets. Maybe
> it "reinvents" much of what is already in Lisp, but that need not be a
> bad thing. Maybe Python will do some things better and then Common
> Lisp can say "hey, I didn't think of that, lets try it out" :)
> A symbioses of some sort.
Thats true. It's not that i don't like phyton (in fact i didn't know
it).
But i just started learning lisp and feel very comfortable with it. And
as i can see it has adapted (or maybe invented) lots of concepts that
are
realy helpful (i.e. Objects, error-handling). I'm shure that it will
also
adapt new things due to it flexible structure.
But exactly that makes it a "long-time language" (as seen the last 40
years).
So i again end up in asking what a change to phyton is good for ;-)
Best regards
AHz
Andy wrote:
>
> Thomas Stegen wrote:
>
>>10 - 100, if you make good use of the libraries it gets faster since
>>they are mostly written in C.
>>
>>
> Ok, but even 10 times slower is not realy an advantage ;-)
>
Yeah, if you need speed, then Python is not always the language to
go for.
I am not trying to say that you should ditch Lisp in favor of Python.
I was trying to say that if you ever feel that you need to learn Python
(for whatever reason) it is very easy to do. And IMHO it is also
a language worth learning, and so is Lisp.
--
Thomas.
On Wed, 24 Apr 2002 23:56:37 +0100, Thomas Stegen <·······@cis.strath.ac.uk>
wrote:
>If you know how to program, then learning enough Python to get you
>reading examples should not take you more than a few hours.
>Starting programming seriously in Python should not take more than a
>week.
Especially if you already know Lisp.
>It seems to me that Python deserves most of the hype it gets. Maybe
>it "reinvents" much of what is already in Lisp, but that need not be a
>bad thing.
Python is Lisp for the masses and its success will probably help Lisp in the
long run. Probably Lisp vendors should start targeting Python shops looking
for more power.
IMHO Python is the best way to show the average programmer that Lisp is a good
idea.
-----------------------
Fernando Rodriguez
* Andy <···@smi.de>
| And btw. Peter said phyton was 100 (!) times slower.
Perhaps Lisp has a future as an interpreted language? Maybe this whole
compiler thing was the reason it never took off? Lisp was slow and large
and interpreted _way_ ahead of the crowd, but then got fast and lean and
mean before the others had time to catch up or even be invented. Such is
_not_ good for business. The key problem is that computers are simply
becoming too fast for human comfort. Computers have already answered
most questions before the human has actually finished asking it, like
this: before the tactile response from the mouse or the enter key has
reached the brain, the eye detects a change, making it appear that the
computer knew what you were going to ask before you did. Clearly, if
you are generally slow to begin with, this can be stunningly scary. Our
good friends at Microsoft are working day and night to make sure that no
computer is ever faster than any person alive on earth today, and many
other developers for too fast computers help by reinventing byte code and
other slow and bloated interpreters. It also helped a lot with slow and
congested Internet links, but now that that is soon history, responsible
and idiot-friendly companies compensate for any uncomfortable speed with
web pages with tons of Javascript, stylesheets, many nested tables, and a
thousand images that say less than one well-chosen word, not to mention
the excellent effort by such things as Gecko to make display comfortably
and predictably slow. Users can make a very simple test. How fast do
you want your autorepeat to work? Set the number of repetitions per
second to what you believe is your IQ. IIff yyoouu wwrriittee
lliikkee tthhiiss ooorrr llliiikkkeee ttthhhiiisss, you are not as
smart as you think you are, and should get a slower computer, too, or
maybe use Python. Artificial Intelligence is good, but we cannot have
computers that are way faster than their programmers' real intelligence,
can we? Moreover, if the computer is busy doing some mindless repetitive
task like running a byte code interpreter, it will never figure out what
it is _really_ doing, either. The world is yet safe for average people.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
·····@norvig.com (Peter Norvig) writes:
> I guess I got a reputation for abandoning Lisp because I am
> experimenting with Python as an alternative to Lisp for the
> implementation language for my AI text with Stuart Russell. The
> hypothesis is that (1) instructors no longer have time to teach 2
> weeks of Lisp as part of the AI course because there is so much
> material in an AI course now, (2) some students have trouble learning
> Lisp on their own, and (3) some students may already know Python, or
> find it easier to learn than Lisp. Therefore, it makes sense to offer
> Python as an alternative to Lisp.
Perhaps a better alternative would be to hit at the heart of the
problem - AI courses (and possibly thus textbooks) need to be segmented.
How many levels of Algebra or Calculus are there? (rhetorical) And how
many levels of AI are taught nowadays? (not rhetorical; I really don't
know, but suspect that it is close to 1).
> Since the code is still fairly
> incomplete, I don't know yet whether the hypothesis will hold up. See
> http://www.norvig.com/python/python.html for more details.
Seems like at the technical level, there isn't enough difference to
warrant a change. And who knows how popular your book/course will be
several years from now, when Python has gone the way of other languages
and lost its faddish popularity...
--
Duane Rettig Franz Inc. http://www.franz.com/ (www)
1995 University Ave Suite 275 Berkeley, CA 94704
Phone: (510) 548-3600; FAX: (510) 548-8253 ·····@Franz.COM (internet)
Duane Rettig wrote:
> And who knows how popular your book/course will be
> several years from now, when Python has gone the way of other languages
> and lost its faddish popularity...
pardon my cynicism, but authors of college textbooks come out with new
editions precisely to kill the used market. they have to add new
material for this to work. N&R can just change to Ruby. :)
the good news is that it is a slippery slope from C++ to Java to Python
or Ruby to Lisp.
--
kenny tilton
clinisys, inc
---------------------------------------------------------------
"Harvey has overcome not only time and space but any objections."
Elwood P. Dowd
On Wed, 24 Apr 2002 22:13:06 GMT, Kenny Tilton <·······@nyc.rr.com> wrote:
> pardon my cynicism, but authors of college textbooks come out with new
> editions precisely to kill the used market. they have to add new
They may face competition by Sedgewick with his "Algorithms in YouNameIt"
series :)
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
[http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/]
Duane Rettig <·····@franz.com> writes:
> ... And who knows how popular your book/course will be
> several years from now, when Python has gone the way of other languages
> and lost its faddish popularity...
i don't know if useful languages ever really go away. it seems to me
that predictions on the language front is bound to be disappointing.
python is making it into highschools. this may or may not change its
futures for instance.
obhref: www.python.org/workshops/2000-01/proceedings/papers/elkner/pyYHS.htm
oz
--
you take a banana, you get a lunar landscape. -- j. van wijk
ozan s yigit <··@blue.cs.yorku.ca> writes:
> i don't know if useful languages ever really go away. it seems to me
> that predictions on the language front is bound to be disappointing.
> python is making it into highschools. this may or may not change its
> futures for instance.
But so did Pascal and BASIC, and C and C++ never really did until
recently, when the AP test switched over to C++, so I don't see any
significant connection.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
I think Duane is hitting at a big part of the problem: too much AI
material for one course. I realize that AIMA, at 1000 pages, doesn't
help much. In an ideal world (from my point of view) there would be a
two-semester AI "theory" sequence, and a separate AI programming
course. Berkeley, MIT, CMU and some other schools work pretty much
like this, but most schools do not -- as Duane points out, most
schools (and almost all students) don't go beyone 1 AI course.
In AIMA we chose not to address the AI programming part at all -- we
don't teach a programming language, and we don't teach software
engineering for AI. Instead we teach the theory and intuitions behind
the problems and their solutions. I tried to cover Lisp and software
engineering in PAIP, and it really does deserve its own 1000 pages.
Given that we don't teach a language in AIMA, the choice is really up
to the professor, and I think it can't hurt to offer some options.
(Note: if it were really the case that most of AI was done in Lisp,
then it WOULD hurt to fragment the community by encouraging other
languages. But there was always a variety of language choices (e.g.
Prolog, Pop-11), and if you look at the current
statistical/probabilistic/machine learning AI communities, they're
doing more work in C++ and Matlab than in Lisp.)
For those who are interested in programming real AI applications,
rather than just understanding the algorithms in a course setting, I
continue to recommend Lisp, and to recommend against Python (unless
you're willing to code some extensions in C).
And for Duane and his employer, let me say that if there was a
standard, easy to use Common Lisp GUI package that was portable across
Windows, several flavors of Unix, and possibly Mac, then I would never
have started looking at Python. Really the only answer to "what can
Python do that Lisp can't" that matters to me is "put up a window in a
portable way".
-Peter
Duane Rettig <·····@franz.com> wrote in message news:<·············@beta.franz.com>...
> ·····@norvig.com (Peter Norvig) writes:
>
> Perhaps a better alternative would be to hit at the heart of the
> problem - AI courses (and possibly thus textbooks) need to be segmented.
> How many levels of Algebra or Calculus are there? (rhetorical) And how
> many levels of AI are taught nowadays? (not rhetorical; I really don't
> know, but suspect that it is close to 1).
>
>>>>> "PN" == Peter Norvig <·····@norvig.com> writes:
PN> ... But there was always a variety of language choices
PN> (e.g. Prolog, Pop-11), and if you look at the current
PN> statistical/probabilistic/machine learning AI communities,
PN> they're doing more work in C++ and Matlab than in Lisp.)
Yes, I noticed this shift in the early 90's and it really is a shame
for all the reasons this community knows about and especially since
Common Lisp provides a uniquely convenient means of speeding up one's
slow general purpose code by making calling the compiler at run time
very convenient [1]. This was handy and cute when the hardware was slow
enough for even the practically tractable algorithms to take an
inconveniently long time on standard/small problems and it probably is
still relevant today for large datasets. I suspect there
wasn't enough resident Lisp talent available in universities to
install and maintain Lisp systems let alone teach students how to get
performance out of them so people shifted their code over to C for
speed and then to C++ for the promised convenience. People might also
have looked at things like ID3->C4.5, versions of autoclass where the
shift was towards C [2]. Somewhat later things like ML++ appeared and
those packaged convenient things in C++. A good CL environment and
some libraries could have simultaneously satisfied the constraints that
make people go to C++ (speed) and Matlab (convenience), but it didn't
happen. I started a half-hearted personal attempt in CL/CLIM [3], but
then when I wanted comments from people it turned out many did not
have that set-up. Given the trends I saw back then, I am not surprised
that the state of affairs is as you say in 2002.
[...]
PN> And for Duane and his employer, let me say that if there was a
PN> standard, easy to use Common Lisp GUI package that was
PN> portable across Windows, several flavors of Unix, and possibly
PN> Mac, then I would never have started looking at Python.
PN> Really the only answer to "what can Python do that Lisp can't"
PN> that matters to me is "put up a window in a portable way". [...]
Indeed, and do it for free in a pre-installed package in university
environments _and_ in something people can install into their home machines
without much effort. At the present time there is no Commmon Lisp that
can do that. Garnet+AKCL or Garnet+CMUCL on the Unix side and Garnet+MCL
on the Mac side would have been a possibility 10 years ago. As Bruce Hoult
pointed out, punting to Tk is a possibility right now, but as far as I know
it is neither pre-packaged in all platforms nor is it adequately documented
(do a search for tkinter, and then do the same search for Lisp/Tk and you'll
see). It seems unless somebody funds another Garnet-like project, the
situation will not change.
cheers,
BM
[1] One such example for a 'nearest neighbour' sort of a problem that came up
here is: http://groups.google.com/groups?selm=sovpzcm6.fsf%40servtech.com
[2] "Lisp is slow" is still mentioned. See "10-20 times faster" in
http://ic.arc.nasa.gov/ic/projects/bayes-group/autoclass/autoclass-c-program.html
[3] http://www.cs.rochester.edu/u/mucit/res/newshell.html (no I don't have
the code in running, let alone distributable form now)
From: Friedrich Dominicus
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <87bsc8kk3o.fsf@fbigm.here>
·····@norvig.com (Peter Norvig) writes:
>
> And for Duane and his employer, let me say that if there was a
> standard, easy to use Common Lisp GUI package that was portable across
> Windows, several flavors of Unix, and possibly Mac, then I would never
> have started looking at Python. Really the only answer to "what can
> Python do that Lisp can't" that matters to me is "put up a window in a
> portable way".
Well I have used CAPI from LispWorks on both Windows and Linux and it
runs on diverse unices too. It's as easy as (for a dialog)
(capi:display-message "this is a ~A capi dialog" (type-of 10))
But I guess that is not what you want to have?
Regards
Friedrich
Friedrich Dominicus <·····@q-software-solutions.com> writes:
> Well I have used CAPI from LispWorks on both Windows and Linux and it
> runs on diverse unices too. It's as easy as (for a dialog)
> (capi:display-message "this is a ~A capi dialog" (type-of 10))
>
> But I guess that is not what you want to have?
I wish someone could port CAPI to MCL (and that Digitool soon gets their
OS X version out)...
--
(espen)
From: Friedrich Dominicus
Subject: Re: Your introduction to Lisp...
Date:
Message-ID: <87ofg7izuz.fsf@fbigm.here>
Espen Vestre <·····@*do-not-spam-me*.vestre.net> writes:
> >
> > But I guess that is not what you want to have?
>
> I wish someone could port CAPI to MCL (and that Digitool soon gets their
> OS X version out)...
Well I know some who could, ask Xanalys.
Regards
Friedrich
From: Rolf Mach
Subject: CAPI on Mac OS-X (was Re: Your introduction to Lisp...)
Date:
Message-ID: <3CC81535.27347622@xanalys.com>
Friedrich Dominicus wrote:
> Espen Vestre <·····@*do-not-spam-me*.vestre.net> writes:
>
> > >
> > > But I guess that is not what you want to have?
> >
> > I wish someone could port CAPI to MCL (and that Digitool soon gets their
> > OS X version out)...
> Well I know some who could, ask Xanalys.
>
> Regards
> Friedrich
Friedrich,
the question is not so simple.
Running CAPI on Mac OS-X through LessTif/openmotiv with a resulting X Windows
look and feel would be a solution technically within reach.
However it would not meet the Mac native Aqua standard that most Mac users
would expect for very good reasons.
I wonder how many Mac aficionados would accept this?
Cheers
Rolf
--
Rolf Mach
Xanalys Business Development & Sales Manager, Europe
An der Schaafhansenwiese 6
D-65428 Ruesselsheim, Germany
Phone ++49 +6142 938197
Fax ++49 +6142 938199
·····@xanalys.com
From: Friedrich Dominicus
Subject: Re: CAPI on Mac OS-X (was Re: Your introduction to Lisp...)
Date:
Message-ID: <87sn5jhipa.fsf@fbigm.here>
Rolf Mach <·····@xanalys.com> writes:
>
> Friedrich,
>
> the question is not so simple.
>
> Running CAPI on Mac OS-X through LessTif/openmotiv with a resulting X Windows
> look and feel would be a solution technically within reach.
I'm fully aware of that, but the OP asked if someone could to it. At
the moment the only group which really can is Xanalys.
>
> I wonder how many Mac aficionados would accept this?
That is a question which is difficult to answer. But I would think
"not too much". Nevertheless CAPI does not have to be bound to Motif
forever...
On the other hand I would think MCL does have the native-look-and-feel
So one could imagine using that and put CAPI above that toolkit.
Of course I can not say if that would be a viable product for Xanalys,
that is what Xanalys has to decide. Please read the original
message. It was about someone who "could do it" and it was a wish...
Wishing is still allowed, I guess.
Regards
Friedrich
On 25 Apr 2002 18:00:17 +0200, Friedrich Dominicus
<·····@q-software-solutions.com> wrote:
>> I wonder how many Mac aficionados would accept this?
>That is a question which is difficult to answer. But I would think
>"not too much". Nevertheless CAPI does not have to be bound to Motif
>forever...
I wonder how many Linux aficionados will still accept a Motif app instead of
Gnome or QT in the next few years... ;-)
-----------------------
Fernando Rodriguez
From: lin8080
Subject: Re: CAPI on Mac OS-X (was Re: Your introduction to Lisp...)
Date:
Message-ID: <3CC8CD9D.D9FA5F61@freenet.de>
Friedrich Dominicus schrieb:
> On the other hand I would think MCL does have the native-look-and-feel
> So one could imagine using that and put CAPI above that toolkit.
> Of course I can not say if that would be a viable product for Xanalys,
> that is what Xanalys has to decide. Please read the original
> message. It was about someone who "could do it" and it was a wish...
> Wishing is still allowed, I guess.
hallo friederich dominicus
You may look to
http://www.eligis.com/
There is an "OpenLisp" with simple graphics (see also ISLISP).
Small example:
.............................................
;;; Dragon
(defglobal ox 0)
(defglobal oy 0)
(defglobal oa 0)
(defun %line-to (x y)
(draw-line ox oy x y)
(setq ox x)
(setq oy y))
(defun walk (len)
(case oa
(( 0) (%line-to (+ ox len) oy))
(( 90) (%line-to ox (+ oy len)))
((180) (%line-to (- ox len) oy))
((270) (%line-to ox (- oy len)))))
..............................................
hope that is a step to what you wish?
stefan
From: Friedrich Dominicus
Subject: Re: CAPI on Mac OS-X (was Re: Your introduction to Lisp...)
Date:
Message-ID: <87lmb9zn9p.fsf@fbigm.here>
lin8080 <·······@freenet.de> writes:
> Friedrich Dominicus schrieb:
>
> > On the other hand I would think MCL does have the native-look-and-feel
> > So one could imagine using that and put CAPI above that toolkit.
>
> > Of course I can not say if that would be a viable product for Xanalys,
> > that is what Xanalys has to decide. Please read the original
> > message. It was about someone who "could do it" and it was a wish...
>
> > Wishing is still allowed, I guess.
>
> hallo friederich dominicus
You are nto addressing the right one. Which is hardly anytime a good
idea in Newsgroups. But thanks anyway, I'll check it out too.
Regards
Friedrich
On Thu, 25 Apr 2002 16:39:52 +0200,
Rolf Mach <·····@xanalys.com> wrote:
>
> Running CAPI on Mac OS-X through LessTif/openmotiv with a resulting X Windows
> look and feel would be a solution technically within reach.
>
> However it would not meet the Mac native Aqua standard that most Mac users
> would expect for very good reasons.
>
> I wonder how many Mac aficionados would accept this?
>
Well, I for one, would really like it, as I would not have to get
used to all of that modern, resource-hungry aqua stuff and get the
nice, plain, readable, fast 2D windows, that concentrate on doing
the job instead of providing work for my hardware.
That's the same reason that I generally avoid using gnome or kde,
I am usually running just sawfish.
s.
From: Mark Coletti
Subject: Re: CAPI on Mac OS-X (was Re: Your introduction to Lisp...)
Date:
Message-ID: <GvG1nr.DnK@igsrsparc2.er.usgs.gov>
On Fri, 26 Apr 2002 01:42:22 -0400, Stefan Schmiedl wrote:
[...]
> That's the same reason that I generally avoid using gnome or kde, I am
> usually running just sawfish.
The window manager and desktop environment are orthogonal. I'm currently
running sawfish, too, and gnome. Theoretically, I could run sawfish with
KDE, too.
However, are you aware that sawfish's configuration language is LISP? In
fact, there are all sorts of nifty sawfish LISP code. E.g.,
http://www.davep.org/sawfish/
Cheers,
Mark
On Wed, 1 May 2002 17:53:07 GMT,
Mark Coletti <········@lychnobite.org> wrote:
> On Fri, 26 Apr 2002 01:42:22 -0400, Stefan Schmiedl wrote:
>
> [...]
>> That's the same reason that I generally avoid using gnome or kde, I am
>> usually running just sawfish.
>
> The window manager and desktop environment are orthogonal. I'm currently
> running sawfish, too, and gnome. Theoretically, I could run sawfish with
> KDE, too.
of course. s/just/*just*/ ... oops, sorry, wrong newsgroup ;)
>
> However, are you aware that sawfish's configuration language is LISP? In
That's the reason I chose sawfish over, say, Windowmaker and fvwm:
Lisp *and* Multiple desktops.
But I did not need to fiddle much with it, besides setting up
a menu with my personal favourite apps ...
> fact, there are all sorts of nifty sawfish LISP code. E.g.,
> http://www.davep.org/sawfish/
I'll check this one out, thanks.
s.
From: Espen Vestre
Subject: Re: CAPI on Mac OS-X (was Re: Your introduction to Lisp...)
Date:
Message-ID: <kw7kmuzyyu.fsf@merced.netfonds.no>
Rolf Mach <·····@xanalys.com> writes:
> Running CAPI on Mac OS-X through LessTif/openmotiv with a resulting X Windows
> look and feel would be a solution technically within reach.
>
> However it would not meet the Mac native Aqua standard that most Mac users
> would expect for very good reasons.
>
> I wonder how many Mac aficionados would accept this?
I guess it depends. If your alternative is to run software in SoftPC or
on a second machine, then maybe CAPI (especially if you use the newest
XDarwin with the Orobor OS X Aqua-like window manager, which is well
integrated into the OS X GUI) isn't such a pain after all.
--
(espen)
From: Espen Vestre
Subject: Re: CAPI on Mac OS-X (was Re: Your introduction to Lisp...)
Date:
Message-ID: <kw1yd2zytq.fsf@merced.netfonds.no>
Rolf Mach <·····@xanalys.com> writes:
> Running CAPI on Mac OS-X through LessTif/openmotiv with a resulting X Windows
> look and feel would be a solution technically within reach.
>
> However it would not meet the Mac native Aqua standard that most Mac users
> would expect for very good reasons.
>
> I wonder how many Mac aficionados would accept this?
I guess it depends. If your alternative is to run software in SoftPC or
on a second machine, then maybe CAPI on X11 (especially if you use the
newest XDarwin with the Orobor OS X Aqua-like window manager, which is
well integrated into the OS X GUI) isn't such a pain after all.
--
(espen)
In article <····························@posting.google.com>,
·····@norvig.com (Peter Norvig) wrote:
> And for Duane and his employer, let me say that if there was a
> standard, easy to use Common Lisp GUI package that was portable across
> Windows, several flavors of Unix, and possibly Mac, then I would never
> have started looking at Python. Really the only answer to "what can
> Python do that Lisp can't" that matters to me is "put up a window in a
> portable way".
I'm not up in Python, but I thought it could only do that by using tk --
which Lisp can use as well.
-- Bruce
Bruce Hoult wrote:
> In article <····························@posting.google.com>,
> ·····@norvig.com (Peter Norvig) wrote:
>
>> And for Duane and his employer, let me say that if there was a
>> standard, easy to use Common Lisp GUI package that was portable across
>> Windows, several flavors of Unix, and possibly Mac, then I would never
>> have started looking at Python. Really the only answer to "what can
>> Python do that Lisp can't" that matters to me is "put up a window in a
>> portable way".
>
> I'm not up in Python, but I thought it could only do that by using tk --
> which Lisp can use as well.
There are at least QT, GTK and WxWindows bindings for Python. AFAIK all of
this run on Linux and Windows.
We used Trolltech's QDesigner GUI Builder to create a Python GUI Frontend
for a Common Lisp application (visual demonstration of local optimization
techniques like Simulated Annealing and Treshold Accepting) at university.
We have done it this way because not all of the team knew Lisp and so some
could hack the GUI with Python. I was one of those who knew Lisp so besides
of creating the CL application I had to write the marshalling code for the
communication between Lisp and Python.
ciao,
Jochen
--
http://www.dataheaven.de
>... I am experimenting with Python as an alternative to Lisp for the
>implementation language for my AI text with Stuart Russell.
Please, God, NO!!! I am in just such an AI course, with your book. Our
university won't teach lisp because of pure prejudice--they still tell
people that it's only a "slow, interpreted language with too many
parentheses." I offered to teach a 1 credit Lisp course just so students
would get SOMETHING, but while my AI instructor was ecstatic, the dept.
wouldn't even waive tuition as compensation. Of course, the students
struggle horribly with the AI courses, and the fault is laid at the feet of
Lisp, rather than the department which so desperately needs a spanking.
It's so horrifying to me that I take away from my study time to help others
learn enough Lisp so see how nice it is. Once they see it, the light turns
on, but if another half-assed language is provided instead, they never ever
ever will get it.
We have to fight until the bitter end to prevent the dumbing down of CS,
so PLEASE don't make it easier for the beige-box droids to ruin everything!
I know your priorities (teaching AI) might be orthogonal to mine (teaching
that Lisp makes it all easier), but I implore you to add a chapter on Lisp
to your AI book and weave Lisp throughout your book's examples, rather than
give up on it.
FWIW,
Eric
--
"The obvious mathematical breakthrough would be development of an easy
way to factor large prime numbers."
Bill Gates, The Road Ahead, Viking Penguin (1995), page 265
"Coby Beck" <·····@mercury.bc.ca> wrote in message news:<······················@news1.calgary.shaw.ca>...
>
> Peter, you have recently been cited as an example of someone of high esteem
> in the Common Lisp world who has abandoned it, along with Paul Graham. I
> think this is fair on the surface for Mr. Graham, given his own writings and
> his focus on designing something "better".
I haven't abandoned Common Lisp. I use it as much, and like it as
little, as I ever have.
Lisp is a collection of dialects. I wrote the books about CL because
it's the standard dialect, but there is a good chunk of Scheme
(specifically, T) in _On Lisp_.
In both books I was careful to distinguish between talking about
Lisp generally and Common Lisp, though I'm not sure how many readers
notice this.
Over the last 19 years I have used (in order) InterLisp, Franz Lisp,
IQLisp, MacScheme, Lisp Machine Lisp, Vax Lisp, Common Lisp (Kyoto,
Lucid, MCL, and CLisp), T, Scheme 48, and Arc.
It's Lisp I like, not CL. I think CL is pretty ugly and always have.
My favorite dialect of Lisp is T, which was developed (mostly) by
Jonathan Rees at Yale in the early 80s. T is the language Common
Lisp should have been.
If CL is ugly, why do I use it and write about it? Because Lisp
is so powerful that even an ugly Lisp is preferable to using some
other language.
--pg
On 30 Apr 2002 10:06:10 -0700,
Paul Graham <····@bugbear.com> wrote:
> "Coby Beck" <·····@mercury.bc.ca> wrote in message news:<······················@news1.calgary.shaw.ca>...
>
> It's Lisp I like, not CL. I think CL is pretty ugly and always have.
> My favorite dialect of Lisp is T, which was developed (mostly) by
> Jonathan Rees at Yale in the early 80s. T is the language Common
> Lisp should have been.
>
I just googled T and got 293,000,000 results back ...
Finally I found an entry in the directory at
http://directory.google.com/Top/Computers/Programming/
Languages/Lisp/Scheme/Implementations/
in the lower part:
T 3.1 ftp://ftp.cs.indiana.edu/pub/scheme-repository/imp/t/
T is a Scheme-like language developed at Yale.
It is to Scheme approximately like NIL is to Lisp.
Primarily of interest to historians and theoreticians.
If we are talking about the same language, it is well hidden ...
which makes me curious:
If you searched the Net for T, how would you proceed?
Regards,
S.
From: Eric Hanchrow
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <87n0vlvttg.fsf@blarg.net>
sort of related:
I am working on a project which is based on scheme.
I had looked at t.
since t is generally a dead langauge I will probably continue to design a
scheme system and use t as a source of design decisions...
mostly: far more people probably know scheme than t; hopefully design work
would be picked up by someone again before I would decide to use it.
it looks for the most part very similar to scheme anyways...
any comments?...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
From: Christopher Browne
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <m3pu0c4s5m.fsf@chvatal.cbbrowne.com>
Oops! cr88192 <·······@hotmail.com> was seen spray-painting on a wall:
> sort of related:
> I am working on a project which is based on scheme.
> I had looked at t.
> since t is generally a dead langauge I will probably continue to design a
> scheme system and use t as a source of design decisions...
> mostly: far more people probably know scheme than t; hopefully design work
> would be picked up by someone again before I would decide to use it.
> it looks for the most part very similar to scheme anyways...
>
> any comments?...
If the licensing of the code that's out there is compatible with your
needs, there might even be some useful code there.
If there's something useful to learn from it, it would be, by all
means, a great idea to bring some ideas back from it.
I would speculate that one could easily make a quasi-academic
computing career out of mining ideas from such "dead" systems as:
- Multics
- T
- Algol 60 and Algol 68
- CLOS
- PL/1
- Ada
- APL
[Anyone so humourless that they get their nose out of joint out of
their favorite thing being described as dead can feel free to "eat my
shorts," to use The Bart's phrase...]
--
(reverse (concatenate 'string ········@" "enworbbc"))
http://www.cbbrowne.com/info/linuxdistributions.html
I always try to do things in chronological order.
Christopher Browne wrote:
> Oops! cr88192 <·······@hotmail.com> was seen spray-painting on a wall:
>> sort of related:
>> I am working on a project which is based on scheme.
>> I had looked at t.
>> since t is generally a dead langauge I will probably continue to design a
>> scheme system and use t as a source of design decisions...
>> mostly: far more people probably know scheme than t; hopefully design
>> work would be picked up by someone again before I would decide to use it.
>> it looks for the most part very similar to scheme anyways...
>>
>> any comments?...
>
> If the licensing of the code that's out there is compatible with your
> needs, there might even be some useful code there.
>
> If there's something useful to learn from it, it would be, by all
> means, a great idea to bring some ideas back from it.
>
> I would speculate that one could easily make a quasi-academic
> computing career out of mining ideas from such "dead" systems as:
>
> - Multics
> - T
> - Algol 60 and Algol 68
> - CLOS
> - PL/1
> - Ada
> - APL
>
> [Anyone so humourless that they get their nose out of joint out of
> their favorite thing being described as dead can feel free to "eat my
> shorts," to use The Bart's phrase...]
I think there is a bit of sarcasm here, I had just thought t *was* a dead
language.
I didn't mean any insult, and I recognize some of the others as still being
*alive*. I didn't mean to seem like I was trolling. the context of the
nearby posts made me think such.
I was meaning that I think it is a more defined scheme and looked as if it
had good design choices, so on development of my project I will consider
what they did there. so on I consider other things: mzscheme, guile, cl.
for more general design issues if possible I look to tunes.
misc: does anyone think it might be possibly useful to use a basic type
syntax on top of a scheme like core?
I just figure it might be more attractive looking to the masses (who have a
bias against/not heard of lisp), and could possibly be more accessible (to
newbies) than python... or is this just stupid.
(just in my mind python "looks" harder than basic, and I figure that of
possible realavance), or will those who don't know programming continue to
not learn?...
I have tried on several occasions to get my girlfriend to learn *some*
programming language with no success as of yet... maybe if there were some
way to make it less intimidating or something...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
From: Christopher Browne
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <m3elgs4jwt.fsf@chvatal.cbbrowne.com>
In an attempt to throw the authorities off his trail, cr88192 <·······@hotmail.com> transmitted:
> Christopher Browne wrote:
>
>> Oops! cr88192 <·······@hotmail.com> was seen spray-painting on a wall:
>>> sort of related:
>>> I am working on a project which is based on scheme.
>>> I had looked at t.
>>> since t is generally a dead langauge I will probably continue to design a
>>> scheme system and use t as a source of design decisions...
>>> mostly: far more people probably know scheme than t; hopefully design
>>> work would be picked up by someone again before I would decide to use it.
>>> it looks for the most part very similar to scheme anyways...
>>>
>>> any comments?...
>>
>> If the licensing of the code that's out there is compatible with your
>> needs, there might even be some useful code there.
>>
>> If there's something useful to learn from it, it would be, by all
>> means, a great idea to bring some ideas back from it.
>>
>> I would speculate that one could easily make a quasi-academic
>> computing career out of mining ideas from such "dead" systems as:
>>
>> - Multics
>> - T
>> - Algol 60 and Algol 68
>> - CLOS
>> - PL/1
>> - Ada
>> - APL
>>
>> [Anyone so humourless that they get their nose out of joint out of
>> their favorite thing being described as dead can feel free to "eat my
>> shorts," to use The Bart's phrase...]
>
> I think there is a bit of sarcasm here, I had just thought t *was* a dead
> language.
The sarcasm hasn't at all to do with T... Just wait and see if anyone
writes anything outraged...
> I didn't mean any insult, and I recognize some of the others as still being
> *alive*. I didn't mean to seem like I was trolling. the context of the
> nearby posts made me think such.
No insult intended. All of the above _are_ likely to be widely
considered to be "dead" systems, irrespective of there being small
hotbeds of suage.
> I was meaning that I think it is a more defined scheme and looked as if it
> had good design choices, so on development of my project I will consider
> what they did there. so on I consider other things: mzscheme, guile, cl.
> for more general design issues if possible I look to tunes.
Tunes seems tremendously wishful; you're likely to learn more lessons
from something that actually got implemented than from something
that's still being designed.
> misc: does anyone think it might be possibly useful to use a basic type
> syntax on top of a scheme like core?
If you're thinking "that different," I'd suggest instead that you
consider looking at the ML family...
> I just figure it might be more attractive looking to the masses (who
> have a bias against/not heard of lisp), and could possibly be more
> accessible (to newbies) than python... or is this just stupid.
It's much better to do what _you_ want, and have something that is
actually implemented, than to try to pick things based on what other
people _might_ want.
> (just in my mind python "looks" harder than basic, and I figure that
> of possible realavance), or will those who don't know programming
> continue to not learn?...
I'd think the latter to be more likely...
> I have tried on several occasions to get my girlfriend to learn
> *some* programming language with no success as of yet... maybe if
> there were some way to make it less intimidating or something...
It is readily arguable that programming isn't intimidating enough, and
is attracting too many people that figure that they can study "Java in
24 Hours" or some such rot and become a "Professional Programmer."
That's a controversial position, to be sure. That doesn't make the
position wrong.
--
(reverse (concatenate 'string ········@" "enworbbc"))
http://www.ntlug.org/~cbbrowne/sgml.html
God is dead. -Nietszche
Nietszche is dead. -God
>
> The sarcasm hasn't at all to do with T... Just wait and see if anyone
> writes anything outraged...
>
?...
>> I didn't mean any insult, and I recognize some of the others as still
>> being *alive*. I didn't mean to seem like I was trolling. the context of
>> the nearby posts made me think such.
>
> No insult intended. All of the above _are_ likely to be widely
> considered to be "dead" systems, irrespective of there being small
> hotbeds of suage.
>
ok.
>> I was meaning that I think it is a more defined scheme and looked as if
>> it had good design choices, so on development of my project I will
>> consider what they did there. so on I consider other things: mzscheme,
>> guile, cl. for more general design issues if possible I look to tunes.
>
> Tunes seems tremendously wishful; you're likely to learn more lessons
> from something that actually got implemented than from something
> that's still being designed.
>
hmm, good pointers in this respect?
even though it is highly wishful it did have a few helpful ideas.
>> misc: does anyone think it might be possibly useful to use a basic type
>> syntax on top of a scheme like core?
>
> If you're thinking "that different," I'd suggest instead that you
> consider looking at the ML family...
>
maybe I will. as far as I know ml was related to the pascal family, but
nothing really more than that.
>> I just figure it might be more attractive looking to the masses (who
>> have a bias against/not heard of lisp), and could possibly be more
>> accessible (to newbies) than python... or is this just stupid.
>
> It's much better to do what _you_ want, and have something that is
> actually implemented, than to try to pick things based on what other
> people _might_ want.
>
what I want is probably not what the masses want, and what I want is what I
am writting.
>> (just in my mind python "looks" harder than basic, and I figure that
>> of possible realavance), or will those who don't know programming
>> continue to not learn?...
>
> I'd think the latter to be more likely...
>
well, this is probably over optimistic, but I would hope for a time where
almost everyone is at least a "competent" programmer (in the same respect
you can consider someone in hs "competent" in math).
not that they would be very good, just that if really needed they could
beat something out...
>> I have tried on several occasions to get my girlfriend to learn
>> *some* programming language with no success as of yet... maybe if
>> there were some way to make it less intimidating or something...
>
> It is readily arguable that programming isn't intimidating enough, and
> is attracting too many people that figure that they can study "Java in
> 24 Hours" or some such rot and become a "Professional Programmer."
>
> That's a controversial position, to be sure. That doesn't make the
> position wrong.
well, the idea that someone can just read a book and be "professional"
seems silly. but I would hope that more in general people would try to pick
up programming.
or hell at least be "competent" users...
the school's "computer" classes are horrid, not much higher than the typing
classes. in one they teach how to type, in another the how semester is
spent focusing on ms-word.
not once do the mention the "filesystem" or even "control panel", nor do
they explain anything beyond a "to do this then do this" type fashion...
then at the end they explain excel and powerpoint... as if those give "real
computing competence".
I hold a similar oppinion for the math classes...
a number of months ago I gave my girlfriend a book about c, ever since she
has not really been interested in programming...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
From: Thien-Thi Nguyen
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <kk9offvd1bu.fsf@glug.org>
Christopher Browne <········@acm.org> writes:
> hotbeds of suage.
typo or pun? "suage: usage gone bad"
thi
From: Christopher Browne
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <m37kmj33mt.fsf@chvatal.cbbrowne.com>
In the last exciting episode, Thien-Thi Nguyen <···@glug.org> wrote::
> Christopher Browne <········@acm.org> writes:
>
>> hotbeds of suage.
>
> typo or pun? "suage: usage gone bad"
Apparently it's _usable_ both ways...
[Rim-shot...]
--
(concatenate 'string "aa454" ·@freenet.carleton.ca")
http://www3.sympatico.ca/cbbrowne/finances.html
I can see clearly now, the brain is gone...
From: Thien-Thi Nguyen
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <kk9r8krd1eo.fsf@glug.org>
cr88192 <·······@hotmail.com> writes:
> (just in my mind python "looks" harder than basic, and I figure that of
> possible realavance), or will those who don't know programming continue to
> not learn?...
"learning" is the practice of programming yourself. if people don't like
learning (or their cultural institutions are successful in beating this
natural desire out of them), it is unlikely they will like getting into the
programming mindset. how do you propose to improve society w/ your project?
thi
Thien-Thi Nguyen wrote:
> cr88192 <·······@hotmail.com> writes:
>
>> (just in my mind python "looks" harder than basic, and I figure that of
>> possible realavance), or will those who don't know programming continue
>> to not learn?...
>
> "learning" is the practice of programming yourself. if people don't like
> learning (or their cultural institutions are successful in beating this
> natural desire out of them), it is unlikely they will like getting into
> the
> programming mindset. how do you propose to improve society w/ your
> project?
>
well these comments were not directly related to my project. however in my
project (assuming people actually use it). there will be enough exposure to
the programming side of things (in a not scarry manner) that hopefully
people would pick up on it.
worth noting is that if it were not seing batch files and later seeing
basic then I probably would not have learned programming, it was a "see:
understand" type process.
given if more people "see" it then maybe more people will learn...
for this to work well the language would probably need an "obvious"
syntax... in my mind basic and batch sort of fulfilled this (better than
say: shellscripts and perl...).
otherwise I am more focusing on the technical side of things...
--
<·······@hotmail.com> <http://bgb1.hypermart.net/>
From: Kenny Tilton
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <3CCEFC19.F9798F0F@nyc.rr.com>
Stefan Schmiedl wrote:
> If you searched the Net for T, how would you proceed?
First I tried "T", but that matched the t in "didn't work".
Adding spaces " T " didn'"t" help.
"T language" turned up a passing reference which mentioned Yale (as did
the OP, so I should have had that in there from the get go.
Searching on: "T programming" Yale
...did pretty good.
--
kenny tilton
clinisys, inc
---------------------------------------------------------------
"Harvey has overcome not only time and space but any objections."
Elwood P. Dowd
The world rejoiced as Stefan Schmiedl <·@xss.de> wrote:
> On 30 Apr 2002 10:06:10 -0700,
> Paul Graham <····@bugbear.com> wrote:
>> "Coby Beck" <·····@mercury.bc.ca> wrote in message news:<······················@news1.calgary.shaw.ca>...
>>
>> It's Lisp I like, not CL. I think CL is pretty ugly and always have.
>> My favorite dialect of Lisp is T, which was developed (mostly) by
>> Jonathan Rees at Yale in the early 80s. T is the language Common
>> Lisp should have been.
>>
>
> I just googled T and got 293,000,000 results back ...
> Finally I found an entry in the directory at
>
> http://directory.google.com/Top/Computers/Programming/
> Languages/Lisp/Scheme/Implementations/
>
> in the lower part:
>p
> T 3.1 ftp://ftp.cs.indiana.edu/pub/scheme-repository/imp/t/
> T is a Scheme-like language developed at Yale.
> It is to Scheme approximately like NIL is to Lisp.
> Primarily of interest to historians and theoreticians.
>
> If we are talking about the same language, it is well hidden ...
> which makes me curious:
>
> If you searched the Net for T, how would you proceed?
I'd search for "yale t scheme" which gets me rather close.
The project apparently ended a dozen years ago, so for there to be
something of a lack of heavy linkages to it would coma as little
surprise..
--
(reverse (concatenate 'string ········@" "enworbbc"))
http://www.cbbrowne.com/info/lsf.html
"Of course, to join the NSA, all you really have to do is pick up any
phone, anywhere, make a long-distance call, and say `National Security
Agency, I'd like a job.' They'll check you out and either give you a
job, or do a job on you." -- David Palmer
From: Chris Double
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <uoffxah0b.fsf@double.co.nz>
Christopher Browne <········@acm.org> writes:
> The project apparently ended a dozen years ago, so for there to be
> something of a lack of heavy linkages to it would coma as little
> surprise..
Almost everything you ever wanted to know about the history of T was
posted to the little languages list a while back. Makes interesting
reading:
http://www.public.asu.edu/~sthaiyar/books-articles/shivers-history.txt
Chris
--
http://www.double.co.nz/cl
From: Tim Moore
Subject: Re: Searching for T, (was: Re: Your introduction to Lisp...)
Date:
Message-ID: <aaufmm$49$0@216.39.145.192>
On 03 May 2002 18:21:24 +1200, Chris Double <·····@double.co.nz> wrote:
>Christopher Browne <········@acm.org> writes:
>
>> The project apparently ended a dozen years ago, so for there to be
>> something of a lack of heavy linkages to it would coma as little
>> surprise..
>
>Almost everything you ever wanted to know about the history of T was
>posted to the little languages list a while back. Makes interesting
>reading:
>
>http://www.public.asu.edu/~sthaiyar/books-articles/shivers-history.txt
Is there a "big languages" list?
Tim
"Tim Moore" <······@sea-tmoore-l.dotcast.com> wrote in message ················@216.39.145.192...
>
> Is there a "big languages" list?
>
The list of languages here is pretty big....
http://99-bottles-of-beer.ls-la.net/
Stefan Schmiedl <·@xss.de> writes:
> Paul Graham <····@bugbear.com> wrote:
>
> > It's Lisp I like, not CL. I think CL is pretty ugly and always have.
> > My favorite dialect of Lisp is T, which was developed (mostly) by
> > Jonathan Rees at Yale in the early 80s. T is the language Common
> > Lisp should have been.
>
> I just googled T and got 293,000,000 results back ...
Sometimes we also called it TEA (for "T with Extended Acronym") so no
one could complain about the one-letter-ness... heh.
I can't remember whose bright idea this was, but something vaguely
says maybe McDermott's?
No, don't bother checking Google for this; you'll not find anything
useful this way. I mentioned this just for grins....
* Paul Graham
| If CL is ugly, why do I use it and write about it? Because Lisp is so
| powerful that even an ugly Lisp is preferable to using some other
| language.
What a great marketing line!
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Erik Naggum <····@naggum.net> wrote in message news:<················@naggum.net>...
> * Paul Graham
> | If CL is ugly, why do I use it and write about it? Because Lisp is so
> | powerful that even an ugly Lisp is preferable to using some other
> | language.
>
> What a great marketing line!
>
That's kinda like saying: Use Lisp! It sucks less!
I *really* want to see that on a commercial vendors website. ;)
Damond
·······@syncreticsoft.com (Damond Walker) writes:
> Erik Naggum <····@naggum.net> wrote in message news:<················@naggum.net>...
> > * Paul Graham
> > | If CL is ugly, why do I use it and write about it? Because Lisp is so
> > | powerful that even an ugly Lisp is preferable to using some other
> > | language.
> >
> > What a great marketing line!
> >
>
> That's kinda like saying: Use Lisp! It sucks less!
>
> I *really* want to see that on a commercial vendors website. ;)
Amusingly a quick google shows that the office suite siag has as it's
motto "It Sucks Less!". Siag is written in.... scheme. Oh well.
Cheers,
M.
--
For their next act, they'll no doubt be buying a firewall
running under NT, which makes about as much sense as
building a prison out of meringue. -- -:Tanuki:-
-- http://home.xnet.com/~raven/Sysadmin/ASR.Quotes.html
Paul Graham wrote:
>
> In both books I was careful to distinguish between talking about
> Lisp generally and Common Lisp, though I'm not sure how many readers
> notice this.
With a book title like "ANSI common lisp" a reader will sure assume that
you talking about common lisp at all ;-) However, IMHO a great book for
beginners.
>
> Over the last 19 years I have used (in order) InterLisp, Franz Lisp,
> IQLisp, MacScheme, Lisp Machine Lisp, Vax Lisp, Common Lisp (Kyoto,
> Lucid, MCL, and CLisp), T, Scheme 48, and Arc.
>
Is Arc now ready for tests ? Which plattforms are currently supported ?
Best regards
AHz
...down memory lane.
The "Artificial Intelligence" course in the third year at the
University of Milan was taught two hour on Thursday and two hours on
Saturday morning starting at 8:30.
Since we had to work on "AI" we learned a Lisp. The one available was
VLisp (a precursor of LeLisp) on Z8000 UNIX v7 boxes with 512K of
memory shared by a bunch of students.
The first thing I did was a translator from FOL wff's to fully
skolemized form.
What really really got me going was the fact that you did not have to
write a parser for a new language. It was just way too cool.
Previously I had been exposed to Pascal, C, (some preliminary) Ada and
a lot of Shell/Unix stuff.
I took it from there.
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
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
·······@syncreticsoft.com (Damond Walker) writes:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
Some of you have heard some of my story already; I related most of
it at the 1998 LUGM.
I have decided to organize my story recursively, because in order
to understand how I came to Lisp, you must first understand how
I came to Software:
I was a Hardware Engineer, working mostly in the testing
industry. But you must first understand how I came to
Hardware Testing:
I was a Music Major, going for a teaching credential. But
first you must understand how I decided to major in music:
I was both a hobbyist and a musician, playing instruments
and carrying on science experiments since 5 years old. I
got pretty good at piano, but it was a time drain, so I
convinced my Mom (who was a piano teacher until just last
year) to let me drop it in 3rd grade. She agreed if I
continued on with my trumpet, which I still play.
My science experiments included all kinds of inventions,
including electronics, but when I discovered the wonders
of digital logic, I was hooked. In 7th grade (age 12) I
entered a Science Fair and won first prize. I had built
(with my Dad's help) a discrete-DTL (diode-transistor-logic)
four-bit adder. It worked, too, until just before the fair,
when the diodes started blowing out because of too much
current. I was frantically ganging up diodes in parallel,
and by the time the judges came around, only two stages (bits)
worked. But I knew my stuff, and they gave me the prize anyway.
My high school career was also taken in parallel with both
Band/Orchestra and math/science. In math class, we got to
go to a place where they had several teletypes set up to log
in to the Westinghouse Tymshare system, and we learned Basic.
I also learned how to program on an HP calculator; this one
had a card reader and had to be carted around on an Audio-Visual
cart, it was so big.
But high school being what it was, the stigma of being a nerd
took its toll, and I got contact lenses, grew my hair out, and
decided to become a Music Teacher instead of a scientist. And
that's how I came to be a Music Major.
As a Music Major, I had to work in order to pay tuition, so my Dad
got me a job as a tester/technician in his Company, and I started
working my way up. After almost four years of 1-unit music courses
(for example, Marching Band met Monday, Wednesday, Friday for two
hours each, and we were to be at every home football game - how
many units was this class? Just one!) I realized that I could
finish up my college career faster by switching my major to what
I had been minoring in (math) and besides, my employer would pay
tuition for a math degree, but not a music degree. So I switched,
and was out in a year and a half. Once I graduated, the Personnel
Department had the paper they needed to make me into a Real Engineer.
And that's how I became a Hardware Test Engineer.
As an Engineer in Testing, I had to understand all disciplines; it
is not as glamorous a job as being in the Development group, but I
recommend it for anyone who wants to be well-rounded in the Computer
Industry. In order to know how to test, I had to know how to design,
manufacture, and break (!) things. I had to understand Reliability
issues, how the product's and testers' software worked, and by the
time I got to the mainframe company I worked for, I had to understand
how the chip manufacturing process worked. During that time, I worked
out a GFI (guided-fault-isolation) system that was data-driven from
the circuit-board's database, which runs through the tests over and
over again and guiding the test operator back to where the failure
is occurring. It is a simple algorithm, but to the casual observer
it looks a lot like AI. Also by that time, I was doing very little
soldering and a lot of typing. And that is how I came to Software...
As my last hardware employer started preparing for their largest and
densest product yet, it became evident that the chips were going to
be impossible to probe, and real AI would be necessary. I had heard
about Lisp, but had no idea what the big deal was. The parens didn't
bother me, they just looked wierd to me. A group of us got together
once a week and formed an AI club, where we discussed the issues of
AI and how we could use it.
Then one day during an AI club meeting a guy walked in with a tape
of Franz Lisp from the Berkeley Software Distribution (BSD), and asked
if anyone wanted to try to port it to our version of Unix (at the time
Franz Lisp had only been ported to Vax and 68k). So I volunteered
to give it a shot. I viewed a port to be the best way to find out
just what the big deal was about Lisp, anyway. So I ported it, and
became thoroughly hooked. I went to our software/operating-system
department, thinking that we could sell this as a product. But they
discouraged me from that, since we were a Hardware company, and didn't
know how to sell Software. The manager of the operating-system group
said that he knew of a new little company that had just started up
to port FranzLisp to other platforms (it was called Franz, Inc),
and that I should meet them. And what do you think happened next? ...
--
Duane Rettig Franz Inc. http://www.franz.com/ (www)
1995 University Ave Suite 275 Berkeley, CA 94704
Phone: (510) 548-3600; FAX: (510) 548-8253 ·····@Franz.COM (internet)