Few words can describe the sheer frustration of coming to Common Lisp from not merely an imperative background, but a background of modern languages. Everything from the documentation to implementation details have the stench of old and crusty all over it. If you aren’t dealing with the well meant condescension of Lisp gurus who seem have never actually had to write an application for end-users (and why would they, no one writes end-user applications in Lisp) then you’re dealing with documentation that was pretty much a copy and paste from the implementer’s specification created by a bureaucratic standards organization.

How do you explain to someone that an ANSI Standard document is not documentation.

You can’t, because only an asshole would think that. And you can’t explain pragmatism to an asshole.

Your language is not a race, it’s a game

An issue with many languages, and especially Lispers, is that they treat programming in Lisp a bit like you would treat a sports competition, or a chess match. To them, if you “haven’t done the prep” you deserve to lose.

But a language, or platform for developing software, is not like a chess tournament, it’s like a neighborhood game. And new programmers are like the new kid on the block. When they walk up to you and ask if they can play too, your response should “Sure, here are the rules.” If you don’t, you’d just an asshole.

A simple example is QuickLisp. QuickLisp took the idea of Ruby Gems, or NPM, and basically implemented it like an asshole would implement it. Because if you follow every step on the Getting Started page you will not end up with a working, interfaceable library.

If you are designing a packaging system, or library system you must do these things:

  1. Explain installation of your manager
  2. Explain installation of arbitrary libraries
  3. Demonstrate how to include libraries
  4. Demonstrate how to use libraries

Some steps are obviously redundant, redundancy is a feature. There may already be some established method of interacting with a library that you should know. Which makes the person who doesn’t know feel like a frustrated schlub, because everyone expects that he should know, so no one tells him. It’s a catch 22, you come into a language community and you can’t get jump-started. It’s sink or swim, and from the numbers with Lisp, most people sink.

The idea that it is or should be intuitive is stupid because I didn’t intuit it. It may just be that I am stupid. But it’s probably because you’re an asshole.

By the way, the answer to how to use a library, especially one with a long or complicated name and many functions, is this for say the xhtmlambda package. Took awhile to search it out, and finally found the answer in Peter Seibel’s book.

(in-package :xhtmlambda) ; this is the magic line 
; so you don't have to prepend xhtmlambda: to every function
(htmlise (:syntax :compact)
                 ((body :style "color: red")
                  (p "Some text here"
                     (ul (loop for i below 5
                                  collect (li () (format nil "Line ~D" i))))))
                 )
(in-package :cl-user) ; and this gets you back into your script