     (let [component (assoc component
                            :default-chan (or default-chan (async/chan 100))
                            :error-chan (or error-chan (async/chan 100))
-                           ;; This should have no buffer so that it doesn't grab a dispatch message and put it in
-                           ;; the buffer just before an error message comes in
+                           ;; This should have no buffer so that it doesn't grab a dispatch event and put it in
+                           ;; the buffer just before an error event comes in
                            :event-chan (async/chan))])
     (go-loop []
-      ;; Hmm... this actually doesn't have the semantics we want, since 1 default chan message could get
-      ;; through before the message chan is ready to take yet
+      ;; Hmm... this actually doesn't have the semantics we want, since 1 default chan event could get
+      ;; through before the event chan is ready to take yet
       (let [[event chan] (async/alts! [error-chan default-chan])]
         (async/>! event-chan event)))
     component)
   (stop [component]
     component)
   protocols/PDispatcher
-  (dispatch! [component message level]
+  (dispatch! [component event level]
     (go
       (async/>! 
         (if (= level :error) error-chan default-chan)
-        message)))
-  ;; Here, the message chan is just the dispatch chan...
+        event)))
+  ;; Here, the event chan is just the dispatch chan...
   (dispatcher-event-chan [component]
     ;; Don't know if this will compile properly TODO
     event-chan))
 
 (defn new-error-priority-dispatcher
   "Creates a new ErroPriorityDispatcher. Can customize :default-chan and :error-chan through options.
-  Idea is that Reactor will get error messages before other queued messages, but the mechanism is a little flawed.
-  Currently, it's still possible for a non error message to get through before the reactor is ready to consume from the event-chan.
+  Idea is that Reactor will get error events before other queued events, but the mechanism is a little flawed.
+  Currently, it's still possible for a non error event to get through before the reactor is ready to consume from the event-chan.
   May need to adjust the protocols."
   ([options]
    (map->ErrorPriorityDispatcher options))

   (new-strictly-ordered-dispatcher {})))


;; Any messages with level :error will get processed by the reactor before _any_ other dispatched messages.
(defrecord ErrorPriorityDispatcher [default-chan error-chan event-chan]
  ;; Should make pluggable config options for the chan creation
  component/Lifecycle



;; A signal sampler might have functions that let you plug in your own signal channels that you mix/merge/alt
;; whatever, to gate vs critical system control events.


;; ## Public API around dispatchers

(defn dispatch!
  "Dispatches event on the dispatcher component at the given level (:default if unspecified)."
  ([dispatcher event level]
   (protocols/dispatch! dispatcher event level))
  ([dispatcher event]
   (protocols/dispatch! dispatcher event :default)))

(defn dispatch-error!
  [datview event]
  (dispatch! datview event :error))


(defn event-chan [dispatcher]
  "Get the event channel for a dispatcher"
  (protocols/dispatcher-event-chan dispatcher))


