I looked several times at each of these:
 <http://cclan.cvs.sourceforge.net/*checkout*/cclan/asdf/README>
 <http://constantly.at/lisp/asdf/> but neither of them tells me
anything about checking if ASDF already is installed. Each seems to
assume you already know it's not previously installed and you need
to start from scratch installing it.

I asked this same question a couple times previously in different
threads, but nobody told me how to get the info I need. I'm hoping
blatantly announcing "ASDF-newbie" in the Subject field will
finally attract somebody who knows the answer. Does anybody know
how to get that ASDF-already-installed-or-not info???

Later: If I can ever find out whether ASDF is already installed on
my ISP, and if it turns out that it's in fact not yet installed and
I need to download and install it myself on my personal account,
I'll need to know how to get it and how to install it. For example:
 <http://www.cliki.net/asdf>
says:
   you can find it in the Sourceforge cCLan CVS repository:
     * http://cclan.cvs.sourceforge.net/cclan/asdf/
but when I click on that link it says:
                                                               ViewVC Exception
  An Exception Has Occurred
   The root "cclan" is unknown. If you believe the value is correct, then
   please double-check your configuration.
    HTTP Response Status
404 Repository not found
     _________________________________________________________________

 <http://constantly.at/lisp/asdf/Using-asdf-to-load-systems.html#Using%...>
says:
   The single file asdf.lisp is all you need to use asdf normally. Once
   you load it in a running Lisp, you're ready to use asdf.
Is that really correct??

<http://www.cliki.net/asdf> also says:
   The source code of ASDF is here.
   URL: <http://cclan.cvs.sourceforge.net/*checkout*/cclan/asdf/asdf.lisp>
Is that the aforementionned "single file" that I need to load into
a running CMUCL before using ASDF? So, assuming it's not already on
some system directory and I need to download my own private copy, I
just download the contents of that Web page to my private account,
start up CMUCL, load that in, and then I can immediately start
using ASDF?

   The cclan version of asdf apparently doesn't have the necessary code
   to hook REQUIRE into CMUCL. So here is a small bit of code to make it
   so. You need at least cmucl 19a with patch 0 for this to work.

If the administrator has configured his system to updated periodically
the locate database, you can use it to locate a file by (part of) name
(or with some versions of localte by regular expression).

     locate asdf.lisp

Otherwise, in the last resort, you can use find (it's slower since it
scans all the directory hierarchy):

     find / -name asdf.lisp -print

That said, asdf.lisp is about 40 KB, I wouldn't hesitate to keep my own
copy in case of version differential or whatever.

For some lisps, it is better to
(compile-file #P"/path/to/asdf.lisp") ; do this once
and then load the compiled version of ASDF.
(load #P"/path/to/asdf.fas") ; or whatever extension your lisp uses

For most (all?) lisps, this can be simplified as
(compile-file "/path/to/asdf") ; compile-file guesses the extension
(load "/path/to/asdf") ; load tries compiled version first

Well, while well-intended, I feel that's a bit too strong.
REQUIRE does have one useful feature that one would want to
duplicate when "just using LOAD", namely, that it won't LOAD
the file again if LOADing it the first time resulted in the
addition of the module name to *MODULES*. This makes it easy
for small utility modules to simply REQUIRE the other modules
they depend on without having to have an ASDF file for every
possible combination of modules one might use!

Yes, one can easily create a REQUIRE replacement that performs
an equivalent "once-only" action, and perhaps that's a better
solution for programs intended to be very portable. Something
like this perhaps [only lightly tested]:

    (defvar *my-required-files* nil)

    (defun my-require (&rest files)
      (dolist (file files)
        (let ((path (truename file)))
          (unless (find path *my-required-files* :test #'equal)
            (load path)
            (push path *my-require-files*)))))

But for local hacking about, I find CMUCL's REQUIRE adequate... ;-}

-Rob

If so, ASDF is already loaded.

On my current (very cramped) shell account:
shell.rawbw.com% locate -S
Database: /var/db/locate.database
Compression: Front: 17.35%, Bigram: 63.12%, Total: 12.68%
Filenames: 181580, Characters: 11116300, Database size: 1409385
Bigram characters: 519782, Integers: 3810, 8-Bit characters: 3
shell.rawbw.com% ls -l /var/db/locate.database
1392 -r--r--r--  1 nobody  wheel  1409385 Jan 10 04:15 /var/db/locate.database

On the machine we'll be miagrating to eventually:

On the machine in the UK where I have a guest account:
rem@teh:~$ locate -S
Database /var/cache/locate/locatedb is in the LOCATE02 format.
Locate database size: 11087253 bytes
Filenames: 644372 with a cumulative length of 47764669 bytes
        of which 1459 contain whitespace,
        2 contain newline characters,
        and 100 contain characters with the high bit set.
Compression ratio 76.79%
rem@teh:~$ ls -l /var/cache/locate/locatedb
-rw-r--r-- 1 root root 11087253 Jan 11 06:26 /var/cache/locate/locatedb

So it looks like the database is kept up to date on all three machines.

shell.rawbw.com% locate asdf.lisp
(no output before next shell prompt, hence no such file found)

rem@teh:~$ locate asdf.lisp
/home/jpw/old-src/sbcl/contrib/asdf/asdf.lisp
/usr/share/common-lisp/source/arnesi/src/asdf.lisp
/usr/share/common-lisp/source/asdf/asdf.lisp
/usr/share/sbcl-common/contrib/asdf/asdf.lisp
Four different versions, comparing sizes:

rem@teh:~$ ls -l /home/jpw/old-src/sbcl/contrib/asdf/asdf.lisp
-rw-r--r-- 1 jpw jpw 44714 Aug 31  2005 /home/jpw/old-src/sbcl/contrib/asdf/asdf.lisp
rem@teh:~$ ls -l /usr/share/common-lisp/source/arnesi/src/asdf.lisp
-rw-r--r-- 1 root root 2376 Oct 12  2005 /usr/share/common-lisp/source/arnesi/src/asdf.lisp
rem@teh:~$ ls -l /usr/share/common-lisp/source/asdf/asdf.lisp
-rw-r--r-- 1 root root 39639 Sep 26  2005 /usr/share/common-lisp/source/asdf/asdf.lisp
rem@teh:~$ ls -l /usr/share/sbcl-common/contrib/asdf/asdf.lisp
-rw-r--r-- 1 root root 44714 Mar 27  2006 /usr/share/sbcl-common/contrib/asdf/asdf.lisp
First and last are same size, so comparing them:
rem@teh:~$ diff /home/jpw/old-src/sbcl/contrib/asdf/asdf.lisp /usr/share/sbcl-common/contrib/asdf/asdf.lisp | more
(no output before next shell prompt, hence files are identical)

Comparing slightly short with full-length versions:
rem@teh:~$ diff /usr/share/common-lisp/source/asdf/asdf.lisp /usr/share/sbcl-common/contrib/asdf/asdf.lisp | more
< ;;; This is asdf: Another System Definition Facility.  $Revision: 1.88 $
---

Finally, looking at that short file:
rem@teh:~$ more /usr/share/common-lisp/source/arnesi/src/asdf.lisp
;; -*- lisp -*-
(in-package :it.bese.arnesi)
;;;; * A clean-op for ASDF
(defclass clean-op (asdf:operation)
  ((for-op :accessor for-op :initarg :for-op :initform 'asdf:compile-op))
  (:documentation "Removes any files generated by an asdf component."))
(defmethod asdf:perform ((op clean-op) (c asdf:component))
  "Delete all the output files generated by the component C."
  (dolist (f (asdf:output-files (make-instance (for-op op)) c))
    (when (probe-file f)
      (delete-file f))))
..
Is that something I would need *after* 1.88, or something already
incorporated into it hence no longer needed?

Switching over to the Ubuntu Linux system in the UK:
rem@teh:~$ lisp
-bash: lisp: command not found
rem@teh:~$ cmucl
-bash: cmucl: command not found
rem@teh:~$ sbcl
This is SBCL 0.9.8.8, an implementation of ANSI Common Lisp.
..
* (find-package "ASDF")
NIL
* asdf:*central-registry*
debugger invoked on a SB-KERNEL:READER-PACKAGE-ERROR:
  READER-ERROR on #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100015D091}>:
package "ASDF" not found
* (require :asdf)
appx. 3 second pause
("ASDF")
so does that mean it loaded it from one of those three files I
found earlier via the 'locate asdf.lisp' command?

* (make-package "FOOQ")
#<The FOOQ package, 0/9 internal, 0/9 external>

* fooq:bar
Reader error at 74579 on #<Two-Way Stream, Input = #<Synonym Stream to SYSTEM:*S
TDIN*>, Output = #<Synonym Stream to SYSTEM:*STDOUT*>>:
Symbol "BAR" not found in the FOOQ package.

On the Ubuntu Linux system in the UK (SBCL):
* (MEMBER :ASDF *FEATURES*)
NIL
* (require :asdf)
("ASDF")
* (MEMBER :ASDF *FEATURES*)
(:ASDF :ANSI-CL
       :COMMON-LISP
       :SBCL
       :UNIX
       :SB-DOC
       :SB-TEST
       :SB-PACKAGE-LOCKS
       :SB-UNICODE
       :SB-SOURCE-LOCATIONS
       :IEEE-FLOATING-POINT
       :X86-64
       :ELF
       :LINUX
       :GENCGC
       :STACK-GROWS-DOWNWARD-NOT-UPWARD
       :C-STACK-IS-CONTROL-STACK
       :LINKAGE-TABLE
       :STACK-ALLOCATABLE-CLOSURES
       :OS-PROVIDES-DLOPEN
       :OS-PROVIDES-DLADDR
       :OS-PROVIDES-PUTWC)
IMO using POSITION instead of MEMBER is better, to avoid the
verbose printout of the tail of the list from the found-element to
the end of the list of features.

And I would say that it is *always* better to compile asdf.lisp.

=> ASDF isn't preloaded (e.g. by an init file) on either system...

Anyway, you need to get a copy of asdf.lisp on the BSD server.  If
that requires netcat, then more power to you.

The server will need to use either
   (load #P"/path/to/asdf.lisp")
or
   (require :asdf #P"/path/to/asdf.lisp")

I think REQUIRE, while "deprecated", is preferable to LOAD in this
case; it can no-op when the file is already loaded.

Since you don't have write access to the directory containing
asdf.lisp on the server, compile it with something like

(compile-file #P"/path/to/asdf.lisp"
   :output-file #P"/path/to/asdf.fasl")

Then load the compiled version using
(load #P"/path/to/asdf.fasl")

and tell ASDF where to find files using
(push #P"/path/to/*.asd" asdf:*central-registry*)
where #P"/path/to/*.asd" is a directory of symlinks named *.asd
pointing to the asd files in actual packages.

-----

On your webserver, is SBCL a persistent process, or is it started each
time a CGI script runs?  If the latter, there are two tricks you might
consider:
- Use save-lisp-and-die to save everything into a single image
- Switch to clisp

On my system,
# time sbcl --eval '(quit)'
real    0m0.352s
# time clisp -x '(quit)'
real    0m0.020s
 > time clisp -x '(require :asdf "./asdf.fas") (quit)'
real    0m0.114s

So the slower implementation is sometimes faster.

Look, it's not difficult.  On unix, before using ANY command, you should
just type: man THE_COMAND  and read carefully the page mage of the
command.

With make, arnesi would have written something like:

clean:
    for file in $(OUTPUT_FILES) ; do \
        if [ -r $$file ] ; then \
            rm $$file ;\
        fi ;\
    done

in some makefile.  That is, they would have provided data to make.
But since in lisp, code = data = code = data, instead of providing data
in some strange format to lisp tools, you just provide code.  This is
easier and more powerful, and can be done without a question raised
since asdf is to be used by _programmers_.   Are you a programmer?

For example, if you have an asdf system such as:

    /home/rem/src/split-sequence/split-sequence.asd

you can write:

    (pushnew #P"/home/rem/src/split-sequence/" asdf:*central-registry*
             :test (function equal))

to be able to do:

    (asdf:oos 'asdf:load-op :split-sequence)

Or you can use a little function such as:

    http://paste.lisp.org/display/49261

to fill asdf:*central-registry* with all the directories in a subtree
where .asd files lie.

(There's another way, using so called "symbolic links", but I cannot
find this notion in CLHS...)

    Robert> When I start up CMUCL here, it says:
    Robert>   CMU Common Lisp 18b, running on shell.rawbw.com
    Robert> So does anybody know whether if I go to the trouble of downloading
    Robert> and installing ASDF here, it'll even be possible for it to work
    Robert> here?? Does anybody know how to make ASDF work here? Or should I
    Robert> just dismiss ASDF as something that can't possibly work here and
    Robert> is not worth any further bother on my part?

If you want to have asdf hook into REQUIRE with CMUCL, I can provide
the nessary changes.  You need the bit of code from cliki.net, and you
need the changes from 19a to run with 18b.  I'm pretty sure the
changes are quite simple and should run on 18b.

(defmethod perform ((o asdf:test-op) (c (eql (find-
system :weblocks))))

and

(defmethod perform ((o load-op) (c elephant-c-source))

Now on to my point-by-point reply/followup:

So as long as you're jumping down my throat for my failure to wade
my way through those illegible 'man' pages for 'diff' once again,
starting more than three hours past my bedtime, at 1:43, I'll give
it a royal try...

       -E  --ignore-tab-expansion
              Ignore changes due to tab expansion.
(doesn't ignore *all* white space, but might do what I need in this
 special case where tab expansion might be why the newer version is
 smaller)

       -b  --ignore-space-change
              Ignore changes in the amount of white space.
(might be what I asked for)

       -w  --ignore-all-space
              Ignore all white space.
(might be over-kill, but might be needed, not sure)

       -B  --ignore-blank-lines
              Ignore changes whose lines are all blank.
(I might want this too, not sure)

       -t  --expand-tabs
              Expand tabs to spaces in output.
(I probably need this to avoid problem of host and recipient
 counting tabs as different sizes.)

       -d  --minimal
              Try hard to find a smaller set of changes.
(I might need this too)

       --speed-large-files
              Assume large files and many scattered small changes.
(I don't know whether to use this or not)

       The  full documentation for diff is maintained as a Texinfo manual.  If
       the info and diff programs are properly installed  at  your  site,  the
       command
              info diff
       should give you access to the complete manual.
(It's now 1:52. Should I 'info diff' or not??)

Ok, now it's sitting at:
 Manual page diff(1) line 195/219 (END)    
and when I press space to continue off the end it just beeps at me.
Do I need to press control-C to abort the 'man' program on Ubuntu
Linux, or is there some clean way to exit it? I think I need to
control-Z to suspend 'man diff' and now do 'man man' to get
instructions how to gracefully exit the program when it reaches the
end of the document. It's now 1:55...
OK, I've scrolled all the way to the end of 'man man', and I don't
see any mention whatsoever of the commands used to navigate
scrolling, such as space to see another window or return to see
just one more line. At 2:01, I'm sitting at:
 Manual page man(1) line 527/551 (END)    
and have no idea how to gracefully get out of either 'man diff' or
'man man'. Let me see if the 'h' command gives me help about
scrolling commands, as it does when running 'more'...

                   SUMMARY OF LESS COMMANDS
      Commands marked with * may be preceded by a number, N.
      Notes in parentheses indicate the behavior if N is given.
  h  H                 Display this help.
  q  :q  Q  :Q  ZZ     Exit.
  ESC-SPACE         *  Forward  one window, but don't stop at end-of-file.
HELP -- Press RETURN for more, or q when done
                          LINE EDITING
        These keys can be used to edit text being entered
        on the "command line" at the bottom of the screen.
Now at 2:06 I'm sitting at:
HELP -- END -- Press g to see it again, or q when done
I pressed 'q', now sitting at:
 Manual page man(1) line 527/551 (END)
I pressed 'q' again, now sitting at:
rem@teh:~$
I typed 'fg', now sitting at:
 Manual page diff(1) line 195/219 (END)
I pressed 'q' again, now sitting at:
rem@teh:~$

rem@teh:~$ diff -b /usr/share/common-lisp/source/asdf/asdf.lisp /usr/share/sbcl-common/contrib/asdf/asdf.lisp | more
1c1
< ;;; This is asdf: Another System Definition Facility.  $Revision: 1.88 $
---

Hmm, they went to all the trouble of issuing a new minor version
number, just to fix the pretty-print indentation on that (let ...,
and change equal to equalp (I almost missed that because the two
lines didn't "line up" because of change in indentation, so the
change didn't pop out at me when eyeballing the two lines in
parallel), and in the process they made massive changes in white
space due to tab optimization?? I'll need to look at the two files
separately (in emacs) to see whether they fixed the indentation
that had been wrong before, or *broke* it in the process of
manually adding the letter "p" to "equal"...

rem@teh:~$ emacs /usr/share/common-lisp/source/asdf/asdf.lisp /usr/share/sbcl-common/contrib/asdf/asdf.lisp
C-U 976 C-N
takes me to a line (same in each file), that says:
        (let ((*serial-depends-on* nil))
How come the line-number given by 'diff' isn't the same as one more
than the number of C-N commands needed to get there? Is it because
the stupid version of EMACS on Ubuntu counts wrapped lines as MORE
THAN ONE LINE, where C-N goes into position-plus-80 in the SAME
LINE instead of moving to next line? I'll have to go back to the
top and try incremental-search instead, hoping that there aren't a
lot of lines that look the same in different parts of the file...
There's only one line (same in each file) like that:
        ;; check for duplicate names
        (let ((name-hash (make-hash-table :test #'equal)))
Both are indented the same, so 'diff' is lying when it shows
different indentation. Or the prefix at the left of the line
added by 'diff' is screwing tab alignment, Let me try again:

rem@teh:~$ diff -b -t /usr/share/common-lisp/source/asdf/asdf.lisp /usr/share/sbcl-common/contrib/asdf/asdf.lisp | more
1c1
< ;;; This is asdf: Another System Definition Facility.  $Revision: 1.88 $
---

Aha, no change in indentation, just the < or > added by 'diff'
caused tab to end up 8 from very left margin instead of 8 from
start of line from file. But -t makes it generate 8 spaces, so it
shows as 8 from start of line from file. So they didn't fix any
indentation, merely converted it to tabs instead of spaces, so that
diff without the -t option would give a misleading report.
It's now 2:27, and I really should go to bed now, before finishing
the rest of this followup.

It's now 9:48, and I'm awake and resuming my reply now:

[snip discussion of makefile vs. lisp]

The code I write is fully inline-documented, for example, here's
what's at the top of my 2005-7-mbbt.lisp:

;Moderately-Balanced Binary Tree: The total number of nodes in the two
; branches, at each level, is never allowed to get worse than 3:1 or 2:0
;This is not as strict as an AVL tree, so it gets somewhat more unbalanced,
; but performs major rebalancing much less often. This implements a sorted
; TreeMap. To implement a sorted set, use NIL as val in all cases. It wastes
; some storage for every node to contain one dunzell standard-pair,
; but it saves writing a lot of almost duplicate software.
;<EmptyPair> = (:PAIR . NIL)     ;[sic] not really a pair yet
;<GoodPair>  = (:PAIR key . val) ;Key field is immutable, value mutable
;<Tree> = (:MBBT 0 . <EmptyPair>) = (:MBBT 0 :PAIR)  ;empty/null/dummy
;       | (:MBBT 1 . <GoodPair>)                     ;leaf
;       | (:MBBT <Total> <GoodPair> <Tree> <Tree>)   ;fork
;Note: Per the BNF above, NIL would be a valid key. A GoodPair with NIL
; as the key is distinguished from an EmptyPair because NIL is car of stdpair
; which isn't present for EmptyPair. However in the code below the key must
; always be integer and sorting predicate is always #'< and equality predicate
; is always #'=, whereby NIL wouldn't be allowed as a key. A variation of
; this module might use different sorting/equality predicates whereby NIL
; could be a valid key, sharing whatever code below doesn't involve those
; operators.
;Note that during the transition between: leaf <-> fork,
; both the count and the basic structure must be changed,
; hence at the halfway point the two are inconsistent.
;At such times, it's the structure, not the count, which determines access means.
;The structure is changed first, then the count is recomputed and updatedInPlace.
;Hence mbbt-tree-is-leaf and mbbt-tree-is-fork test the structure, not the count.

;If you are going to be adding large consecutive blocks that share all
; the same value (or for a TreeSet where there's no value associated with
; a key), this is not appropriate because it takes a long time to add all the
; individual nodes one by one, and it wastes space to have so many nodes.
; Instead, use a derived type that stores intervals of keys instead of
; individual keys per node.

;Major change 2007.May.08-10: Node-update function no longer fixed, now
; parameterized via fluid variable, so that other node-update policies
; can be used for derived classes such as MBBT-interval+length (mbbtil).

In the same file, a few samples of inline documentation before
individual functions:

;This makes an empty tree or sub-tree.
; This is to avoid having to wait until the first element is available
; before building the framework for the tree, so you can save the
; toplevel handle which will never change for any given tree, so copies
; of the original handle will always be valid. Note: It's a bad idea to
; make copies of handles of sub-trees then attempt to modify those sub-trees,
; because if you do that, the total-count-of-subtree won't propagate into
; totals at higher levels in main tree.
(defun mbbt-new ()
  (list :MBBT 0 :PAIR)) ;I.e. (:MBBT 0 . <EmptyNode>) = (:MBBT 0 :PAIR)

;Are we looking at the very top level of a MBBT object here?
(defun mbbt-is-tree (mbbt)
  (eql :MBBT (car mbbt)))
;MBBT must be a leaf node, and we want to delete the only key present,
; which will convert this to an empty (null) tree.
;As usual, we return values: deletedKey deletedVal
(defun mbbt-leaf-delete-only (mbbt)
  ...)

;Find node with key exactly = the probe.
;If such exists, return entire <GoodPair> object, i.e. (:PAIR key . value)
;Otherwise return NIL.
(defun mbbt-find-exact= (mbbt probe)
  ...)

;Find node with nearest key leq the probe.
;If such exists, return entire <GoodPair> object, i.e. (:PAIR key . value)
;If probe is leftward of leftmost node in tree, return :LEFTWARD
(defun mbbt-find-nearest-leq (mbbt probe)
 ...)

[Pascal J. Bourguignon]

| [...] man THE_COMAND  and read carefully the page mage
| of the command.

[Robert Maas]

| I already did read those fucking-extraverbose man pages several times,
| each time spending a half hour or hour or even two hours [...]

You might be better off reading them less carefully.  I'm often helped
by cheap-and-cheerful approaches, like

  $ diff --version | head -n 1
  diff (GNU diffutils) 2.8.1

  $ diff --help | grep white
    -b  --ignore-space-change  Ignore changes in the amount of white space.
    -w  --ignore-all-space  Ignore all white space.

at least for the first pass.

I think it's reasonable to think of `find' as the general Unix user
interface for operating on the filesystem-graph, and as such worth
spending a little time learning.

  find --help

yields a dense overview, at least with a recent GNU findutils.  Also,
the top 4 Google results for "find tutorial" are tutorials for `find'.

You'll find that most commands yield useful output when you pass --help.

| Ok, now it's sitting at:
|  Manual page diff(1) line 195/219 (END)    
| and when I press space to continue off the end it just beeps at me.
| Do I need to press control-C to abort the 'man' program on Ubuntu

Nowadays it's reasonable to assume that the default pager is `less'
(instead of `more').  `man' takes care of rendering the page, and punts
to `less' for paging.  Press `q' to quit, press `h' to see a help-page,
press `/' to search forward for a regex-match, press `g' to jump to the
first line.  Piping long output to `less' for paging long outputs from
grep, locate etc. is useful.

There's a recent-Linux-distribution survival-kit for you; --help,
option, grep, find, locate, man and less.

| How come the line-number given by 'diff' isn't the same as one more
| than the number of C-N commands needed to get there?  Is it because
| the stupid version of EMACS on Ubuntu counts wrapped lines as MORE
| THAN ONE LINE [...]

That sounds highly unlikely.  Besides, you can probably get the
display behaviour you want by putting "(setq selective-display-ellipses
t)" in your .emacs.

Since you're already in Emacs, it's convenient to do `M-x diff RET'
insteading of dropping to a shell.  Other useful commands to avoid
dropping to a shell in Emacs are `dired', `locate', `grep', `find',
`find-grep' and `man'.  They invoke the corresponpinding Linux commands
for you, and provides helpful behaviour for operating on the output.
For example, `RET' on a line in a diff-buffer will take you to the
corresponding line in the source file, `RET' on a line in a grep buffer
will take you to the corresponding location in the source file etc.

| I don't understand why, on Ubuntu where asdf already is on system
| disk, I need to provide my own version in addition. Why can't I
| just use the system-supplied version?

Why can't you?  (load "/path/to/asdf.lisp") ?

| I'm guessing asdf:oos means Object-Oriented Services, but
| so-far the Google search isn't turning up the definition of the
| abbreviation.

  CL-USER> (load #p"/home/thomas/lib/cl/asdf.lisp")
  T
  CL-USER> (documentation 'asdf:oos 'function)
  "Short for _operate on system_ and an alias for the `operate` function.
  Operate does three things:

  1. It creates an instance of `operation-class` using any keyword parameters
  as initargs.
  2. It finds the  asdf-system specified by `system` (possibly loading
  it from disk).
  3. It then calls `traverse` with the operation and system as arguments

  The traverse operation is wrapped in `with-compilation-unit` and error
  handling code. If a `version` argument is supplied, then operate also
  ensures that the system found satisfies it using the `version-satisfies`
  method."

An alternative to ASDF is Sean Ross' Mudballs <http://mudballs.com/>

| Many years ago there were job openings for people to do this kind of
| work, for the purpose of developing a huge database of "world
| knowledge" for use by a computer system that understood the deep
| meaning of natural language.

Today the "semantic web" is all the rage.  Or, maybe it was last week.
<http://en.wikipedia.org/wiki/Semantic_Web>

| IMO s-expressions are optimal for specifying strictly-nested
| structures, whereas SGML is optimal for turning orthogonal modes on
| and off in a non-nested way, the old "tag soup" methodology.

Related topic at <http://www.cliki.net/HTML-from-sexpr>.  Marking up
with sexprs offers paren-matching instead of tag-balancing, structural
editing with familiar Emacs commands, less verbosity, easy manipulation
by means of CL, easy to spit out whatever-format from.

| I wonder how MicroSoft Word fhandles it [...]

It's "Microsoft", I believe.

|  [about ASDF dependency-detection/resolving]

<http://www.cliki.net/asdf-dependency-grovel> is useful, and
<http://common-lisp.net/project/xcvb/> is in the works.

ASDF/ASDF-INSTALL works just fine for downloading, installing, compiling
and loading an extensive set of libraries, though.

|    Suppose that file "a" in system FOO changes; if you load system BAR,
|    file "a" will be recompiled; but file "b" will not! If file "b" uses a
|    macro from file "a", you will load the old version of that macro from
|    FASLs, and things will break. Ow.

| Does this mean ASDF is really crappy in this respect?

This has bitten me often enough that I have written tools for clearing
relevant fasls.  On the other hand, I've become better at getting my
macros right quickly. :)

FreeBSD:

At this stage, I am nowhere near packaging an application to run
under CGI. All these manual tests of CMUCL and SBCL are directly
from interactive shell.

;Given name (symbol) of needed function, and directory-shorthand + fn1
; where that function is defined:
;If function already defined, do nothing, else load source or compiled,
; whichever is latest, then make sure the function really got defined.
(defun funct+shortdir+fn1-mayload (funct shortdir fn1)
  (prog (lastfile)
    (when (fboundp funct) (return :ALREADY))
    (setq lastfile (shortdir+fn1-which-more-recent shortdir fn1))
    (load lastfile)
    (when (fboundp funct) (return :LOADED))
    (error "After loading ~S,~%function ~S still not defined" lastfile funct)
    ))

If and when I run CGI/SBCL code on Ubuntu Linux, then I should be
able to use the code you quoted.