I was thinking about buying Lisp In Small Pieces? and Escentials of
Programming Languages? How good are these books. I already know
Lisp/Scheme but wanted to learn about how to write compilers in Lisp,
and how to write a Lisp compiler. As these are pricey books; how
helpful would these be? How does Anatomy of Lisp compair to the above
books?
I am also intrested in writing Lisp in Lisp, Reflexive or Metacircular
compilers--are there any books about such topics. I liked some papers
I've read in 'Lisp Ponters' (Does the 'zein still exist?) about
implementing Lisp Special-Forms as Lisp Macros.
I also liked in ANSI CL how Paul Grham wrote the basic Lisp functions
in Lisp. Is there a book about how to create a Lisp-kernal (microcode
compiler, base functions) and write an entire ANSI CL on top of it.
(Or, compiling Scheme on top of a kernal, because it is a smaller
language.)
Is there a book about implementing ANSI CL ontop of Scheme. Peter
Novig wrote about implementing Scheme in ANSI CL in his Paradigms of
Artificial Intelligence: Case Studies in Common Lisp book.
"Franz Kafka" <·································@hotmail.com> ha scritto nel messaggio
································@posting.google.com...
> I was thinking about buying Lisp In Small Pieces? and Escentials of
> Programming Languages? How good are these books.
Both books are excellent. LISP more practical, EoP more abstract.
> Lisp/Scheme but wanted to learn about how to write compilers in Lisp,
> and how to write a Lisp compiler. As these are pricey books; how
> helpful would these be?
LISP would definitely help.
>How does Anatomy of Lisp compair to the above books?
The Anatomy is interesting only from a historical point of view.
> I am also intrested in writing Lisp in Lisp, Reflexive or Metacircular
> compilers--are there any books about such topics.
The Art of the MOP for CLOS. For core lisp, many older books
treat this. E.g. the Anatomy.
> I liked some papers I've read in 'Lisp Ponters' (Does the 'zein still exist?)
No.
> I also liked in ANSI CL how Paul Grham wrote the basic Lisp functions
> in Lisp. Is there a book about how to create a Lisp-kernal (microcode
> compiler, base functions) and write an entire ANSI CL on top of it.
> (Or, compiling Scheme on top of a kernal, because it is a smaller
> language.)
For a broad, not deep, overview you may find useful Kogge,
The Architecture of Symbolic computers. Or just study an existing implementation.
> Is there a book about implementing ANSI CL ontop of Scheme. Peter
> Novig wrote about implementing Scheme in ANSI CL in his Paradigms of
> Artificial Intelligence: Case Studies in Common Lisp book.
You may want to look at BBN lisp which was implemented in this way.
Source available from the lisp repository.
P.
>
> > I am also intrested in writing Lisp in Lisp, Reflexive or Metacircular
> > compilers--are there any books about such topics.
>
> The Art of the MOP for CLOS. For core lisp, many older books
> treat this. E.g. the Anatomy.
>
I have got LiSP, and looked through it. It did have two intresting
chapters: 1.) About towers of Lisp--Lisp defined using Lisp. 2.) A
chapter about Reflexion that was helpful.
But, I was confused by Denotional Semantics. Is their a ref. that
would explain this to me. I am more of a coding buf. than a math buf.
-- so, is there a ref. book that would explain Denotional Semantics in
Lisp code. It could be that eval/apply fit this need. But, I just
don't get math as well as I get code.
Thank You.
PS
I also got EoPL and it was good. There was less math in EoPL more
Scheme/Lisp code. The diagrams in both books helped me out alot.
PPS
I am trying to educate myself about Lisp -- both implementing it, and
implementing other langauges in it. (Are there any books in the middle
betweeen Compiling Lisp, and using Lisp.)
I have read some of the more advanced Lisp texts: On Lisp, SICP.
Is there a book that comes between books like LiSP, EoPL, and On Lisp,
SICP.
PPPS
I think the books are going to help me. I'll just skip over Den. Sem.
and some back to it later; unless I find a ref. book that explains it
so a good coder can understand it Scheme/Lisp terms.
PPPPS
If you can tell me the bast way to tackle Den. Sem. I'd be greatful.
I'll just struggle threw the Den. Sem. chapt. in LiSP and hope that I
can teach myself Den. Sem. (I know it will take longer that twenty-one
days, but Lisp is alot more powerful that C++/Java and alot less
likely to crash my system.)
Franz Kafka wrote:
> If you can tell me the bast way to tackle Den. Sem. I'd be greatful.
> I'll just struggle threw the Den. Sem. chapt. in LiSP and hope that I
> can teach myself Den. Sem. (I know it will take longer that twenty-one
> days, but Lisp is alot more powerful that C++/Java and alot less
> likely to crash my system.)
Read Stoy's book "Denotational Semantics: The Scott-Strachey Approach to
Programming Language Theory"; MIT Press, 1977. It's one of the clearest
explanations of the theory I've read. You can ignore a lot of the stuff
that's in the book about type lattices, because that's just to show that
the theory is complete. Everything else in the book is gold. Everything
else that has ever been published on this subject seems to derive from this
work.
faa
From: Joe Marshall
Subject: Re: Some Questions about Lisp Books?
Date:
Message-ID: <vfx67fns.fsf@ccs.neu.edu>
> Franz Kafka wrote:
>
> > If you can tell me the bast way to tackle Den. Sem. I'd be greatful.
> > I'll just struggle threw the Den. Sem. chapt. in LiSP and hope that I
> > can teach myself Den. Sem. (I know it will take longer that twenty-one
> > days, but Lisp is alot more powerful that C++/Java and alot less
> > likely to crash my system.)
>
"Frank A. Adrian" <·······@ancar.org> writes:
> Read Stoy's book "Denotational Semantics: The Scott-Strachey Approach to
> Programming Language Theory"; MIT Press, 1977. It's one of the clearest
> explanations of the theory I've read.
I'll second this recommendation.
You'll probably want to familiarize yourself with lambda calculus as
well. It's pretty straightforward.
The whole thrust of Denotational Semantics is to try to describe what
a program *means* in some formal sense. You start with sets of things
you might want to represent in your language: strings, numbers,
functions, aggregate types, etc. and you create mappings from program
constructs to members of these sets. The thing that is at first
confusing is that these mappings are usually described using lambda
calculus (because it lends itself quite nicely to the task), and the
mappings *look* like lisp expressions (because lisp was inspired by
lambda calculus). So in describing the semantics of lisp, you end up
with a pile of equations where one side (the lisp syntax side) looks
just like the other (the lambda calculus semantics side).
Also, since there are mathematicians involved, there is a whole lot of
effort devoted to proving that the math is well founded. You'd like
your programs to mean *something* (have at least *one* meaning) and to
be unambiguous (have at most *one* meaning). It turns out that in the
case of partial recursive functions that this is tricky to prove. If
it suits you, you can wade through Scott's lattice construction. I'm
a bit less picky: it was proved at some point, and I'll take it on
faith that the math works.
In article <····························@posting.google.com>,
·································@hotmail.com (Franz Kafka) wrote:
> But, I was confused by Denotional Semantics. Is their a ref. that
> would explain this to me. I am more of a coding buf. than a math buf.
> -- so, is there a ref. book that would explain Denotional Semantics in
> Lisp code. It could be that eval/apply fit this need. But, I just
> don't get math as well as I get code.
You might find the following link helpful.
Wolfgang De Meuter, Niels Boyen: "An Informal Tour On Denotational
Semantics", http://prog.vub.ac.be/cgi-bin/perform.cgi?action=paperdetails&id=ppr_12
Pascal
--
"If I could explain it, I wouldn't be able to do it."
A.M.McKenzie
"Franz Kafka" <·································@hotmail.com> wrote in
message ·································@posting.google.com...
> I have got LiSP, and looked through it. It did have two intresting
> chapters: 1.) About towers of Lisp--Lisp defined using Lisp. 2.) A
> chapter about Reflexion that was helpful.
>
> But, I was confused by Denotional Semantics. Is their a ref. that
> would explain this to me. I am more of a coding buf. than a math buf.
> -- so, is there a ref. book that would explain Denotional Semantics in
> Lisp code. It could be that eval/apply fit this need. But, I just
> don't get math as well as I get code.
I've read probably over half of LiSP, and I didn't really have problems with
it. I found the notation confusing at first but struggled through until it
became clear enough for me to follow what what going on.
You might want to try reading farther into the book, and then, literally, go
back and read it again.
Funky Math Bits in books throw me for a loop in general (particularly when
they start using Greek alphabets, mostly because I assume that there is some
other meaning to a partilcular symbol than they state in the book, something
I'm simply supposed to know). But although it looks intimidating, as I
recall it was fairly skin deep and with a little bit of study along with the
text, it was pretty straight forward.
Now, of course, I may be missing something deeper in the notation, but it
didn't seem that way to me.
(Mind I can certainly simply be blowing smoke here. I frankly haven't any
idea of what Denotional Semantics are, it's been about two years since I've
read the book, and I don't have it handy. I'm assuming you're talking about
the notation that is used within the book. If not, then, well, "Never
mind").
Regards,
Will Hartung
(·····@msoft.com)
Franz Kafka <·································@hotmail.com> wrote:
+---------------
| I have got LiSP, and looked through it. It did have two intresting
| chapters: 1.) About towers of Lisp--Lisp defined using Lisp. 2.) A
| chapter about Reflexion that was helpful.
+---------------
Pay especial attention to the section [sorry, don't have the book handy
at the moment, or I'd list the pages] on "fast interpretation", which
covers a large range of possible ways of representing lexical environments,
e.g., linked-lists of alists, linked lists of vectors ("frames"), vectors
of vectors (a.k.a. Algol-like "displays"), "skip-level" displays (a neat
hybrid between the previous two), and "flat" environments (which require
"boxing" [pushing into the heap and rewriting their accessors] of variables
that are mutated *and* closed over by "escaping" lambdas). I found that
section to be a gold mine for the aspiring implementor.
Also check out the "compiler" sections towards the end.
-Rob
-----
Rob Warnock, PP-ASEL-IA <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
·································@hotmail.com (Franz Kafka) writes:
> I was thinking about buying Lisp In Small Pieces? and Escentials of
> Programming Languages? How good are these books. I already know
> Lisp/Scheme but wanted to learn about how to write compilers in Lisp,
> and how to write a Lisp compiler. As these are pricey books; how
> helpful would these be? How does Anatomy of Lisp compair to the above
> books?
I can strongly recommend Lisp in Small Pieces, assuming you don't have
any alergies to Scheme. It definitely gave me a bunch of new
perspectives on things Lispy. And you have to admire a book that can
range from a pure denotational semantics for Scheme to a compiler that
generates C code.
-Peter
--
Peter Seibel ·····@javamonkey.com
The intellectual level needed for system design is in general
grossly underestimated. I am convinced more than ever that this
type of work is very difficult and that every effort to do it with
other than the best people is doomed to either failure or moderate
success at enormous expense. --Edsger Dijkstra
On 14 Apr 2003 18:47:05 -0700,
·································@hotmail.com (Franz Kafka) wrote:
> I am also intrested in writing Lisp in Lisp, Reflexive or Metacircular
> compilers--are there any books about such topics. I liked some papers
You might consider contributing to the improvement of an existing
implementation such as CMUCL or SBCL (grep for TODO into the SBCL sources,
for example). It would be less glamorous, but very useful.
> I've read in 'Lisp Ponters' (Does the 'zein still exist?) about
It no longer exists.
Paolo
--
Paolo Amoroso <·······@mclink.it>
On 14 Apr 2003 18:47:05 -0700,
·································@hotmail.com (Franz Kafka) wrote:
>I was thinking about buying Lisp In Small Pieces? and Escentials of
>Programming Languages? How good are these books. I already know
>Lisp/Scheme but wanted to learn about how to write compilers in Lisp,
>and how to write a Lisp compiler. As these are pricey books; how
>helpful would these be? How does Anatomy of Lisp compair to the above
>books?
>
>I am also intrested in writing Lisp in Lisp, Reflexive or Metacircular
>compilers--are there any books about such topics. I liked some papers
>I've read in 'Lisp Ponters' (Does the 'zein still exist?) about
>implementing Lisp Special-Forms as Lisp Macros.
>
>I also liked in ANSI CL how Paul Grham wrote the basic Lisp functions
>in Lisp. Is there a book about how to create a Lisp-kernal (microcode
>compiler, base functions) and write an entire ANSI CL on top of it.
>(Or, compiling Scheme on top of a kernal, because it is a smaller
>language.)
>
>Is there a book about implementing ANSI CL ontop of Scheme. Peter
>Novig wrote about implementing Scheme in ANSI CL in his Paradigms of
>Artificial Intelligence: Case Studies in Common Lisp book.
Not recommending references most people here already have.
Instead I would make a suggetion.
If you are interested in the writing of Lisp Compilers, why not try
porting cmucl or sbcl to Windows?
--------------------------------------------------
Thaddeus L. Olczyk, PhD
Think twice, code once.