How does this recursive algorithm work? One question from the Grokking Algorithms book:

Implement a max([]int) function, returning the biggest element in the array.

Here's my solution in Golang (adapted from the Python solution in the book):

func maxNumber(arr []int) (r int) {
    // base case
    if len(arr) == 2 {
        if arr[0] &gt; arr[1] {
            return arr[0]
        } else {
            return arr[1]
        }
    }

    // recursive case
    subMax := maxNumber(arr[1:])

    if arr[0] &gt; subMax {
        fmt.Println("arr[0] &gt; subMax")
        return arr[0]
    } else {
        fmt.Println("arr[0] &lt; subMax")
        return subMax
    }
}


It works, but I can wrap my head around it. How is the third block called if every time maxNumber(arr[1:]) is called it executes the function again, passing the array with one last element? If so, at some point in time it will hit the first block (base case) and return or the first element or the second.

I know the function works, but I'm missing the how.

Could someone help me around, explain like I'm 5 styles haha

Thanks!
The base case works because, if the array contains only 2 elements, it compares them and return the biggest. 
Starting from this assumption, the recursive call to the function maxNumber compare the maxnumber of the precedent call to the next element in the array. 
when the list has been read all the way to the end, the algorithm will return the max number of the whole list.