     |> get_positions_to_create
   end
 
+  # Get all `{x, y}` coordinates of neighboring cells based on the input `{x, y}` and return them. 
   defp get_neighboring_positions({x, y}) do
      @neighbor_offsets
      |> map(fn {dx, dy} -> {x + dx, y + dy} end)
   end
 
+  # Filter out the `positions` which are not currently alive and return them.
   defp get_dead_neighbors(positions), do: filter(positions, &(lookup(&1) == nil))
 
+  # Lookup `position` in the Cell Registry. If it's in the Registry, get the process's `pid`.
+  # Make sure the cell with PID `pid` is alive, and if so, return it.
+  # Filter out `alive` processes since `terminate_child` will remove the cell from the Supervisor,
+  # but it may not be fully removed from the Registry yet.
   defp lookup(position) do
     Cell.Registry
     |> Registry.lookup(position)

    |> List.first
  end

  defp get_positions_to_create(positions) do
    positions
    |> filter(&(count_living_neighbors(&1) == 3))
  end

  defp count_living_neighbors(position) do
    position
    |> get_neighboring_positions

    |> length
  end

  # Returns a filtered list of all living positions within `positions`.
  defp get_living_neighbors(positions), do: filter(positions, &(lookup(&1) != nil))

  # Get the living neighbors of `position`.  If there are exactly 2 or 3, this `position`
  # lives, otherwise it will be destroyed.
  # Returns itself if it should be destroyed, otherwise returns an empty list.
  defp to_destroy(position) do
    position
    |> count_living_neighbors
