Uhhh wait what? I don’t see how these two features are connected at all. I wish the post would elaborate on that. Feels like a non-sequitur.

Yes, other CLs (and me) agree. The author probably mean the interactive flow where you feed code to the running process instead. Similar to one does in Clojure, and Clojure doesn’t have any kind of images. Ref: https://twitter.com/stylewarning/status/1665754390639304707

hard to use effectively because it’s very easy to do accidental symbol capture if you don’t use gensym in the right places.

I can see how it is very easy to do accidental symbol capture in Scheme, which has a single namespace for symbols. Ignoring the fact that CL has different namespaces for variables, functions, classes, etc, symbols in CL are namespaced under a package. This results in accidental symbol capture being less frequent in practice. That said CL also gives you the tools to avoid the problem, as you mention.

If it was easy to do in CL, one would frequently run into bugs relating accidental symbol capture, do you know of any? To be clear, I have found macros were that should have used gensym but didn’t. I have not found bugs in the call-sites of said macros.

CLers scoffed at it because they said the cost was too high, and accidental symbol capture “wasn’t all that bad”.

The use of quotes without a reference looks like a strawman. Do you have a source for that? What I’ve seen people in the CL community argue is that hygienic macros are more complex and you can solve the problem with other means (gensym).

hygenic macros have other benefits (like improved error reporting when using the … pattern).

But the auto-gensym feature introduced by Clojure along with protections against non-gensym identifiers basically solves the same problem with a fraction of the conceptual overhead and lets you keep using the “obvious” defmacro style of CL without the danger

I wasn’t aware of that feature, seems like a reader macro to generate unique symbols. Looks similar to CL’s uninterned symbols, which is what gensym is built upon. CL has syntax for uninterned symbols, #:. The name of the symbol gensym returns is unimportant, as even if two gensymed symbols have the same name they will still be treated as different symbols.

* (eq '#:hello '#:hello) ; => NIL

(let ((sym-1 (let ((*gensym-counter* 42))
               (gensym)))
      (sym-2 (let ((*gensym-counter* 42))
               (gensym))))
  (format t "sym-1: ~A~%sym-2: ~A~%" sym-1 sym-2)
  (eq sym-1 sym-2))
;; sym-1: G42
;; sym-2: G42
;;  => NIL

I think he means something subtly different by ‘image-based development’ than most folks do. The common meaning of an image is persistent mutable runtime state, like a Smalltalk image. Common Lisp doesn’t have to have that, and I don’t believe that is how it is commonly used.

I think what he means is that the entire runtime system is available at read macros run, and at compile time, when macros run. But I could be wrong.