         points (map #(for-t % [x-vals y-vals z-vals]) (range 0 1 step-amount))]
     points))
 
-;; this can generate paths that go below the canvas, we should set
+;; This can generate paths that go below the canvas, we should set
 ;; these to 0 as it is the equivalent of painting on the canvas
 
 (defn ensure-above-canvas [path]

(defn vector-add [vector1 vector2]
  (map + vector1 vector2))

;; need to walk between a start and end position in a random fashion

(defn random-vector-between [lower upper]
  [(random-between lower upper)
   (random-between lower upper)
   (random-between lower upper)])

(defn random-path [position step-vector bounds]
  (cons position

                                           (random-vector-between (- 0 bounds) bounds))
                               step-vector bounds))))

;; We can now use this random-path lazy sequence to generate a list of
;; control points given an initial starting point and some bounding
;; variables. The distance, step and variation allow us to request long
;; winding paths or short flicks.

(defn control-points [position min-distance max-distance min-steps max-steps variation]
  (let [direction       (random-unit-vector)
        distance        (random-between min-distance max-distance)
        steps           (random-between min-steps max-steps)
