We can predict the performance of a program before we take the time to write code. In a large project, if we waited until after all the code was written to discover that something runs very slowly, it could be a major disaster, but if we do the analysis first we have time to discover speed problems and work around them. By analyzing an algorithm, we gain a better understanding of where the fast and slow parts are, and what to work on or work around in order to speed it up. It's one you probably wouldn't need to actually solve, but simple enough that it's easy to understand and maybe surprising that there are many different solutions. These children are too young to have children of their own until two years later.
Rabbits never die.
The natural measure would be in seconds, but it would be nice to have an answer that didn't change every time Intel came out with a faster processor. However, it is hard to guess from a piece of pseudo-code the exact number of instructions that a particular compiler would generate. To get a rough approximation of this, we try measuring in terms of lines of code. Each call to fib returns either one or two lines. Except for the two lines in each call, the time for n is the sum of the times for two smaller recursive calls.