         {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.
+  Although we have mentioned that the supervisor automatically expands
+  `{Stack, [:hello]}` to a child specification by calling
+  `Stack.child_spec([:hello])`, we haven't formally defined all of the
+  arguments accepted by `start_link/2` and `init/2`. Let's rectify that
+  now.
 
   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 map representing the child specification itself - as outlined in the
+      "Child specification" section
     * 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.
+      such as `{Stack, [:hello]}`. In this case, `Stack.child_spec([:hello])`
+      is called to retrieve the child specification
+    * a module - such as `Stack`. In this case, `Stack.child_spec([])`
+      is called to retrieve the child specification
 
   The second argument is a keyword list of options:
 

  There is a sixth key, called `:modules`, which is rarely changed and
  it is set automatically based on the value in `:start`.

  Most times, the behaviour module you are implementing will take care
  of setting up a proper `child_spec/1` for you. For example, `use Supervisor`
  will define a `child_spec/1` where the `:type` is set to `:supervisor`
  and the `:shutdown` is `:infinity`. Still, if you need to customize
  a certain behaviour, you can do so by defining your own `child_spec/1`
  function or by passing options on `use`. For example, to specify a
  `GenServer` with a shutdown limit of 10 seconds (10_000 milliseconds),
  one might do:

      use GenServer, shutdown: 10_000

  Let's understand what the `:shutdown` and `:restart` options control.

  ### Shutdown values (:shutdown)

  The following shutdown values are supported in the `:shutdown` option:

    * `:brutal_kill` - the child process is unconditionally terminated
      using `Process.exit(child, :kill)`.

    * any integer >= 0 - the amount of time in milliseconds that the
      supervisor will wait for children to terminate after emitting a

  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 start, shutdown and
  restart child processes.

  The child specification contains 5 keys. The first two are required
  and the remaining ones are optional:
