anchor.diff:  
   (defmethod print-object ((clock clock) stream)
     (with-slots (tempo beats) clock
  -    (format stream "#<CLOCK :tempo ~f :beats ~f>" tempo beats)))
  +    (format stream "#<~s :tempo ~f :beats ~f>" 'clock tempo beats)))
   
   (defun clock-add (item &optional (clock *clock*))
     (with-slots (tasks tasks-lock) clock
  
positive.code: 
  (defclass clock ()
    ((beats :initform 0 :documentation "The number of beats that have elapsed since the creation of the clock.")
     (tempo :initarg :tempo :initform 1 :accessor tempo :documentation "The tempo of the clock, in beats per second.")
     (granularity :initarg :granularity :initform 1/10 :documentation "How often the clock \"wakes up\" to process events in each beat. Shouldn't need to be adjusted.")
     (tasks :initform nil :documentation "The list of tasks that are running on the clock.")
     (tasks-lock :initform (bt:make-lock) :documentation "The lock on the tasks to make the clock thread-safe.")
     (unix-time-at-tempo :initform (cl-collider-now) :documentation "The Unix time when the tempo was last changed.")
     (timestamp-at-tempo :initform (local-time:now) :documentation "The local-time timestamp when the tempo was last changed.")
     (time-at-tempo :initform (get-internal-real-time) :documentation "The internal real time when the tempo was last changed.")
     (when-tempo-changed :initform 0 :documentation "The number of beats on the clock when the tempo was last changed.")))
  
  (defmethod (setf tempo) (value (item clock))
    (clock-add (event :type :tempo-change :tempo value) item))
  
  (defun timestamp-to-universal (timestamp)
    "Convert a local-time timestamp to a universal time, perserving microseconds."
    (+ (local-time:timestamp-to-universal timestamp)
       (/ (local-time:timestamp-microsecond timestamp) 1000000)))
  
  (defun current-universal-time ()
    "Get the current universal time with microseconds."
    (timestamp-to-universal (local-time:now)))
  
  (defun cl-collider-now () ;; FIX: pull request this to byulparan/scheduler??
    "Get the current unix time in the same format as byulparan/scheduler."
    (timestamp-to-cl-collider (local-time:now)))
  
  (defclass task ()
    ((gensym :initform (gensym))
  
negative.code: ;; * I use the local-time system instead of Lisp's built-in get-internal-real-time function because local-time is more accurate and is portable. For example, CMUCL's internal-time-units-per-second is only 100, which is pretty low. A local-time timestamp includes nanoseconds. In some implementations, local-time derives nanoseconds from less granular units of time, however it looks like it's still more accurate than using internal time would be... I'm not sure how much all of the above really matters, though, since the sleep function that we use is not guaranteed to be accurate either.
  
  ;; FIX: changing :instrument in pmono causes the old one to stay playing.
  ;; FIX: get rid of clock's "granularity" slot?
  ;; FIX: don't play "expired" events... i.e. if the event should have already ended by the time we get around to playing it, just don't play it. this way, if the user takes too long to select a restart when an error occurs on the clock, the events won't be played all at once.
  ;; FIX: print a warning after the clock has finished "catching up"... or perhaps print a warning each time the sleep amount is 0?
  
  (in-package :cl-patterns)
  
  (defparameter *clock* nil
    "The default clock to run tasks on.")
  
  (defun release (node)
    "Placeholder method; override this in cl-patterns' audio backend."
  