[Top][All Lists]

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

Re: [Axiom-developer] Re: learning Lisp

From: root
Subject: Re: [Axiom-developer] Re: learning Lisp
Date: Tue, 6 Dec 2005 11:00:49 -0500

ok, this conversation has gone WAY off the rails ...

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.

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. there is a concatenate function in lisp and
   one in the boot language. to distinguish these two names so they
   don't collide each name lives in a separate hash table. the lisp
   concatenate is really USER:CONCATENATE and the boot version is
   BOOT:CONCATENATE. the "package name" prefix is the name of the
   hash table to look up the function symbol. so being in the BOOT
   package means to look in the BOOT package hash table to find the
   symbol corresponding to a name. to change to the "standard"
   package type:
     (in-packge "USER")
   to change back type
     (in-package "BOOT")

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.

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.

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.

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).

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.

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
then do
and you'll get a clean, non-axiom lisp image where you can work.


reply via email to

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