Do You Have to Use (ASDF:load-system :xxxx) and (ql:quickload :yyyy) Every Time You Work in Lisp?

If you’re diving into the world of Lisp programming, you’ve probably come across commands like (ASDF:load-system :xxxx) and (ql:quickload :yyyy). These are essential tools for managing systems and libraries in Lisp, but they can feel a bit confusing at first. One question that pops up a lot is: Do you really need to run these every single time you start working? The short answer? It depends—but don’t worry, I’m here to break it all down for you in plain, simple English.

In this guide, we’ll explore what these commands do, why they’re so important in Lisp, and whether you have to type them every time you sit down to code. We’ll also look at ways to make your workflow smoother, so you can spend less time fiddling with setup and more time building awesome projects. Whether you’re a Lisp newbie or a seasoned coder, you’ll walk away with a clear understanding of how to handle ASDF:load-system and ql:quickload in Lisp. Let’s get started!

Table of contents

What Are ASDF and Quicklisp in Lisp?

Before we dive into the “do you have to” part, let’s get a handle on what these tools are and why they matter.

Understanding ASDF: The Build System for Lisp

ASDF stands for Another System Definition Facility. Think of it as a build tool—like make for C or Maven for Java—but designed specifically for Lisp. It helps you organize and load your Lisp projects, which are called “systems.” A system is just a collection of Lisp files (and sometimes dependencies) that work together to do something useful.

When you run (ASDF:load-system :xxxx), you’re telling Lisp to find a system named :xxxx, load its files, and compile anything that needs compiling. The :xxxx part is a placeholder for the name of your system—like :my-cool-app or :cl-ppcre (a popular regex library).

Understanding Quicklisp: The Package Manager

Quicklisp, on the other hand, is like pip for Python or npm for JavaScript. It’s a library manager that makes it super easy to download and install Lisp libraries from the internet. When you type (ql:quickload :yyyy), you’re asking Quicklisp to fetch a library named :yyyy, download it if it’s not already on your system, and load it into your Lisp environment.

For example, (ql:quickload :cl-json) would grab a JSON parsing library and make it ready to use. Quicklisp relies on ASDF under the hood to actually load the system once it’s downloaded.

How They Work Together

Here’s where it gets interesting: ASDF and Quicklisp are a team. Quicklisp uses ASDF to load the libraries it downloads. So when you run (ql:quickload :yyyy), Quicklisp might internally call (ASDF:load-system :yyyy) after fetching the files. But you can also use (ASDF:load-system :xxxx) on its own for systems that are already on your computer—like your own projects or libraries Quicklisp didn’t install.

Now that we’ve got the basics, let’s tackle the big question: Do you need to run these every time?

Do You Have to Run (ASDF:load-system :xxxx) Every Time?

The answer depends on how you’re working with Lisp. Let’s break it down step-by-step.

Scenario 1: Starting a Fresh Lisp Session

Imagine you’ve just opened your Lisp environment—like SBCL (Steel Bank Common Lisp) or CCL (Clozure Common Lisp)—in your terminal. You type sbcl or ccl, hit Enter, and you’re greeted with a blank REPL (Read-Eval-Print Loop). At this point, nothing is loaded—no systems, no libraries, just pure, empty Lisp.

If you want to work with a system you’ve written (say, :my-project), you’ll need to load it with (ASDF:load-system :my-project). Why? Because Lisp doesn’t “remember” what you loaded in your last session. Each time you start a new REPL, it’s a clean slate. So yes, in this case, you do have to run (ASDF:load-system :xxxx) every time you start fresh.

Scenario 2: Working on the Same Session

Now, let’s say you’ve already loaded :my-project with (ASDF:load-system :my-project) in your current REPL session. You’ve been coding for an hour, tweaking functions and testing stuff. Do you need to run it again? Nope! Once a system is loaded in your session, it stays loaded until you quit the REPL or restart Lisp. You can keep using its functions and variables without reloading.

Scenario 3: Making Changes to Your Code

What if you edit your project’s files—like adding a new function to my-project.lisp—and want those changes to show up? Here’s where it gets tricky. Running (ASDF:load-system :xxxx) again won’t always pick up your changes automatically. ASDF is smart, but it only recompiles files if it thinks they’ve changed and need rebuilding. If you want to force a reload, you might need to:

• Restart your REPL and run (ASDF:load-system :xxxx) again.
• Use (ASDF:load-system :xxxx :force t) to make ASDF recompile everything.

So, while you don’t always need to rerun it in the same session, you might have to if your code changes.

Do You Have to Run (ql:quickload :yyyy) Every Time?

Quicklisp follows a similar logic, but with a twist because it’s tied to downloading libraries.

Scenario 1: First-Time Installation

The first time you run (ql:quickload :yyyy) for a library (like :cl-json), Quicklisp checks if it’s already on your system. If not, it downloads it, installs it, and loads it using ASDF. After that, the library is saved locally—usually in ~/quicklisp/—so you don’t have to download it again.

But here’s the catch: Just like with ASDF, a fresh Lisp session starts empty. Even though :cl-json is on your hard drive, it’s not loaded until you run (ql:quickload :cl-json) in that session. So yes, you’ll need to run it every time you start a new REPL.

Scenario 2: Already Installed Libraries

Once a library is installed, (ql:quickload :yyyy) skips the download step and just loads it. This is faster, but you still have to run the command in each new session. If you’re in the same REPL and already ran (ql:quickload :yyyy), you don’t need to do it again—unless you’ve unloaded it manually (more on that later).

Scenario 3: Updating Libraries

What if a new version of :yyyy comes out? Quicklisp doesn’t automatically update libraries. You’d need to run (ql:update-all-dists) to fetch the latest versions, then (ql:quickload :yyyy) to load the updated one. So, in this case, you might rerun it to get the freshest code.

Why Does Lisp Work This Way?

If you’re coming from languages like Python or JavaScript, this might feel like extra work. In Python, you import a module once in your script, and it’s good to go. So why does Lisp make you load systems and libraries every time you start?

The REPL-Driven Workflow

Lisp is all about interactive development. The REPL lets you write, test, and tweak code on the fly. But to keep things flexible, it doesn’t assume anything about your environment when you start. This “clean slate” approach gives you control—you decide what to load and when.

Persistent vs. Ephemeral State

Unlike some languages that bundle everything into a single executable, Lisp keeps your session’s state in memory. When you close the REPL, that state disappears. Tools like ASDF and Quicklisp don’t “install” libraries permanently into your Lisp image—they load them temporarily for that session.

How to Avoid Running These Commands Every Time

Okay, so we’ve established that yes, you usually need to run (ASDF:load-system :xxxx) and (ql:quickload :yyyy) at the start of each session. But typing them over and over can get old fast. Here’s how to make your life easier.

Option 1: Use an Initialization File

Most Lisp implementations let you set up an initialization file (like .sbclrc for SBCL) that runs commands automatically when you start. Add this to your ~/.sbclrc:

(require :asdf)
(ql:quickload :yyyy)          ; Load your favorite library
(asdf:load-system :xxxx)      ; Load your project

Now, every time you start SBCL, those systems and libraries load without you lifting a finger.

Option 2: Save a Lisp Image

Lisp lets you save your current session as an “image”—a snapshot of everything loaded in memory. With SBCL, you can do:

(ql:quickload :yyyy)
(asdf:load-system :xxxx)
(sb-ext:save-lisp-and-die "my-image.core")

Next time, start Lisp with:

sbcl --core my-image.core

Boom—your libraries and systems are already loaded!

Option 3: Use an IDE Like SLIME

If you’re using Emacs with SLIME (Superior Lisp Interaction Mode for Emacs), you can set up your project to load everything automatically. Add a few lines to your .emacs file or SLIME config, and it’ll handle (ql:quickload :yyyy) and (ASDF:load-system :xxxx) when you connect to the REPL.

Option 4: Write a Load Script

Create a simple Lisp file (e.g., load.lisp) with:

(ql:quickload :yyyy)
(asdf:load-system :xxxx)

Then, start Lisp with:

sbcl --load load.lisp

This is quick and portable—perfect for small projects.

Table: When Do You Need to Run These Commands?

Here’s a quick reference to sum it up:

Best Practices for Using ASDF:load-system and ql:quickload in Lisp

To wrap up, here are some tips to keep your Lisp workflow smooth:

• Document Your Setup: Keep a README with the exact commands to load your project.
• Test in a Clean Environment: Occasionally start a fresh REPL to ensure your load commands work.
• Stay Updated: Run (ql:update-client) and (ql:update-all-dists) periodically to keep Quicklisp current.
• Leverage Tools: Use SLIME, initialization files, or images to save time.

Conclusion: Streamline Your Lisp Experience

So, do you have to run (ASDF:load-system :xxxx) and (ql:quickload :yyyy) every time you work in Lisp? In a fresh session, yes—but you don’t have to let it slow you down. With tricks like initialization files, saved images, or IDE setups, you can make loading systems and libraries a breeze.

Lisp’s flexibility is one of its superpowers, and understanding ASDF:load-system and ql:quickload in Lisp is key to unlocking that power. Next time you fire up your REPL, you’ll know exactly what to do—and how to do it faster. Happy coding!

Resources

• Do You Need to Run ASDF:load-system and ql:quickload Every Time You Work in Lisp?
• Quicklisp Homepage
• SBCL Manual
• SLIME GitHub