[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

RE: [Axiom-developer] Re: learning Lisp

From: Bill Page
Subject: RE: [Axiom-developer] Re: learning Lisp
Date: Tue, 6 Dec 2005 11:38:40 -0500

On December 6, 2005 11:01 AM Tim Daly wrote:
> ok, this conversation has gone WAY off the rails ...

I don't know why you say that. It seems right-on to me. The
information you provide below is very useful.

> 1) the $dalymode is a HACK to allow easier maintenance of the
>    system. it is NOT a general purpose mechanism and it needs one
>    of those hallway signs (like slippery floor) to make people
>    aware that it INTENTIONALLY breaks the interpreter in certain
>    well-known ways to allow ease of use for MAINTENANCE. If you're
>    gonna unscrew the pipes you've got to expect that the plumbing
>    is broken. there is no plan to ever make this part of the
>    standard.

I STRONGLY disagree with this attitude. It is the purpose of
all documentation to act as "hallway signs" when necessary. I
don't think $dalymode is any more of a HACK than any other
debugging/maintenance option already defined in Axiom. And as
far as I can see from the Axiom source code, $dalymode is just
a short-cut for an Axiom command that *is* already documented

  )lisp ...

So I don't see what the big deal is. If we are going to keep
this short-cut, then let's just document it properly once and
for all.

> 2) the BOOT package has nothing to do with the boot language.
>    the BOOT package is a way to isolate certain axiom names
>    from certain common lisp names. ...

That is clear and has already been explained, I think.

>    to change to the "standard"  package type:
>      (in-packge "USER")
>    to change back type
>      (in-package "BOOT")

Can you explain what is the difference? Which package is used
for what? In what sense is "USER" standard? What other packages
are defined in Axiom?

> 3) the commands
>      )read file.input
>      )lisp (load "file.lisp")
>    work on two different levels that have NOTHING to do with 
>    each other.
>    the ")read" command reads AXIOM expressions from an input
>    stream.
>    the "(load" command reads LISP expressions from an input
>    stream.

Of course but why doesn't $dalymode allow the same short-cut
for )lisp inside ')read'?

> 4) the |foo| naming convention isn't really a naming convention.
>    the BOOT language is case sensitive. by default lisp uses
>    uppercase only. the lisp syntax for escaping special characters
>    in a symbol name is to surround it with vertical bars. if you
>    define a function in BOOT using lower case with
>        foo == 
>    it becomes equivalent to 
>        (defun |foo| 
>    however if you define a BOOT function name in uppercase as in
>        BAR ==
>    it becomes equivalent to
>        (defun bar 
>    without the escape characters.

Ok, that is important to know. Generally Boot functions are written
with at least one lower case letter so they always appear as |...|.
So we can write:

(1) -> )fin
(defun foo1 (x y)
   (+ x y))

(defun |foo2| (x y)
   (+ x y))


(1) -> FOO1(1,2)$Lisp

   (1)  3
                                     Type: SExpression
(2) -> foo2(1,2)$Lisp

   (2)  3
                                     Type: SExpression

> 5) Lisp functions are always available in Axiom and are used in
>    the algebra (grep for $LISP). However it is strongly recommended
>    that you don't do this as it implies you know the EXACT LISP
>    internal representation of the object you are manipulating.
>    Don't try this at home.

Au contraire. The is the axiom-developer list ... Please try this at
home! Try to understand it. Try to help maintain and improve Axiom.

> 6) everything in axiom is just lisp code. there is no magic
>    anywhere.  sure, it looks funny but it's really just lisp.
>    once you understand that it all makes sense (well, after 10
>    years or so).

Well, that is a considerable exaggeration I think. Make
perfectly good sense to me and I've only been doing this
seriously for 2 years. :)

> 7) there are "flavors" of lisp. axiom is written in common 
>    lisp version 1. the standard has moved since axiom was
>    written but in a mostly upward compatible way. the lisp
>    in Emacs is another, older lisp.

These days "Common Lisp" usually means ANSI Common Lisp, right?
Is there a more exact way to refer to the current standard?
> since there is general confusion about all of this perhaps it
> is best to learn lisp in a raw lisp image. when you build
> axiom you'll find a raw lisp image that has been built and
> can be used. if you build axiom at
>     (yourpage)/axiom
> then do
>     (yourpage)/axiom/obj/linux/bin/lisp
> and you'll get a clean, non-axiom lisp image where you can
> work.

That is ok, but I do not think that it reduces the confusion
much in the mind of someone new to lisp who already knows
Axiom. All we really need is a good explanation of how lisp
is used in Axiom. What you have written above is great and
would only occupy a couple of paragraphs on a web page
introducing lisp to Axiom developers.

Bill Page.

reply via email to

[Prev in Thread] Current Thread [Next in Thread]