I think that the difference between the first and the second Count2Ten is an excellent example to show what recursion does, and what NOT to do in a recursive function.
A call like (setq a (count2ten 1.0)) returns 10 in the first instance and 1 in the second, even though the COND should return num when 10 is reached. I don't know if my english will suffice to explain it, but I'll give it a try.
A function that has been evaluated puts the value on the stack if further evaluations await. That way it can evaluate deeply nested functions and still keep track of the evaluation.
When a recursive function runs, it continuously puts the values that are returned from each call on the stack. Either it fills up the stack (and is caught by the interpreter) or, hopefully, it encounters a stop-value, in this case (>= num 10).
When that value is reached, it is returned to the calling function, which is the first instance of the function - or the first level. However, all levels still need to pop off the values that they put on the stack, so it starts backtracing. Unless they cause any further expressions to be evaluated during the backtrace they only pop off values till the stack is empty.
The second Count2Ten had a PRINC statement that followed the nested call. During each call to Count2Ten, it never got to that PRINC statement before calling itself. But on the backtrace it continues evaluation from the point that it stopped at on each level, which - except for the last called Count2Ten that stopped at ((>= num 10) num)) - is at the nested Count2Ten. This causes it to evaluate any following expressions left on each level and that's where the last PRINC statement comes into play. It returns the value of num while it is being pulled from the stack .. to the calling function!
The stack is last-in-first-out, so as num was incremented by each level it seems to be decrementing while backtracing (no calculation is done - it's only values taken from the stack). Finally, SETQ will recieve the value from the calling Count2Ten.
By the way, the "first" Count2Ten referred to above is
(defun Count2Ten (num)
(if (>= num 10)
num
(Count2Ten (+ 1 num))))
and the "second" is
(defun Count2Ten (num)
(cond
((>= num 10) num)
((princ num)(Count2Ten (+ 1 num))(princ num))))