And there's some complex stuff unrelated to longevity or technical
prowess, and more related to market timing, that explains why the
sheer numbers of available libraries are perhaps not what you expect,
though in fact there really is quite a body of interesting stuff out
there when you compare it to the size of the user community which has
been Lisp during this long history.  Large programmer camps for any
language are really a relatively new phenomenon, going back only about
1.5 decades.

Fortran has been around as long as Lisp and also probably suffers under
the same "criticism" though really it's not a material criticism of the
language.

It should be plain that Lisp is not the market-dominant language.  If you
spend some time in Deja News looking for "AI Winter" as your search key
you can find some discussions on this that I don't care to repeat.

But to come in and find someone who has less available capital than someone
else and prod them by saying "hey, your trappings are not as fancy as those
rich guys over there. should I infer this to be 'the poor man's way?' is
not exactly starting out the conversation in a way that will win you any
friends."

I think I'm going to opt out of any further discussion with you on this
rather than let you bait me further unless you do some seriously better
research of the resources that do exist.  I try to be as nice as I can
to people, but there is a limit to how much work I'm willing to do.

  As for reimplementing things from scratch, I got so immensely frustrated
  with the available "libraries" of web-design crap that an incredibly
  incompetent moron had abused unintelligently for a week _not_ serving a
  high-profile ultra-high-security project I am now working on that I sat
  down and whipped up a new Lisp "scripting language", I added a handler to
  Apache and used the support for CLISP "binaries" (.fas files) under Linux
  to fire up an interpreter to deal with my pages, and instead of reams of
  junk code produced by cut and paste and sloppy editing, I could use real
  Lisp _macros_ in my source files, producing XML and Javascript and all
  sorts of junk efficienctly, well-tested and _fast_.  Designing that new
  language took me about three hours, but I have saved at least 40 hours
  dealing with the putrid fecal matter that some people actually spend
  their days trying to shape into web pages.  After working my butt off
  long into the night and missing a Saturday party, I had completed more
  _real_ work in a 16-hour stretch with a dimunitive Lisp tool like CLISP
  than a supposed _professional_ had managed to get done in a whole week.
  This pisses me off so much even hundreds of rounds of target practice
  does not calm down.  What I have done, highly inexperienced at web design
  and not knowing one iota of Javascript on Friday morning, probably looks
  clunky and is generally bells-and-whistles-free apart from functionality
  we need, should have been a walk in the park for a professional web head.
  It should have taken him mere hours to cobble up something from his vast
  store of libraries and tools and have it ready for us the same day.  If I
  can fumble my way through huge tomes, copy stuff I do not fully grasp,
  bumping into problems I had no idea would cause so many lines of logs in
  the poor server, and generally feeling like an incompetent fool myself,
  but I can still get it done in two days with Lisp as the underlying tool,
  writing most of this from scratch while scratching my head and swearing,
  god damn it, those imbecilic _frauds_ who claim to have "libraries" on
  their side should be hanged at dawn.

  People scream about CGI and how hard it is to prosess those things and
  they load 100K+ Perl libraries and write HTML with code that is even more
  verbose than HTML to begin with.  I shall break the "rule" I laid down
  above and tell you what I did.  Below is how I make those pesky CGI
  variables available to my code.  It probably is not 100% correct, but it
  works a lot better than the incredibly stupid Perl solutions I have seen,
  and Perl is supposedly _good_ at this crap.  Retch!  Excuse me while I
  barf in Larry Wall's general direction.  (I use string streams because I
  have no particular inclication to reinvent buffers.  Those who hate loop
  and format probably also hate string streams, but it is not _my_ fault
  that their Lisp vendor did not make them fast enough for them back in
  1980-whatever when their mind was set about what is Lisp and what is not.)

(defun 3ml-cgi-decode ()
  (let ((stream (if (string-equal "get" request-method)
                    (make-string-input-stream query-string)
                  *standard-input*))
        (symbols ()))
    (with-open-stream (output (make-string-output-stream))
      (loop for char = (read-char stream nil nil)
          do (case char
               (#\= (push (intern (string-upcase (get-output-stream-string output)))
                          symbols))
               ((nil #\&) (when symbols
                            (setf (symbol-value (first symbols)) (get-output-stream-string output))))
               (#\+ (write-char #\space output))
               (#\% (let* ((nib1 (read-char stream nil nil))
                           (nib2 (read-char stream nil nil))
                           (code (+ (* 16 (digit-char-p nib1 16))
                                    (digit-char-p nib2 16))))
                      (write-char (code-char code) output)))
               (t (write-char char output)))
          while char))
    (setf *cgi-variables* symbols)))

  You get the symbols that were passed in in the *cgi-variables* list so
  you can check for them with find or member, but you can use the symbols
  without bothering to check, too, provided you have a restart around them
  to get rid of the annoying unbound-variable error.  (Tracking this stuff
  down took me some time, as I have not needed to build interpreters that
  should do this before.  It may not be correct.  Use with caution.)

    (restart-case
        (handler-bind ((unbound-variable
                        (lambda (ignore)
                          (declare (ignore ignore))
                          (use-value ""))))
          ...)
      (use-value (&optional value) value))

  In the end, my nifty little markup language has stuff like this in it:

<table <border 0><width 375>
<form <name registerform><action register.3ml><method post><onsubmit return validate()>
{:discard  ; This {} form does not yield a value to be printed in its place.
(defun make-form (prompt type name &optional width)
     (format nil "<tr <td ~@[<width ~A>~] <p <class header> ~A:>>~
                      <td <input <type ~A><name ~A><value {~A}><size 35>>>>"
             width prompt type name name size))}
{(make-form "Given name" "text" "givenname" 120)}
{(make-form "Family name" "text" "familyname")}
{(make-form "E-mail" "text" "email")}
{(make-form "Phone" "text" "phone")}
{(make-form "Organization" "text" "organization")}
{(make-form "Username" "text" "username")}
{(make-form "Password" "password" "password1")}
{(make-form "Password (confirm)" "password" "password2")}
<tr <td <input <type hidden><name invitation><value {invitation}>>>
<td <input <type submit><name register><value Register>>
<input <type reset>>>>>>

  I assume that this is immediately understandable apart from the use of
  {~A} and {invitation}.  Those result in expansions to the CGI variables
  with the input field names.  I also assume that any wreck who has had to
  deal with the expanded HTML from something like this will appreciate its
  relative brevity.  Once I get more work done in this area, however, it
  should like this, but the code that produces HTML/XML is too simple to
  deal with it this late this weekend:

{(defun make-form (prompt type name &optional width)
   <tr <td {(when width <width {width}>)} <p <class header> {prompt}:>>
       <td <input <type {type}><name {name}><value {'{name}}><size 35>>>>)}
<make-form <prompt Organization><type text><name organization>>

  There, I have posted both loop code, intricate format constrol strings, a
  compact new syntax that saves a lot on typing (ewwww!), shown that I use
  javascript (EWWWW!), and I have not even kept the fact that I designed
  web pages a secret.  No cats were harmed in the production of this code
  or these web pages, however.

Thank you for spending you time in providing clarifications to me.  It
must sure be boring to keep answering similar questions time after
time.  I wont ask any more.

quasi

Thanks a lot.
quasi

(BTW, I'm *not* trying to claim  that either LOC or NOS is an accurate
measure...nor  trying  to   start  yet  another  line-oriented  versus
expression-oriented language debate...)

[...]