     {:noreply, {context, new_timer, state}}
   end
 
+  # ignore other database events.
+  #TODO(Connor) we might need to handle Sequence delete events?
   def handle_info({Database, _}, state), do: {:noreply, state}
 
+  # This is the timer message.
   def handle_info(:checkup, {context, _, state}) do
     now = get_now()
-    # debug_log "Doing checkup: #{inspect now}"
-    new_state = if now do
-      all_events =
-        context
-          |> Database.get_all(FarmEvent)
-          |> Enum.map(fn(%{body: actual}) -> actual end)
-
-      # debug_log "BEGIN CHECKUP"
-      {late_events, new} = do_checkup(context, all_events, now, state)
-      # debug_log "\r\n =======================\r\n"
-      unless Enum.empty?(late_events) do
-        Logger.info "Time for event to run at: #{now.hour}:#{now.minute}"
-        start_events(context, late_events, now)
-      end
-      new
-    else
-      state
-    end
+
+    # get all the farm_events.
+    all_events =
+      context
+        |> Database.get_all(FarmEvent)
+        |> Enum.map(fn(%{body: actual}) -> actual end)
+
+    # do checkup is the bulk of the work.
+    {late_events, new} = do_checkup(context, all_events, now, state)
+
+    #TODO(Connor) Conditionally start events based on some state info.
+    unless Enum.empty?(late_events) do
+      Logger.info "Time for event to run at: #{now.hour}:#{now.minute}"
+      start_events(context, late_events, now)
+    end
+
+    # Start a new timer.
     timer = Process.send_after self(), :checkup, @checkup_time
-    {:noreply, {context, timer, new_state}}
-  end
-
-  @spec start_events(Context.t, [Sequence.t | Regimen.t], DateTime.t)
-    :: no_return
-  defp start_events(_context, [], _now), do: :ok
-  defp start_events(%Context{} = context, [event | rest], now) do
-    spawn fn() ->
-      execute_event(event, context, now)
-    end
-    start_events(context, rest, now)
-  end
-
-  @spec get_now :: DateTime.t
-  defp get_now, do: Timex.now()
-
-  # is then more than 1 minute in the past?
-  defp is_too_old?(now, then) do
-    blah = fn(dt) -> "#{dt.hour}:#{dt.minute}:#{dt.second}" end
-    seconds = DateTime.to_unix(now, :second) - DateTime.to_unix(then, :second)
-    c = seconds > 60 # not in MS here
-    debug_log "is checking #{blah.(now)} - #{blah.(then)} = #{seconds} seconds ago. is_too_old? => #{c}"
-    # require IEx; IEx.pry
-    c
-  end
-
-  @type late_event :: Regimen.t | Sequence.t
-  @type late_events :: [late_event]
-
-  # TODO(Connor) turn this into tasks
-  # NOTE(Connor) yes i could have just done an Enum.reduce here, but i want
-  # it to be async at some point
-  @spec do_checkup(Context.t, [struct], DateTime.t, late_events, state)
-    :: {late_events, state}
+    {:noreply, {context, timer, new}}
+  end
+
+  # Check each events, and put late ones in `late_events` accumulator.
   defp do_checkup(context, list, time, late_events \\ [], state)
 
+  # When there are no more events to be enumerated.
   defp do_checkup(_, [], _now, late_events, state), do: {late_events, state}
 
-  defp do_checkup(%Context{} = ctx,
-    [farm_event | rest], now, late_events, state)
-  do
-    {new_late, last_time} = check_event(ctx,
-      farm_event, now, state[farm_event.id])
-
+  # Enumerate all the things.
+  defp do_checkup(%Context{} = ctx, [farm_event | rest], now, late_events, state) do
+    # new_late will be a executable event (Regimen or Sequence.)
+    {new_late_event, last_time} = check_event(ctx, farm_event, now, state[farm_event.id])
+
+    # update state.
     new_state = Map.put(state, farm_event.id, last_time)
-    if new_late do
-      do_checkup(ctx, rest, now, [new_late | late_events], new_state)
-    else
-      do_checkup(ctx, rest, now, late_events, new_state)
-    end
-  end
-
-  @spec check_event(Context.t, FarmEvent.t, DateTime.t, DateTime.t)
-    :: {late_event | nil, DateTime.t}
+    case new_late_event do
+      # if `new_late_event` is nil, don't accumulate it.
+      nil   -> do_checkup(ctx, rest, now, late_events, new_state)
+      # if there is a new event, accumulate it.
+      event -> do_checkup(ctx, rest, now, [event | late_events], new_state)
+    end
+  end
+
   defp check_event(%Context{} = ctx, %FarmEvent{} = f, now, last_time) do
     # Get the executable out of the database this may fail.
     mod_list = [Farmbot.Database, Syncable, f.executable_type |> String.to_atom]

    {nil, last_time}
  end

  # We only want to check if the sequence is started, and not finished.
  defp maybe_start_sequence(started?, finished?, farm_event, last_time, event, now)

  defp maybe_start_sequence(_started? = true, _finished? = false, farm_event, last_time, event, now) do
    {run?, next_time} = should_run_sequence?(farm_event.calendar, last_time, now)
    case run? do

  use     DebugLog
  use     GenServer
  alias   Database.Syncable.{
    # Sequence,
    # Regimen,
    FarmEvent
  }

  @checkup_time 20_000

  @doc "Start the FarmEvent Runner."
  def start_link(%Context{} = context, opts) do
    GenServer.start_link(__MODULE__, context, opts)
  end

  ## GenServer Callbacks.

  # State is a map of farm_event id's to last execution time.
  def init(%{database: db} = context) when is_pid(db) do
    Process.link(db)
    Database.hook(context, self())
