 
       def init(_init_arg) do
         children = [
-          {Stack, [:hello]}
+          {Counter, 0}
         ]
 
         Supervisor.init(children, strategy: :one_for_one)

        @impl true
        def init(_init_arg) do
          children = [
            {Stack, [:hello]}
          ]

          Supervisor.init(children, strategy: :one_for_one)

  ## Examples

  In order to start a supervisor, we need to first define a child process
  that will be supervised. As an example, we will define a `GenServer`,
  a generic server, that keeps a counter. Other processes can then send
  messages to this process to read the counter and bump its value.

  > Note: in practice you would not define a counter as a GenServer. Instead,
  > if you need a counter, you would pass it around as inputs and outputs to
  > the functions that need it. The reason we picked a counter in this example
  > is due to its simplicity, as it allows us to focus on how Supervisors work.

      defmodule Counter do
        use GenServer

        def start_link(arg) when is_integer(arg) do
          GenServer.start_link(__MODULE__, arg, name: __MODULE__)
        end

        ## Callbacks

        @impl true
        def init(counter) do
          {:ok, counter}
        end

        @impl true
        def handle_call(:get, _from, counter) do
          {:reply, counter, counter}
        end

        def handle_call({:bump, value}, _from, counter) do
          {:reply, counter, counter + value}
        end
      end

  The `Counter` receives an argument on `start_link`. This argument
  is passed to the `init/1` callback which becomes the initial value
  of the counter. Our counter handles two operations (known as calls):
  `:get`, to get the current counter value, and `:bump`, that bumps
  the counter by the given `value` and returns the old counter.

  We can now start a supervisor that will start and supervise our
  counter 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 Counter is a child started via Counter.start_link(0)
        %{
          id: Counter,
          start: {Counter, :start_link, [0]}
        }
      ]

