diff --git a/backward-interface.lisp b/backward-interface.lisp
index 3d3f18ea928e93981de1f739bf46ee13b90b3e96..07f366aa7492cc0657756cfddef8cb03fd98bf5a 100644
--- a/backward-interface.lisp
+++ b/backward-interface.lisp
@@ -36,24 +36,37 @@
   (define-condition compile-warned (compile-error) ())
 
   (defun component-load-dependencies (component)
+    "DEPRECATED. Please use COMPONENT-SIDEWAY-DEPENDENCIES instead."
     ;; Old deprecated name for the same thing. Please update your software.
     (component-sideway-dependencies component))
 
-  (defgeneric operation-forced (operation)) ;; Used by swank.asd for swank-loader.
-  ;; swank.asd looks at where the operation was forced to actually reload swank.
-  ;; But the only reason the action would be performed again is because it was forced;
-  ;; so the check is redundant. More generally, if you have to do it when the operation was forced,
-  ;; you should do it when not, and vice-versa, because it really shouldn't matter.
+  (defgeneric operation-forced (operation)
+    (:documentation "DEPRECATED. Assume it's (constantly t) instead."))
+  ;; This method exists for backward compatibility with swank.asd, its only user,
+  ;; that still uses it as of 2016-09-21.
+  ;;
+  ;; The magic PERFORM method in swank.asd only actually loads swank if it sees that
+  ;; the operation was forced. But except for the first time, the only reason the action
+  ;; would be performed to begin with is because it was forced; and the first time over,
+  ;; it doesn't hurt that :reload t :delete t should be used. So the check is redundant.
+  ;; More generally, if you have to do something when the operation was forced,
+  ;; you should also do it when not, and vice-versa, because it really shouldn't matter.
   ;; Thus, the backward-compatible thing to do is to always return T.
+  ;;
+  ;; TODO: change this function to a defun that always returns T.
   (defmethod operation-forced ((o operation)) (getf (operation-original-initargs o) :force))
 
 
   ;; These old interfaces from ASDF1 have never been very meaningful
   ;; but are still used in obscure places.
-  (defgeneric operation-on-warnings (operation))
-  (defgeneric operation-on-failure (operation))
-  (defgeneric (setf operation-on-warnings) (x operation))
-  (defgeneric (setf operation-on-failure) (x operation))
+  (defgeneric operation-on-warnings (operation)
+    (:documentation "DEPRECATED. Please use UIOP:*COMPILE-FILE-WARNINGS-BEHAVIOUR* instead."))
+  (defgeneric operation-on-failure (operation)
+    (:documentation "DEPRECATED. Please use UIOP:*COMPILE-FILE-FAILURE-BEHAVIOUR* instead."))
+  (defgeneric (setf operation-on-warnings) (x operation)
+    (:documentation "DEPRECATED. Please SETF UIOP:*COMPILE-FILE-WARNINGS-BEHAVIOUR* instead."))
+  (defgeneric (setf operation-on-failure) (x operation)
+    (:documentation "DEPRECATED. Please SETF UIOP:*COMPILE-FILE-FAILURE-BEHAVIOUR* instead."))
   (defmethod operation-on-warnings ((o operation))
     *compile-file-warnings-behaviour*)
   (defmethod operation-on-failure ((o operation))
@@ -67,12 +80,11 @@
     ;; As of 2.014.8, we mean to make this function obsolete,
     ;; but that won't happen until all clients have been updated.
     ;;(cerror "Use ASDF:SYSTEM-SOURCE-FILE instead"
-    "Function ASDF:SYSTEM-DEFINITION-PATHNAME is obsolete.
-It used to expose ASDF internals with subtle differences with respect to
-user expectations, that have been refactored away since.
-We recommend you use ASDF:SYSTEM-SOURCE-FILE instead
-for a mostly compatible replacement that we're supporting,
-or even ASDF:SYSTEM-SOURCE-DIRECTORY or ASDF:SYSTEM-RELATIVE-PATHNAME
+    "DEPRECATED. This function used to expose ASDF internals with subtle
+differences with respect to user expectations, that have been refactored
+away since. We recommend you use ASDF:SYSTEM-SOURCE-FILE instead for a
+mostly compatible replacement that we're supporting, or even
+ASDF:SYSTEM-SOURCE-DIRECTORY or ASDF:SYSTEM-RELATIVE-PATHNAME
 if that's whay you mean." ;;)
     (system-source-file x))
 
diff --git a/bundle.lisp b/bundle.lisp
index bf7b97d36b5896666ae9ecd0a7581f497c277001..23c4e382b2b15936bf2e7f3ac7831d210fb54882 100644
--- a/bundle.lisp
+++ b/bundle.lisp
@@ -72,6 +72,7 @@ itself."))
     (:documentation "Abstract operation for linking files together"))
 
   (defclass gather-op (bundle-op)
+    ;; TODO: rename the slot and reader gather-op to gather-operation
     ((gather-op :initform nil :allocation :class :reader gather-op)
      (gather-type :initform :no-output-file :allocation :class :reader gather-type))
     (:documentation "Abstract operation for gathering many input files from a system"))
@@ -80,10 +81,11 @@ itself."))
     (typep op 'monolithic-op))
 
   ;; Dependencies of a gather-op are the actions of the dependent operation
-  ;; (from gather-op reader, defaulting to lib-op or compile-op depending
-  ;; on the operation being monolithic or not) for all the (sorted) required components
-  ;; for loading the system, recursing either to other systems or sub-components
-  ;; depending on it being monolithic or not.
+  ;; for all the (sorted) required components for loading the system.
+  ;; Monolithic operations typically use lib-op as the dependent operation,
+  ;; and all system-level dependencies as required components.
+  ;; Non-monolithic operations typically use compile-op as the dependent operation,
+  ;; and all transitive sub-components as required components (excluding other systems).
   (defmethod component-depends-on ((o gather-op) (s system))
     (let* ((mono (operation-monolithic-p o))
            (deps
@@ -264,7 +266,7 @@ or of opaque libraries shipped along the source code."))
   (defclass prebuilt-system (system)
     ((build-pathname :initarg :static-library :initarg :lib
                      :accessor prebuilt-system-static-library))
-    (:documentation "Class for a system that comes precompiled with a static library file")))
+    (:documentation "Class for a system delivered with a linkable static library (.a/.lib)")))
 
 
 ;;;
diff --git a/plan.lisp b/plan.lisp
index 08e7398cd92e729c3d22e78ae916baab34210cd9..b45ecc172e09f222f89a730e2e1a191e871f6815 100644
--- a/plan.lisp
+++ b/plan.lisp
@@ -238,7 +238,8 @@ initialized with SEED."
     ;;   in the current image, or NIL if it hasn't.
     ;; Note that if e.g. LOAD-OP only depends on up-to-date files, but
     ;; hasn't been done in the current image yet, then it can have a non-T timestamp,
-    ;; yet a NIL done-in-image-p flag.
+    ;; yet a NIL done-in-image-p flag: we can predict what timestamp it will have once loaded,
+    ;; i.e. that of the input-files.
     (nest
      (block ())
      (let ((dep-stamp ; collect timestamp from dependencies (or T if forced or out-of-date)