Hello all!
Can anyone recommend a good book to learn lisp/clos from? I am using
Graham's "ANSI Common Lisp", but find it very unclear - many of the
appendix d list of commands seem to take some kind of undefined
variables. Maybe that comes from the power of the language, but it sure
puts up stumbling blocks to newbies.
tia.
On Mon, 12 Apr 1999 22:21:35 -0500, Craig Ewert
<········@mailc.starnetinc.com> posted:
>Can anyone recommend a good book to learn lisp/clos from? I am using
>Graham's "ANSI Common Lisp", but find it very unclear - many of the
>appendix d list of commands seem to take some kind of undefined
>variables. Maybe that comes from the power of the language, but it sure
>puts up stumbling blocks to newbies.
You're expecting more of the book than it can provide without quite
literally doubling its size.
Find yourself a copy of the Hyperspec,
<http://www.harlequin.com/books/HyperSpec/> a document that is a detailed
reference to the Common LISP standard, which is doubtless what you're
looking for.
The material in the appendices of Graham's book will leave some open
questions; when you think you need answers, the Hyperspec can provide
answers.
--
Those who do not understand Unix are condemned to reinvent it, poorly.
-- Henry Spencer <http://www.hex.net/~cbbrowne/lsf.html>
········@hex.net - "What have you contributed to free software today?..."
········@news.brownes.org (Christopher B. Browne) writes:
> On Mon, 12 Apr 1999 22:21:35 -0500, Craig Ewert
> <········@mailc.starnetinc.com> posted:
> >Can anyone recommend a good book to learn lisp/clos from? I am using
> >Graham's "ANSI Common Lisp", but find it very unclear - many of the
> >appendix d list of commands seem to take some kind of undefined
> >variables. Maybe that comes from the power of the language, but it sure
> >puts up stumbling blocks to newbies.
it's an appendix. it's there as a reference, not a tutorial like the
main body of the book.
> You're expecting more of the book than it can provide without quite
> literally doubling its size.
>
> Find yourself a copy of the Hyperspec,
> <http://www.harlequin.com/books/HyperSpec/> a document that is a detailed
> reference to the Common LISP standard, which is doubtless what you're
> looking for.
however, if the person is having difficulty with grahams's appendix d,
how can the hyperspec help? it's much the same information presented
in a similar cryptic code of nomenclature. i am not trying to
disparage the hyperspec -- it's been very helpful to me, but sometimes
i do not understand what it is talking about simply because the lisp
argot is unfamiliar to me.
> The material in the appendices of Graham's book will leave some open
> questions; when you think you need answers, the Hyperspec can provide
> answers.
however, there are a whole lot of simple questions not addressed by
either graham or the hyperspec. examples:
how do i work with lisp? it's not like C, fortran, pascal, ada, algol
&c where i compile, link and get a stand alone executable.
how do i run the lisp listener? where is the pointer to use emacs and
an inferior lisp process?
does hyperspec have a description of how you go about actually working
with lisp? a discussion of what method do you use to work with lisp,
write a file, compile file, direct input to lisp listener, some
mixture of the these could be helpful.
how do i build a bigger lisp program? how can i give the finished
program to a friend to run?
these are all important questions and depend greatly on your platform
and lisp vendor/implementation. vendor docs help. these little low
level nits frustrated me to no end while trying to learn lisp.
sometimes a little bit of hand-holding really does help.
--
johan kullstam
Johan Kullstam wrote in message ...
>however, there are a whole lot of simple questions not addressed by
>either graham or the hyperspec. examples:
>
>how do i work with lisp? it's not like C, fortran, pascal, ada, algol
>&c where i compile, link and get a stand alone executable.
>
>how do i run the lisp listener? where is the pointer to use emacs and
>an inferior lisp process?
>
>does hyperspec have a description of how you go about actually working
>with lisp? a discussion of what method do you use to work with lisp,
>write a file, compile file, direct input to lisp listener, some
>mixture of the these could be helpful.
>
>how do i build a bigger lisp program? how can i give the finished
>program to a friend to run?
>
>these are all important questions and depend greatly on your platform
>and lisp vendor/implementation. vendor docs help. these little low
>level nits frustrated me to no end while trying to learn lisp.
>sometimes a little bit of hand-holding really does help.
I've never seen a real clear introduction from a system operation point of
view. Most every Lisp book I've seen starts at the '>' prompt and moves from
there. Even vendor documentation doesn't really provide good introductions
from what I've seen.
It appears to me that most of those skills are learned from a layer of
folklore about "how Lisp is used". About the most major thing that I've
figured out about using Lisp systems is "Step 0 - Learn, Live, Love Emacs".
Even the Harlequin Lispworks for Windows is essentially an Emacs interface.
Which can be quite befuddling. Emacs may be "self-documenting" and
"extensible", but it's certainly not intuitive.
There isn't much documentation or even discussion of Lisp Use idioms. Much
like the other thread on "Spontaneous Bad Habits", when folks are
essentially fending for themselves with little guidance, horrible (or even
innovative depending on your point of view) things can happen.
It also doesn't help when you bring along a whole history of baggage from
other environments and try to pound your C shaped habits into an L shaped
hole.
I'd love to see a primer on packages, "eval-when", project structure etc, as
well as a sort of tutorial on the EMacs listener and its wonders.
How often do people restart their images during development? How often you
reload files? Packages? Entire source trees? comapred to Ctrl-C-E
everything.
I think a lot of this can be fairly implementation independant.
Will Hartung
(·····@msoft.com)
Will Hartung <············@msoft.com> wrote:
> Johan Kullstam wrote in message ...
>>however, there are a whole lot of simple questions not addressed by
>>either graham or the hyperspec. examples:
>>
>>how do i work with lisp? it's not like C, fortran, pascal, ada, algol
>>&c where i compile, link and get a stand alone executable.
An analogy in a post by Erik Naggum some 3 months ago has helped
me a lot (searched briefly but didn't find it on DejaNews)---basically
that a running Lisp image can be compared to a live filesystem and the
defined functions are akin to executables on disk. A paragraph or two
presenting this idea would make a good introduction for a "beginner's
guide to Lisp" imho; it would alert the reader to be aware of his
semi-conscious preconceptions about how things are done and organized.
[...]
>>does hyperspec have a description of how you go about actually working
>>with lisp? a discussion of what method do you use to work with lisp,
>>write a file, compile file, direct input to lisp listener, some
>>mixture of the these could be helpful.
As much as these are needed, I do not think this information would
fit in the HyperSpec. I see the HyperSpec as something that I will
refer to as long as I program in Lisp and appreciate its very terse,
to-the-point nature. Explanations of how to work in Lisp are handy
at one point (the move verbose and hand-holding the better), but then
this information becomes second nature, just like the Emacs tutorial
describing the intricacies of file finding and buffer switching is
very necessary at the beginning, but unneeded from then on.
>>how do i build a bigger lisp program? how can i give the finished
>>program to a friend to run?
[big snip]
> I'd love to see a primer on packages, "eval-when", project structure etc, as
> well as a sort of tutorial on the EMacs listener and its wonders.
Me too! The skillset equivalent to writing Makefiles and the
"./configure && make && make install" process: How do I package
something up so that somebody else can get it running with minimum
effort?
> How often do people restart their images during development? How often you
> reload files? Packages? Entire source trees? comapred to Ctrl-C-E
> everything.
I can imagine that the biggest obstacle for the creation of
such a primer is that these things become so obvious and second-nature
after a while that the feeling is "Nobody is so stupid as having to be
told *that*!" At the moment, I am in the middle of this learning
process (as some others here seem to be), but my problem is not that I
do not get answers, but that I cannot even ask good, to-the-point
questions. [Side remark: isn't it the work of a knowledge engineer
to extract all the subconscious, basic rules-of-thumb and things-that-
everyone-knows from the expert?] Not that I want to complain, I am
enjoying myself very much.
I will keep a diary from now on to keep hold of these little
insights, instead of letting them sink in and be forgotten. Perhaps
it will spontaneously evolve into a little primer. If you have a
paragraph or two to share or ideas what should be included, send them
to me and I will certainly collect and arrange everything and post it
or make it downloadable when it is large enough.
Rudi
"Will Hartung" <············@msoft.com> writes:
> I'd love to see a primer on packages, "eval-when", project structure etc, as
> well as a sort of tutorial on the EMacs listener and its wonders.
>
> How often do people restart their images during development? How often you
> reload files? Packages? Entire source trees? comapred to Ctrl-C-E
> everything.
Yes, I think that this is an area of Lisp that is sorely lacking
written texts. It seems to me that in the past there were 2 or 3
books on these topics, but all of them are currently out of print, and
have been for some time. I think in most other areas, we have are
quite well equipped with books, which aren't that numerous but are
mostly of high quality.
Regs, Pierre.
(this is a short me, too message, since I'm too tired to write
coherent sentences ;)
--
Pierre Mai <····@acm.org> http://home.pages.de/~trillian/
"One smaller motivation which, in part, stems from altruism is Microsoft-
bashing." [Microsoft memo, see http://www.opensource.org/halloween1.html]
On Thu, 15 Apr 1999 21:11:01 GMT, "Will Hartung" <············@msoft.com>
wrote:
> Which can be quite befuddling. Emacs may be "self-documenting" and
> "extensible", but it's certainly not intuitive.
The book "Writing GNU Emacs Extensions - Editor Customizations and
Creations with Lisp" by Bob Glickstein (O'Reilly, 1997; ISBN
1-56592-261-1), which deals with version 19, may shed some light on the
customization issue.
Paolo
--
Paolo Amoroso <·······@mclink.it>
In article <·················@mailc.starnetinc.com>,
Craig Ewert <········@mailc.starnetinc.com> wrote:
> Hello all!
>
> Can anyone recommend a good book to learn lisp/clos from? I am using
> Graham's "ANSI Common Lisp", but find it very unclear - many of the
> appendix d list of commands seem to take some kind of undefined
> variables. Maybe that comes from the power of the language, but it sure
> puts up stumbling blocks to newbies.
>
You could try Peter Norvig's book "Paradigms in AI programming: case studies
in common lisp" (or something like that anyway) and for a good clos intro:
Sonya Keene's "Object-oriented programming in common lisp".
If you are particulary interested in clos then I'd also recommend having a
look through Kiczales, de Rivieres and Bobrow: "The art of the metaobject
protocol". Some of it may seem a bit opaque, but I think it still contains
some accessible and useful stuff for newcomers to clos.
-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/ Search, Read, Discuss, or Start Your Own
··········@scientia.com wrote:
> In article <·················@mailc.starnetinc.com>,
> Craig Ewert <········@mailc.starnetinc.com> wrote:
> > Hello all!
> >
> > Can anyone recommend a good book to learn lisp/clos from? I am using
> > Graham's "ANSI Common Lisp", but find it very unclear - many of the
> > appendix d list of commands seem to take some kind of undefined
> > variables. Maybe that comes from the power of the language, but it sure
> > puts up stumbling blocks to newbies.
> >
>
> You could try Peter Norvig's book "Paradigms in AI programming: case studies
> in common lisp" (or something like that anyway) and for a good clos intro:
> Sonya Keene's "Object-oriented programming in common lisp".
>
> If you are particulary interested in clos then I'd also recommend having a
> look through Kiczales, de Rivieres and Bobrow: "The art of the metaobject
> protocol". Some of it may seem a bit opaque, but I think it still contains
> some accessible and useful stuff for newcomers to clos.
>
Talking about AI-oriented and advanced books, I see there's now
a 2nd edition of "Artificial Intelligence Programming" by Charniak,
which has been rewritten using CL.
I used this book over 10 years ago, and it was really cool (I had not
seen TMS code in any other one at the time).
--
Fernando D. Mato Mira
Real-Time SW Eng & Networking
Advanced Systems Engineering Division
CSEM
Jaquet-Droz 1 email: matomira AT acm DOT org
CH-2007 Neuchatel tel: +41 (32) 720-5157
Switzerland FAX: +41 (32) 720-5720
www.csem.ch www.vrai.com ligwww.epfl.ch/matomira.html
Craig Ewert wrote:
....
> Can anyone recommend a good book to learn lisp/clos from? I am using
> Graham's "ANSI Common Lisp", but find it very unclear - many of the
> appendix d list of commands seem to take some kind of undefined
> variables. Maybe that comes from the power of the language, but it sure
> puts up stumbling blocks to newbies.
I don't think you are supposed to learn lisp/clos from "Appendix D".
It is an abbreviated reference manual. The "beginning" of the
book is where you will "learn" lisp from. Appendix D isn't a guide for
those you don't know Common Lisp. It is for folks who already know
some lisp and need to know more ( or remember what they forgot).
I think "newbies" tend to grab at too much Common Lisp in the beginning.
Rummaging through Appendix D looking at all the myriad of optional
features isn't productive for "newbies".
In addition to the HyperSpec suggestion from another response, I would
suggest that the book's index holds more learning utility than Appendix D.
Like "keyword" and "optional" arguments. The HyperSpec is mainly helpful
because there are examples for each. It isn't going to "teach" you
lisp/clos either.