anchor.diff:  
   (defun voice->vibration (vo)
     (declare (voice vo))
  -  (make-instance 'vibration :message (message-of vo)))
  +  (make-instance 'vibration :message (message-of vo)
  +		 :duration (duration-of vo)))
   
   
   (defmethod print-object ((p person) s)
  -  (print-unreadable-object (p s :type t :identity t)
  -    (format s "path: ~a name: ~a" (path p) (name-of p))))
  -
  -
  -(defmethod print-object ((csp csp-scenario) s)
  -  (with-accessors ((alice alice-of) (bob bob-of)
  -		   (a-can a-can-of) (b-can b-can-of)
  -		   (wire wire-of)) csp
  -    (print-unreadable-object (csp s :type t :identity t)
  -      (format s "path: ~a" (path csp)))))
  -
  +  (print-unreadable-object (p s)
  +    (format s "name: ~a" (name-of p))))
   
   
   ;; PERSON BEHAVIOUR
   
  -;; schedulable
  -(defmethod think ((p person) (evs list))
  -  (schedule p evs (make-instance 'event
  -				 :owner-path (path p)
  -				 :time (gettime evs)
  -				 :fn #'handle-input
  -				 :args (list (thought-in-of p)
  -					     nil))))
  -
  -
  -;; schedulable
  -(defmethod handle-input ((p person) (evs list) (in thought-in-port)
  -			 (str string))
  -  "thought-in ---> voice-out"
  -  (let ((vo (make-instance 'voice :message str)))
  -    (schedule p evs (make-instance 'event
  -				   :owner-path (path p)
  -				   :time (gettime evs)
  -				   :fn #'put
  -				   :args (list (voice-out-of p)
  -					       vo)))))
  -
  -
  -;; schedulable
  -(defmethod handle-input ((p person) (evs list) (in voice-in-port)
  +
  +(let ((phrases (list "Uh?" "Hello!" "Yes" "Really?" "No"
  +		     "Did you say something?"
  +		     "Please go away" "I'm calling the police"
  +		     "I love you!" "Do you love me?" "I hate you!"
  +		     "Just shut up.")))
  +
  +  (defun random-phrase ()
  +    (make-instance 'voice
  +		   :message (nth (random (length phrases))
  +				 phrases))))
  +
  +
  +(defmethod start-talking ((p person))
  +  (make-instance 'event
  +		 :owner p
  +		 :time (clock-of p)
  +		 :fn #'output
  +		 :args (list (voice-out-of p)
  +			     (random-phrase))))
  +
  +
  +(defmethod handle-input ((p person) (in voice-in-port)
   			 (vo voice))
  -  "voice-in ---> thought-out"
  -  (schedule p evs (make-instance 'event
  -				 :owner-path (path p)
  -				 :time (gettime evs)
  -				 :fn #'put
  -				 :args (list (thought-out-of p)
  -					     (message-of vo)))))
  +  (call-next-method)
  +  (make-instance 'event
  +		 :owner p
  +		 :time (clock-of p)
  +		 :fn #'output
  +		 :args (list (voice-out-of p)
  +			     (random-phrase))))
   
   
   ;; CAN BEHAVIOUR
   
  -;; schedulable
  -(defmethod handle-input ((c can) (evs list) (in voice-in-port)
  +(defmethod handle-input ((c can) (in voice-in-port)
   			 (vo voice))
     "voice-in ---> vibration-out"
  -  (schedule c evs (make-instance 'event
  -				 :owner-path (path c)
  -				 :time (gettime evs)
  -				 :fn #'put
  -				 :args (list (vibration-out-of c)
  -					     (voice->vibration vo)))))
  -
  -
  -(defmethod handle-input ((c can) (evs list) (in vibration-in-port)
  +  (call-next-method)
  +  (make-instance 'event
  +		 :owner c
  +		 :time (clock-of c)
  +		 :fn #'output
  +		 :args (list (vibration-out-of c)
  +			     (voice->vibration vo))))
  +
  +
  +(defmethod handle-input ((c can) (in vibration-in-port)
   			 (vi vibration))
     "vibration-in ---> voice-out"
  -  (schedule c evs (make-instance 'event
  -				 :owner-path (path c)
  -				 :time (gettime evs)
  -				 :fn #'put
  -				 :args (list (voice-out-of c)
  -					     (vibration->voice vi)))))
  +  (call-next-method)
  +  (make-instance 'event
  +		 :owner c
  +		 :time (clock-of c)
  +		 :fn #'output
  +		 :args (list (voice-out-of c)
  +			     (vibration->voice vi))))
   
   
   ;; WIRE BEHAVIOUR
   
  -;; schedulable
  -(defmethod handle-input ((w wire) (evs list) (in vibration-in-port)
  +(defmethod handle-input ((w wire) (in vibration-in-port)
   			 (vi vibration))
     "vibration-in ---> vibration-out"
  +  (call-next-method)
     (let ((out (if (eq in (a-vibration-in-of w))
   		 (b-vibration-out-of w)
   		 (a-vibration-out-of w))))
  -    (schedule w evs (make-instance 'event
  -				   :owner-path (path w)
  -				   :time (gettime evs)
  -				   :fn #'put
  -				   :args (list out vi)))))
  -
  -(defun fresh-csp-scenario ()
  -  (make-instance 'csp-scenario
  +    (make-instance 'event
  +		   :owner w
  +		   :time (clock-of w)
  +		   :fn #'output
  +		   :args (list out vi))))
  +
  +
  +;; LOGGING
  +
  +(defmethod handle-input :after ((sim simulator) (in in-port)
  +				(obj object))
  +  (format t "~&~a - ~a receives ~a through ~a~%"
  +	  (clock-of sim) sim obj in))
  +
  +
  +(defmethod output :after ((sim simulator) (out out-port)
  +			  (obj object))
  +  (format t "~&~a - ~a outputs ~a through ~a~%"
  +	  (clock-of sim) sim obj out))
  +
  +
  +(defun fresh-csp ()
  +  (make-instance 'csp
   		 :alice (make-instance 'person :name "Alice")
   		 :bob (make-instance 'person :name "Bob")
   		 :a-can (make-instance 'can)
   		 :b-can (make-instance 'can)
   		 :wire (make-instance 'wire)))
  -
  -
  -(defmethod run ((csp csp-scenario))
  -  (labels ((run-rec (csp evs)
  -	     (if (null evs)
  -		 csp
  -		 (multiple-value-call #'run-rec
  -		   (evolve csp evs)))))
  -    (with-accessors ((alice alice-of)) csp
  -      (multiple-value-bind (act evs)
  -	  (schedule alice nil
  -		    (make-instance 'event
  -				   :owner-path (path alice)
  -				   :time 0
  -				   :fn #'think))
  -	(run-rec (update-component csp act (id-of act))
  -		 evs)))))
  
positive.code:     :type vibration-out-port)))
  
  
  (defclass csp-scenario (simulator)
    ((alice
      :initarg :alice
      :initform (error ":alice missing")
  
negative.code:   nil)
  
  
  (defclass vibration (object)
    ((message
      :initarg :message
      :initform (error ":message missing")
      :reader message-of
      :type string)
     (duration
      :initarg :duration
      :initform (error ":duration missing")
      :reader duration-of
      :type time-type)))
  
  
  (defclass voice (object)
  