How to start with Emacs and Lisp development?

marcuskammer

I want to share my current Emacs / Lisp setup:

(defvar mk/hyperspec-dir-locations
  '("~/cl-sites/HyperSpec-7-0/HyperSpec/"
    "~/HyperSpec-7-0/HyperSpec/")
  "List of possible locations where the local HyperSpec could reside.")

(defun mk/hyperspec-dir ()
  "Finds and returns the URI of the local HyperSpec directory.
Uses `mk/hyperspec-dir-locations' to find the directory."
  (let ((dir (seq-find 'file-directory-p mk/hyperspec-dir-locations)))
    (if dir
        (concat "file://" (and (eq system-type 'windows-nt) "/") (expand-file-name dir))
      nil)))

(setq common-lisp-hyperspec-root (mk/hyperspec-dir))

(use-package lisp-mode
  :ensure nil
  :mode (("\\.lisp$" . lisp-mode)
         ("\\.lsp$" . lisp-mode)
         ("\\.cl$" . lisp-mode)
         ("\\.asd$" . lisp-mode)
         ("\\.sexp\\'" . lisp-data-mode))
  :hook ((lisp-mode . (lambda () (when flymake-mode (flymake-mode -1)))))
  :init
  (setq inferior-lisp-program "sbcl --noinform")
  :config
  (setq-local comment-start ";; ")
  (setq-local lisp-indent-function 'common-lisp-indent-function))

(use-package sly
  :defer t)

Hyperspec can be downloaded from the following page https://www.lispworks.com/downloads/documentation.html

cryptk

Thanks for sharing your config! I didn't know I could have a local copy of the Hyper Spec.

Regarding documentation, is there other ways of getting information from packages' manuals? I'm thinking of something similar to Emacs help buffers and Info.

I'm only aware of sly-apropos* commands and have been using the following to get information about symbols:

  ;; Copied from https://github.com/enzuru/completing-read-sly
  (defun my/sly-completing-read-search ()
    "Send apropos command to SLY."
    (sly-eval `(common-lisp:apropos-list "" nil t)))

  (defun my/sly-completing-read ()
    "Get list of symbols available in your SLY session."
    (interactive)
    (sly-describe-symbol
     (completing-read "Lookup symbol in SLY: "
                      (my/sly-completing-read-search)))))

marcuskammer

cryptk Package manuals or documentations would be diffcult because there is no documentation standard in common lisp (except docstrings). What I recognized is that most developers provide a README.md within the git repository.

ggxx

The Problem

Someone once lamented that sly was opening so many windows, and Emacs was placing them in awkward locations. To solve this, I tried to come up with some display-buffer-alist rules to place sly windows more predictably.

Keeping sly's new windows under control

The source code gets the majority of the screen space.
The REPL and debugger are allocated bottom-side windows in slots 0 and 1 respectively.
Windows for documentation and the inspector are given right-side windows in slots 0 and 1 respectively.

When all the windows are active, it might look like this.

cap_20250529 06:29:05

The Config

(use-package sly
  :ensure t
  :config
  (let ((patterns '(("\\*sly-mrepl"
                     (display-buffer-in-side-window)
                     (side . bottom)
                     (slot . 0)
                     (window-height . 22))
                    ("\\*sly-db"
                     (display-buffer-in-side-window)
                     (side . bottom)
                     (slot . 1))
                    ("\\*sly-inspector"
                     (display-buffer-in-side-window)
                     (side . right)
                     (slot . 1)
                     (window-width . 80))
                    ("\\*sly-description"
                     (display-buffer-in-side-window)
                     (side . right)
                     (slot . 0)
                     (window-width . 80)))))
    (cl-loop for p in patterns
             do (add-to-list 'display-buffer-alist p)))
  (setopt inferior-lisp-program "/usr/bin/sbcl")
  (setopt org-babel-lisp-eval-fn #'sly-eval))

The Teacher

Thanks to @protesilaos for explaining display-buffer-alist so well.

Original

This was originally posted on github.