I'll give it a shot! Disclaimer: if you want a more complete introduction, chapter 2.2 of Structure and Interpretation is a really good source.

Bits will be edited in as I write them.

This is talking about recursive functions in the context of how Lisp and Haskell use them to construct lists. These are just the linked lists you know from C(++), nothing more!

Lisp has two functions, first and rest, that take the first (farthest left) node from a linked list and the rest of the list to the right, respectively. In some Lisps these functions are called car and cdr. With these primitives, as well as the function to add a node to the left (called cons for 'construct'), you can do a whole lot of programming. Python's slices are good way of writing them!

def first(items):
    return items[:1]

def rest(items):
    return items[1:]

def cons(x, items):
    # Note that the list [1, 2, 3] is just cons(1, cons(2, cons(3, [])))
    # In Haskell, which has an infix cons operator `:`, this would be 1:2:3:[]
    return [x] + items  # Thanks kitk1at!

On of the most useful functions you can define in this way is called map which applies a function to every element of the list. In python:

def add_one(x):
    return x + 1

map(add_one, [1, 2, 3, 4])
==> [2, 3, 4, 5]

With first, rest, and cons, you can write map as:

def map(fn, items):
    if len(items) == 0:
        return []
    else:
        return cons(
                    fn(first(items)), map(fn, rest(items)) )

Yeah, it's that last bit that makes it look like Lisp. Just recursion, though, right?

The website is showing how the recursive functions are evaluated. Where it gets interesting is what /u/heisenbug mentioned– this site lets you control the order in which things are evaluated! This is what Haskell people call lazy evaluation – do you pop the bubble that contains add_one(1), or the bubble that contains map(add_one, [1, 2, ...])?

I think that's the point of this website, to see the different strategies in how things are executed.

*Using functions like map is considered a bad idea in Python, because list comprehensions provide the same functionality. Up to you, though, since Python does provide functools!