   (let [program (if (map? (:program config))
                   (:program config)
                   (try
-                    (resolve-program (:data-connector config) (evaluate (:program config) config))
+                    (resolve-program (:data-connector config)
+                                     (evaluate (:program config) config))
                     (catch Exception e
                       (die
-                        "The configuration must have a program property, which must resolve to a valid yaml document:"
+                        (str "The configuration must have a program property, "
+                             "which must resolve to a valid yaml document:")
                         (.getMessage e)))))
         config (assoc config :env (evaluate (:env config) config))
         exit (try

                   (-> m :requires))
        missing (remove #(-> % second true?)
                        (map (fn [v]
                               [v (or ;; Is it both boolean and true, signifying a default value exists?
                                      (and (bool? v)
                                           (true? v))
                                      ;; Or is it a keyword and found in the current env?
                                      (and (keyword? v)
                                           (not (nil? (-> env v)))))])
                             vars))]
    (if-not (empty? missing)
      ;; If some of the `requires` interfaces are missing, don't bother running it, and
      ;; return nil.
      (throw (AssertionError. (format "Some required inputs are missing for module `%s`.\nMissing: %s\n\n"
                (:name m)
                (into [] (map first missing))
                )))
      #_(log :error
        (format "Some required inputs are missing for module `%s`.\nMissing: %s\n\nEnvironment:\n%s"
                (:name m)
                (into [] (map first missing))
                env))
      ;; All `requires` interfaces exist, so we're a "go."
      ;; Run the checkpoints. Each checkpoint run will return its return code and
      ;; the vars that should be added to the env.

              (-> config :node-manager (invoke checkpoint :local) (assert-checkpoint config {})))))
    ))

(defn checkpoint-env
  [env checkpoint]
  (let [out-arr (-> checkpoint :out :keys first keyword)
        err-arr (-> checkpoint :err :keys first keyword)
        exit-arr (-> checkpoint :exit :keys first keyword)
        success-arr (-> checkpoint :success :keys first keyword)
        out (-> checkpoint :out :value)
        err (-> checkpoint :err :value)
        exit (-> checkpoint :exit :value)
        success (-> checkpoint :success :value)]
    (reduce (fn [env [k v]]
              (if-not (nil? k)
                (assoc env k v) env))
            env
            [[out-arr (conj (get env out-arr) out)]
             [(-> checkpoint :out :keys second keyword) out]
             [err-arr (conj (get env err-arr) err)]
             [(-> checkpoint :err :keys second keyword) err]
             [exit-arr (conj (get env exit-arr) exit)]
             [(-> checkpoint :exit :keys second keyword) exit]
             [success-arr (conj (get env success-arr) success)]
             [(-> checkpoint :success :keys second keyword) success]])))

(defn run-module
  [m c]
