I am over-the-moon excited to share with you that today is the book birthday for my newest book, THE SPELLSHOP! It's a cozy fantasy about a rogue librarian and her best friend, a sentient spider plant, who take on the low-stakes market of illegal spellmaking and the high-risk business of starting over. And it's for anyone who is looking for a slice of joy, a bit of comfort, or just a deep breath.

I wrote this book to feel like a warm hug. Or like drinking hot chocolate. Or like eating really good raspberry jam. Or a cinnamon roll, with hot chocolate and maybe some raspberry jam on the side...

We've all been through a lot over the past few years, and I wrote THE SPELLSHOP for anyone who wants to escape into a world filled with kindness and enchantment.


Thank you to everyone at Macmillan/Tor/Bramble for bringing this book to life and gracing it with Lulu Chen's beautiful cover art and such lovely lavender sprayed edges!

If you'd like to learn more about the book or read the first chapter, please visit my website: http://www.sarahbethdurst.com/Spellshop.htm

I'm also going on book tour starting today, and I'm so excited!! If you'd like to join me at any of my tour stops, I'd love to see you! For details, see the Events page of my website.

Happy reading!!!

THE SPELLSHOP IS A NEW YORK TIMES BESTSELLER (#7), A USA TODAY BESTSELLER (#13), AND AN INDIE BESTSELLER (#10)!!!!!!!! I’M SOBBING!!!! Thank you so much to everyone at Bramble/Tor/Macmillan who made my dreams come true, including the incredible Ali Fisher, Dianna Vega, Caro Perny, and Julia Bergen! Thank you so much to my amazing agent Andrea Somberg who has been with me for 18 years and 28 books! And thank you to the wonderful booksellers and readers who made this possible!!!! I love you all so much!!!

I had an absolutely fantastic time on book tour for THE SPELLSHOP!!! Loved meeting so many wonderful readers and amazing booksellers! Thank you all so much! Just wanted to share some of my favorite pics from:

Fable Hollow Coffee & Bookshoppe in Knoxville, TN
Phoenix Books in Essex, VT, with Katherine Arden
Charis Books & More in Decatur, GA, with Kimberly Lemming
The Ripped Bodice in Brooklyn, NY, with Naomi Novik
The Poisoned Pen Bookstore in Scottsdale, AZ, with Rebecca Thorne
Flyleaf Books in Chapel Hill, NC, with T. Kingfisher

Next up: San Diego Comic Con!

It happened again. NYT. #7 again. I have no words, except THANK YOU. https://www.nytimes.com/books/best-sellers/2024/08/11/hardcover-fiction/

Very excited that THE SPELLSHOP is out today in Germany (with lovely purple edges)!!! Thank you to everyone at Fischer Tor! I like to think that Kiela, Caz, and Meep are celebrating their book birthday by selling spells and jam somewhere along the Rhine... 

https://www.fischerverlage.de/buch/sarah-beth-durst-spellshop-9783596710942

Eeeeeeee! Just saw that THE SPELLSHOP is a nominee for the Goodreads Choice Awards 2024!!! Thanks so much! This makes my day! I'm so thrilled and so grateful! Voting is open now! 

https://www.goodreads.com/choiceawards/readers-favorite-romantasy-books-2024

 

1) Order the fish in a restaurant on a Monday. It'll be three days old. 

2) Base-jumping. He just doesn't see the appeal.

3) Cheat on his wife. Sandra is his world. 

4) Open a new battlefront without adequately securing supply lines first. This one probably won't come up. But still, he'd never do it. Look at Napoleon. 

5) That. He'll do anything for love. But. 

Edit: For some reason, a lot of people seem to be complaining that none of these have anything to do with dishwashers. Why should they? Our dishwasher expert knows a lot about dishwashers, sure, but they're not his whole life. Get some perspective, people.

City Hall [US, Frederick Wiseman, 4] The latest of Wiseman’s distinctive epic-length observational documentaries studies the quotidian, procedural and human moments of human life as seen through the processes of municipal government in Boston, as held together by the thoughtful charisma of Mayor Martin Walsh. Improbably absorbing as always, this institutional cross-section offers a beguiling vision of an oasis of good government in the USA.

In a normal year I’d wait for the four and a half hour Wiseman documentary to arrive on television rather than taking up two time slots to watch it from the confines of a cinema seat at TIFF. But this is not such a year and with a digital screening you get a pause button when you need it. This is bound for PBS and due to the breadth of its subject matter will serve as an excellent introduction to those unfamiliar with this pillar of the documentary form. Or track down 2017’s Ex Libris, about the New York Public Library. In North America Wiseman’s filmography can be found on the Kanopy platform, which you may be able to access through your public library system.

The Father [UK, Florian Zeller, 4] Retired engineer (Anthony Hopkins) struggles to piece together the confusing reality of his living circumstances as his daughter (Olivia Colman) copes with his progressing dementia. Impeccably performed stage play adaptation puts the viewer inside the contradictory shifts of the protagonist’s subjective viewpoint.

Forget Draculas and Cthulhus. This is the real terror.

Summer of 85 [France, Francois Ozon, 4] Love between two young men in a French beach town leads to a bizarre crime. Teen emotions run high in a sunlit melodrama of Eros and Thanatos.

---

Capsule review boilerplate: Ratings are out of 5. I’ll be collecting these reviews in order of preference in a master post the Monday after the fest. Films shown on the festival circuit will appear in theaters, disc and/or streaming over the next year plus.

“Court of Ice and Roses” chessboard in shop!

Table of Contents

1. Dynamic Bindings
2. The problem
3. The solution
4. Dynamic slots
5. The context
6. Summary

Dynamic Bindings

Common Lisp has an important language feature called dynamic binding. It is possible to rebind a dynamic variable somewhere on the call stack and downstream functions will see that new value, and when the stack is unwound, the old value is brought back.

While Common Lisp does not specify multi-threading, it seems to be a consensus among various implementations that dynamic bindings are thread-local, allowing for controlling the computing context in a safe way.

Before we start experiments, let's define a package to isolate our namespace:

(defpackage "EU.TURTLEWARE.BLOG/DLET"
  (:local-nicknames ("MOP" #+closer-mop "C2MOP"
                           #+(and (not closer-mop) ecl) "MOP"
                           #+(and (not closer-mop) ccl) "CCL"
                           #+(and (not closer-mop) sbcl) "SB-MOP"))
  (:use "CL"))
(in-package "EU.TURTLEWARE.BLOG/DLET")

Dynamic binding of variables is transparent to the programmer, because the operator LET is used for both lexical and dynamic bindings. For example:

(defvar *dynamic-variable* 42)

(defun test ()
  (let ((*dynamic-variable* 15)
        (lexical-variable 12))
    (lambda ()
      (print (cons *dynamic-variable* lexical-variable)))))

(funcall (test))
;;; (42 . 12)

(let ((*dynamic-variable* 'xx))
  (funcall (test)))
;;; (xx . 12)

Additionally the language specifies a special operator PROGV that gives the programmer a control over the dynamic binding mechanism, by allowing passing the dynamic variable by value instead of its name. Dynamic variables are represented by symbols:

(progv (list '*dynamic-variable*) (list 'zz)
  (funcall (test)))
;;; (zz . 12)

The problem

Nowadays it is common to encapsulate the state in the instance of a class. Sometimes that state is dynamic. It would be nice if we could use dynamic binding to control it. That said slots are not variables, and if there are many objects of the same class with different states, then using dynamic variables defined with DEFVAR is not feasible.

Consider the following classes which we want to be thread-safe:

(defgeneric call-with-ink (cont window ink))

(defclass window-1 ()
  ((ink :initform 'red :accessor ink)))

(defmethod call-with-ink (cont (win window-1) ink)
  (let ((old-ink (ink win)))
    (setf (ink win) ink)
    (unwind-protect (funcall cont)
      (setf (ink win) old-ink))))

(defclass window-2 ()
  ())

(defvar *ink* 'blue)
(defmethod ink ((window window-2)) *ink*)

(defmethod call-with-ink (cont (win window-2) ink)
  (let ((*ink* ink))
    (funcall cont)))

The first example is clearly not thread safe. If we access the WINDOW-1 instance from multiple threads, then they will overwrite a value of the slot INK.

The second example is not good either, because when we have many instances of WINDOW-2 then they share the binding. Nesting CALL-WITH-INK will overwrite the binding of another window.

The solution

The solution is to use PROGV:

(defclass window-3 ()
  ((ink :initform (gensym))))

(defmethod initialize-instance :after ((win window-3) &key)
  (setf (symbol-value (slot-value win 'ink)) 'red))

(defmethod call-with-ink (cont (win window-3) ink)
  (progv (list (slot-value win 'ink)) (list ink)
    (funcall cont)))

This way each instance has its own dynamic variable that may be rebound with a designated operator CALL-WITH-INK. It is thread-safe and private. We may add some syntactic sugar so it is more similar to let:

(defmacro dlet (bindings &body body)
  (loop for (var val) in bindings
        collect var into vars
        collect val into vals
        finally (return `(progv (list ,@vars) (list ,@vals)
                           ,@body))))

(defmacro dset (&rest pairs)
  `(setf ,@(loop for (var val) on pairs by #'cddr
                 collect `(symbol-value ,var)
                 collect val)))

(defmacro dref (variable)
  `(symbol-value ,variable))

Dynamic slots

While meta-classes are not easily composable, it is worth noting that we can mold it better into the language by specifying that slot itself has a dynamic value. This way CLOS aficionados will have a new tool in their arsenal.

The approach we'll take is that a fresh symbol is stored as the value of each instance-allocated slot, and then accessors for the slot value will use these symbols as a dynamic variable. Here are low-level accessors:

;;; Accessing and binding symbols behind the slot. We don't use SLOT-VALUE,
;;; because it will return the _value_ of the dynamic variable, and not the
;;; variable itself.
(defun slot-dvar (object slotd)
  (mop:standard-instance-access
   object (mop:slot-definition-location slotd)))

(defun slot-dvar* (object slot-name)
  (let* ((class (class-of object))
         (slotd (find slot-name (mop:class-slots class)
                      :key #'mop:slot-definition-name)))
    (slot-dvar object slotd)))

(defmacro slot-dlet (bindings &body body)
  `(dlet ,(loop for ((object slot-name) val) in bindings
                 collect `((slot-dvar* ,object ,slot-name) ,val))
     ,@body))

Now we'll define the meta-class. We need that to specialize functions responsible for processing slot definitions and the instance allocation. Notice, that we make use of a kludge to communicate between COMPUTE-EFFECTIVE-SLOT-DEFINITION and EFFECTIVE-SLOT-DEFINITION-CLASS – this is because the latter has no access to the direct slot definitions.

;;; The metaclass CLASS-WITH-DYNAMIC-SLOTS specifies alternative effective slot
;;; definitions for slots with an initarg :dynamic.
(defclass class-with-dynamic-slots (standard-class) ())

;;; Class with dynamic slots may be subclasses of the standard class.
(defmethod mop:validate-superclass ((class class-with-dynamic-slots)
                                    (super standard-class))
  t)

;;; When allocating the instance we initialize all slots to a fresh symbol that
;;; represents the dynamic variable.
(defmethod allocate-instance ((class class-with-dynamic-slots) &rest initargs)
  (declare (ignore initargs))
  (let ((object (call-next-method)))
    (loop for slotd in (mop:class-slots class)
          when (typep slotd 'dynamic-effective-slot) do
            (setf (mop:standard-instance-access
                   object
                   (mop:slot-definition-location slotd))
                  (gensym (string (mop:slot-definition-name slotd)))))
    object))

;;; To improve potential composability of CLASS-WITH-DYNAMIC-SLOTS with other
;;; metaclasses we treat specially only slots that has :DYNAMIC in initargs,
;;; otherwise we call the next method.
(defmethod mop:direct-slot-definition-class
    ((class class-with-dynamic-slots) &rest initargs)
  (loop for (key val) on initargs by #'cddr
        when (eq key :dynamic)
          do (return-from mop:direct-slot-definition-class
               (find-class 'dynamic-direct-slot)))
  (call-next-method))

;;; The metaobject protocol did not specify an elegant way to communicate
;;; between the direct slot definition and the effective slot definition.
;;; Luckily we have dynamic bindings! :-)
(defvar *kludge/mop-deficiency/dynamic-slot-p* nil)
(defmethod mop:compute-effective-slot-definition
    ((class class-with-dynamic-slots)
     name
     direct-slotds)
  (if (typep (first direct-slotds) 'dynamic-direct-slot)
      (let* ((*kludge/mop-deficiency/dynamic-slot-p* t))
        (call-next-method))
      (call-next-method)))

(defmethod mop:effective-slot-definition-class
    ((class class-with-dynamic-slots) &rest initargs)
  (declare (ignore initargs))
  (if *kludge/mop-deficiency/dynamic-slot-p*
      (find-class 'dynamic-effective-slot)
      (call-next-method)))

Finally we define a direct and an effective slot classes, and specialize slot accessors that are invoked by the instance accessors.

;;; There is a considerable boilerplate involving customizing slots.
;;;
;;; - direct slot definition: local to a single defclass form
;;;
;;; - effective slot definition: combination of all direct slots with the same
;;;   name in the class and its superclasses
;;;
(defclass dynamic-direct-slot (mop:standard-direct-slot-definition)
  ((dynamic :initform nil :initarg :dynamic :reader dynamic-slot-p)))

;;; DYNAMIC-EFFECTIVE-SLOT is implemented to return as slot-value values of the
;;; dynamic variable that is stored with the instance.
;;;
;;; It would be nice if we could specify :ALLOCATION :DYNAMIC for the slot, but
;;; then STANDARD-INSTANCE-ACCESS would go belly up. We could make a clever
;;; workaround, but who cares?
(defclass dynamic-effective-slot (mop:standard-effective-slot-definition)
  ())

(defmethod mop:slot-value-using-class
    ((class class-with-dynamic-slots)
     object
     (slotd dynamic-effective-slot))
  (dref (slot-dvar object slotd)))

(defmethod (setf mop:slot-value-using-class)
    (new-value
     (class class-with-dynamic-slots)
     object
     (slotd dynamic-effective-slot))
  (dset (slot-dvar object slotd) new-value))

(defmethod mop:slot-boundp-using-class
  ((class class-with-dynamic-slots)
   object
   (slotd dynamic-effective-slot))
  (boundp (slot-dvar object slotd)))

(defmethod mop:slot-makunbound-using-class
  ((class class-with-dynamic-slots)
   object
   (slotd dynamic-effective-slot))
  (makunbound (slot-dvar object slotd)))

With this, we can finally define a class with slots that have dynamic values. What's more, we may bind them like dynamic variables.

;;; Let there be light.
(defclass window-4 ()
  ((ink :initform 'red :dynamic t :accessor ink)
   (normal :initform 'normal :accessor normal))
  (:metaclass class-with-dynamic-slots))

(let ((object (make-instance 'window-4)))
  (slot-dlet (((object 'ink) 15))
    (print (ink object)))
  (print (ink object)))

ContextL provides a similar solution with dynamic slots, although it provides much more, like layered classes. This example is much more self-contained.

The context

Lately I'm working on the repaint queue for McCLIM. While doing so I've decided to make stream operations thread-safe, so it is possible to draw on the stream and write to it from arbitrary thread asynchronously. The access to the output record history needs to be clearly locked, so that may be solved by the mutex. Graphics state is another story, consider the following functions running from separate threads:

(defun team-red ()
  (with-drawing-options (stream :ink +dark-red+)
    (loop for i from 0 below 50000 do
      (write-string (format nil "XXX: ~5d~%" i) stream))))

(defun team-blue ()
  (with-drawing-options (stream :ink +dark-blue+)
    (loop for i from 0 below 50000 do
      (write-string (format nil "YYY: ~5d~%" i) stream))))

(defun team-pink ()
  (with-drawing-options (stream :ink +deep-pink+)
    (loop for i from 0 below 25000 do
      (case (random 2)
        (0 (draw-rectangle* stream 200 (* i 100) 250 (+ (* i 100) 50)))
        (1 (draw-circle* stream 225 (+ (* i 100) 25) 25))))))

(defun gonow (stream)
  (window-clear stream)
  (time (let ((a (clim-sys:make-process #'team-red))
              (b (clim-sys:make-process #'team-blue))
              (c (clim-sys:make-process #'team-grue)))
          (bt:join-thread a)
          (bt:join-thread b)
          (bt:join-thread c)
          (format stream "done!~%")))  )

Operations like WRITE-STRING and DRAW-RECTANGLE can be implemented by holding a lock over the shared resource without much disruption. The drawing color on the other hand is set outside of the loop, so if we had locked the graphics state with a lock, then these functions would be serialized despite being called from different processes. The solution to this problem is to make graphics context a dynamic slot that is accessed with WITH-DRAWING-OPTIONS.

Summary

I hope that I've convinced you that dynamic variables are cool (I'm sure that majority of readers here are already convinced), and that dynamic slots are even cooler :-). Watch forward to the upcoming McCLIM release!

If you like technical writeups like this, please consider supporting me on Patreon.

Full Article