   the proper `:shutdown` value, ensuring it terminates within a reasonable
   interval.
 
+  Now that we understand the start and shutdown process, let's take a
+  complete look at all of the options provided in the child specification.
+
   ## Child specification
 
-  The child specification describes how the supervisor should start and
-  supervise a child process. We have learned that, when we invoked
-  `use GenServer`, a `Stack.child_spec/1` was automatically defined for
-  us. Let's invoke it and see what it returns:
-
-      Stack.child_spec([:hello])
-      #=> %{
-      #=>   id: Stack,
-      #=>   start: {Stack, :start_link, [[:hello]]},
-      #=>   restart: :permanent,
-      #=>   shutdown: 5000,
-      #=>   type: :worker
-      #=> }
+  The child specification describes how the supervisor start, shutdown and
+  restart child processes.
 
   The child specification contains 5 keys. The first two are required
   and the remaining ones are optional:

        {Stack, [:hello]}
      ], strategy: :one_for_one)

  However, children can be specified in three different formats and
  supervisors support different options. Let's formally define those.

  The first argument given to `start_link/2` is a list of children which may
  be either:

    * a module - such as `Stack`. In this case, it is equivalent to passing
      `{Stack, []}` (which means `Stack.child_spec/1` is invoked with an empty
      keywords list)
    * a tuple with a module as first element and the start argument as second -
      such as `{Stack, [:hello]}`. When such format is used, the supervisor
      will retrieve the child specification from the given module.
    * a map representing the child specification itself - such as the child
      specification map outlined in the previous section.

  The second argument is a keyword list of options:


  and to get the top of the stack by pattern matching.

  We can now start a supervisor that will start and supervise our
  stack process. The first step is to define a list of **child
  specifications** that control how each child behaves. Each child
  specification is a map, as shown below:

      children = [
        # The Stack is a child started via Stack.start_link([:hello])
        %{
          id: Stack,
          start: {Stack, :start_link, [[:hello]]}
        }
      ]

      # Now we start the supervisor with the children and a strategy
      {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)

      # After started, we can query the supervisor for information
      Supervisor.count_children(pid)
