THE ECOSYSTEM
There is a surprising amount of open source code available for Lisp. The Awesome-CL (https://project-awesome.org/r/awesome-cl) page contains a curated list of open source libraries available.
The most common way to obtain any of these libraries is through quicklisp, the
defacto-standard library manager for Lisp. As I said before, ASDF by default
uses quicklisp to download systems defined in the :depends-on portion of the
defsystem if no local copy exists (in the ~/quicklisp folder). When you want
third-party libraries, you will likely begin by using quicklisp.
Using quicklisp is simple. Let's say you want to load the local-time system.
To do that:
(ql:quickload "local-time")
If you don't already have local-time in your ~/quicklisp folder, quicklisp
will download it from the quicklisp repository. After downloading it, it will
then load the system as if you had run asdf:load-system. To test it, try
running (local-time:now) in the REPL.
Quicklisp will download and load code from the quicklisp "dist". What if you
want to load your own local code? How do you create your own library that you
can add to a .asd file and load seamlessly like any other library?
To do that with Quicklisp, you can add code to either the ~/common-lisp or
~/quicklisp/local-projects folders.
ULTRALISP
Quicklisp is a repository that is only infrequently updated (by one guy). As a result, you might not be able to get the latest version of a project, or it may never be available at all on Quicklisp.
An alternative to Quicklisp is ultralisp. Ultralisp is a "dist" that is
installed on Quicklisp (which has its own default "dist" named quicklisp) and
that is updated every five minutes. If you go to https://ultralisp.org you can
get instructions on how to install and use it. I haven't ever used it, so I
can't give my opinion one way or the other.
In passing, I've seen people have trouble using Ultralisp because they may inadvertently install different versions of the same library and getting Quicklisp (the library manager, not the dist) to load one or the other can be a bit troublesome.
QLOT
Qlot is an alternative library dependency library, found at
https://qlot.tech/. It is designed to essentially solve "versioning" problems
above. It allows you to pin your dependencies to certain versions of
libraries–as found on the Quicklisp "dist".
Qlot is worthy of taking a closer look at. It includes useful command-line
commands and library dependencies are defined in separate qlfile and
qlfile.lock files, making it feel a bit more familiar to library management
systems found in other ecosystems. After getting set up, you might find it more
comfortable to use than Quicklisp or Ultralisp.
OCICL
ocicl is another alternative to Quicklisp that does more than just package
management. It also does linting and has project scaffolding capabilities. It's
developed by Anthony Green, a programmer at Red Hat. Its Github page states:
The main innovation behind ocicl is the idea of applying the ecosystem of tooling and services from the world of application container images to ordinary tarballs of Lisp code. In essence, OCI + CL = ocicl.
If you know what it means for software to be packaged as "OCI-compliant artifacts", you might find ocicl of interest. I'm not sophisticated enough to understand the value proposition, so I've never used it.
VEND
vend (https://github.com/fosskers/vend) is my preferred alternative to
Quicklisp. The vend philosophy is this: vendor dependencies, and make that
simple.
Unlike the other alternatives above, it makes no use of either Quicklisp the tool or the "dist". Instead, it downloads dependencies directly from git repositories. It has its own repository–just a list of libraries and their git repo link. You just configure the REPL to only load dependencies from your project's directory (you don't want it going on a scavenger hunt in other project folders).
The marketing copy from the vend Github readme states:
Why vend?
Dependency management in Common Lisp has traditionally centred around Quicklisp. A desire for access to more rapid package updates spawned Ultralisp. The need for version pinning and isolation birthed Qlot. The want for a better distribution system brought us ocicl.
But, could there be a simpler paradigm than just downloading the code and putting it right there?
With vend:
We need not perform bespoke installation scripts to get started. We need not wait for Quicklisp to update. We need not relegate all our systems to ~/common-lisp/. We need not worry about where ASDF is looking for systems. We need not fret over tools performing strange internal overrides. We need not manage extra config files or lockfiles. Plus, vend is actually an external tool with extra commands to help you inspect and manage your dependencies.
Finding and using the simplest way to do things is a matter of survival. Vend is
an important tool for simplifying our tech stack and empowering us to do more.
That's why for projects in the next chapter, we will be using vend.
I will explain how to install and use vend when it becomes necessary.