anchor.diff:    ((hostname :initarg :hostname :reader hostname)
      (port :initarg :port :reader port)
      (socket :initform nil))
  -  (:documentation "This is a kell that represents the processes running on a particular
  -                   host. It is opaque from the current machine."))
  +  (:documentation "This is a kell that represents the processes running on a
  +                   particular host. It is opaque from the current machine."))
   
   (defmethod print-object ((obj host-kell) stream)
     (format stream "[~a <~a:~d>~:[ ~a~;~]]"
  
positive.code:                    (loop for client = (sockets:accept-connection socket :wait t)
                       do (loop do
                            (handler-case (let ((process (eval (read client))))
                                            (add-process process (parent *local-kell*)))
                              (end-of-file () (return))
                              (kiln-error (c) (handle-error c))))
                       (close client))
  
negative.code: ;;; in the queue to be tried again.
  
  
  ;;; whenever a process is added to a network kell, we share the process across
  ;;; all hosts inside that kell it gets added to each of their event queues. So,
  ;;; the network kells should basically be in sync.
  ;;; 
  ;;; When a process in a network kell is matched, its removal notice is sent to
  ;;; all hosts. Each has to reply that it has been removed before the reaction
  ;;; actually occurs.
  ;;; 
  ;;; If there's a timeout, the host that times out is passivated, and a notice is
  ;;; sent to all hosts to passivate that host.
  
  (defvar *top-kell*)
  (defvar *local-kell*)
  