anchor.diff:                   (when (not (null task)) ;; if it's nil it means it's not done with yet so we do nothing.
                      (clock-remove task clock)))
                  results)
  -         (sleep (max 0 (- (absolute-beats-to-unix-time (+ beats granularity) clock) (unix-time-byulparan)))))
  +         (sleep (max 0 (- (absolute-beats-to-unix-time (+ beats granularity) clock) (cl-collider-now) (/ *latency* 2)))) ;; FIX: not sure if adding this halved latency is a good idea?
  +         ;; (sleep (max 0 (local-time:timestamp-difference (absolute-beats-to-timestamp (+ beats granularity) clock) (local-time:now))))
  +         ;; (sleep (max 0 (/ (- (absolute-beats-to-internal-time (+ beats granularity) clock) (get-internal-real-time)) internal-time-units-per-second)))
  +         )
          ;; FIX: do we need to acquire a lock on the clock's tempo as well?
          (incf beats granularity))))
   
  
positive.code:   "Get the current universal time with microseconds."
    (timestamp-to-universal (local-time:now)))
  
  (defun unix-time-byulparan () ;; FIX: pull request this to byulparan/scheduler??
    "Get the current unix time in the same format as byulparan/scheduler."
    (let ((now (local-time:now)))
      (+ (local-time:timestamp-to-unix now) (* (local-time:nsec-of now) 1.0d-9))))
  
  (defclass task ()
    ((gensym :initform (gensym))
     (clock :initform *clock* :initarg :clock)
     (item :initform nil :initarg :item)
     (start-time :initform nil :initarg :start-time)
     (next-time :initform nil :initarg :next-time)
     (nodes :initarg :nodes :initform (list))))
  
  (defparameter *clock* nil)
  
negative.code:     (if playing
          (progn (stop item) nil)
          (progn (play item) t))))
  
  (defun pdefs-playing (&optional (clock *clock*))
    "Get a list of the names of all pdefs playing on CLOCK."
    (loop :for i :in (slot-value clock 'tasks)
       :collect (slot-value (slot-value i 'item) 'key)))
  