 
 ;; ## Paths vs Points
 
-;; having all the code for dealing with a point is all well and good,
-;; but we need to be dealing with paths
-
-;; I've had a play with path generation before and besier curves gave
-;; a nice output
-
-;; De Casteljau's algorithm is the way we shall be coming up with
-;; paths
-
-;; first off we need to generate the anchor points for the curve
-
-;; to do this we will need to be able to:
-;;   - get a random number between two points (for distance, steps)
-;;   - get a random direction
-;;   - add vectors
+;; All of the gestures Pollock makes are fluid paths, even if the
+;; velocity along the path might be rather erratic. We now need to
+;; work out how to generate a path of points that we can then use the
+;; code we have written above to project and splatter.
+
+;; A [Bezier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+;; is a commonly used curve for generating a smooth curve that can be
+;; scaled indefinitely allowing us to have as many points along our
+;; path as we care to calculate.
+
+;; Bezier curves are defined by an list of control points, so we need
+;; to be able to generate a potential unbounded list of random control
+;; points that should give use limitless different paths to paint with.
+
+;; In order to generate a list of control points we will need to be
+;; able to:
+
+;;   - get a random number between two points for distance and steps,
+;;   - get a random unit vector for the initial direction of the generation,
+;;   - add vectors together to move between our control points.
 
 (defn random-between [lower-bound upper-bound]
   (+ lower-bound (rand (- upper-bound lower-bound))))

                                      total-distance))]
    (vector-divide-by-const difference-vector time-between)))

;; this calculation will leave off the last points velocity, so for
;; now we can just set it to 0

(defn path-velocities [path total-time]
  (let [total-distance   (path-length path)

(defn pick-a-colour []
  (nth paint-colours (rand-int (count paint-colours))))

;; Now we need to assemble all of the above functions into something
;; the resembles Jackson Pollock applying paint to a canvas. We start
;; with a point, project a path, work out masses and velocities,
;; project and then splatter. This is all then packaged up with a
;; colour for drawing onto our canvas.

(defn fling-paint []
  (let [position       (starting-point)
