anchor.diff:      :when (and pt (< pt ot)) :do (setf ot pt)
       :finally (return ot)))
   
  +;; XXX I am suspicious of this code since if you pass it a pathname to
  +;; a file which doesn't exist, the newest timestamp is the most in the
  +;; past timestamp which could exist.
   (defun newest-timestamp (pathnames)
     (loop :with nt = most-negative-single-float
       :for p :in pathnames
  
positive.code:     (&rest keys &key
       source-registry setup verbosity output-path
       build lisp-implementation lisp-binary-path define-feature undefine-feature
       disable-cfasl master object-directory use-base-image profiling debugging force)
    (declare (ignore source-registry setup verbosity
                     lisp-implementation lisp-binary-path define-feature undefine-feature
                     disable-cfasl master object-directory use-base-image debugging))
    (with-maybe-profiling (profiling)
      (apply 'handle-global-options keys)
      (simple-build build :output-path output-path :force force)))
  
negative.code:     :when (and pt (> pt nt)) :do (setf nt pt)
      :finally (return nt)))
  
  ;; XXX Broken when files are written in subsecond intervals.
  ;; XXX Touches the disk too much to get timestamps.
  (defun all-newer-pathnames-p (output-pn input-pn)
    (and
     ;; If any output files don't exist, then they can't possibly be
     ;; newer than the inputs!
     (every #'safe-file-write-date output-pn)
     ;; If any input files have newer timestamps than output files...
     (>= (newest-timestamp input-pn)
         (oldest-timestamp output-pn))))
  
  ;; FIXME XXX Test this!
  (defun run-computation (env computation &key force)
    (let* ((inputs (computation-inputs computation)) ; a grain
  	 (outputs (computation-outputs computation)) ; a grain
  