One can use quicklisp bundles so that the user doesn't have to install quicklisp and download dependencies themselves

https://www.quicklisp.org/beta/bundles.html

Again, these are not ideal for software distribution in the general case (but can be useful for certain cases, so fine as an extra option).

Do you see many Python projects being distributed as virtualenv tarballs which quicklisp bundles may be seen as the equivalent to?

Let me present a sane scheme for dependency management, in terms of software distribution:

+ Create an ASDF system definition.

+ Create a README and list all dependencies with links to the code, version requirements (if any) and other notes/gotchas. This is useful to have regardless.

* Optionally, create a install-deps-via-quicklisp.lisp script that pulls down given dependencies via quicklisp.

* Optionally, create a quicklisp bundle.

Quicklisp (and the way quicklisp does things) should never be forced on the user. Don't get me wrong, it simplifies dependency management and has made things easier for newcomers but it compromises on other fronts and is not (and should not become) the standard way of managing dependencies in CL-land since a lot of its design choices do not mesh well with many real-world scenarios. Always leave a fallback.

I'm officially too dumb for that.

    (loop for system in (list "sxql" "cl-ppcre" "dexador" "clss" "plump" "plump-sexp" "datafly" "xml-emitter" "local-time" "hunchentoot" "cl-who" "lass" "smackjack" "parenscript") do (asdf:load-system system))

I get a load of warnings about "redefining functions". Rather annoying...

You do not need to explicitly load them, ASDF will do it for you. You do need to declare the dependencies though.

Here is an example (example.asd)

  (defsystem :example
    :name "Example"
    :description "Example."
    :author "foo@bar"
    :serial t
    :license "BSD"
    :version "1.0"
    :depends-on (:sxql :cl-ppcre :dexador :clss :plump)
    :components ((:file "packages")
                 (:file "file1")
                 (:file "file2")
                 (:file "file3")))

You don't need to specify .lisp extension for files. Your packages.lisp may be:

  (in-package #:cl-user)

  (defpackage #:example
    (:use #:cl #:sxql #:cl-ppcre)
    (:export #:*global-symbol*
             #:exported-function))

Then you can load your system through ASDF, including all its dependencies, like so:

  (asdf:oos 'asdf:load-op :example)

This assumes that example.asd is inside a directory that can be found in:

  asdf:*central-registry*

Ah, I see, thank you. So I'll have to "install" the script into the registry before being able to just "use" it? :(

The easiest way to do it is to create a .asd for your project and then symlink or copy your project into ~/quicklisp/local-projects (i.e. the folder "local-projects" in the same directory as setup.lisp). Then, either run (ql:register-local-projects) or restart lisp and then do (ql:quickload :my-project) to load it.

Hmm, that makes "just clone the repository and you're done" rather hard. I'll reconsider...

I added the list of packages to the README and I'll think about a good way to use ASDF without QL and/or usability loss later. Thank you though!

I see, thanks. Now I need to read up about ASDF systems (I haven't fully understood defsystem yet). I'll extend the README tonight. :-)

That would basically include Quicklisp again. I thought I shouldn't?

No, it creates bundle you can load using only ASDF. The developer uses quicklisp, not the client

Use ASDF (https://common-lisp.net/project/asdf/), it is the de-facto standard in CL.

Quicklisp does not replace ASDF (it uses ASDF internally).