Since  I spirit people away from python and javascript,  I thought  I better
have  a look  at whatever  python  is like now (I looked  at it last  around
2.7->3.0).   Here is my attempt at a pythonic recursive factorial benchmark.
```
def fact(x,f):
        if x==0:
                return(f);
        else:
                return(fact(x-1,x*f));
##The following single line seems to be part of function definition:

pass; ## No longer in the function definition
import timeit;
timeit.timeit(stmt=lambda:fact(x=993,f=1),number=10000);
```
>29.585241416003555
Seconds,  I imagine.   Boy is that precise.   With timeit,  x>993 or without
timeit, x>997 gave me 
```
RecursionError:     maximum   recursion   depth   exceeded   in   comparison
```
and  number=10000   let  me  run  the  benchmark   in  about   30   seconds.
What about lisp?  Disappointingly,  ECL misses the tail recursion  and stack
depth tops out at x being 8879. ECL uses two kinds of compilation.  'compile
does on-the-fly  byte-compilation  whereas 'compile-file  rolls through $CC.
The standard  is a little  nuanced on the topic.  
```
(defun fact (x f) (if (zerop x) f (fact (1- x) (* x f))))
(time (dotimes (count 10000) (fact 993 1)))
```
real time : 23.190 secs
run time : 27.590 secs
gc count : 2500 times
consed : 7437927024 bytes
NIL
```
...Kind of slow!
Let's        jump        into        sbcl        for        a        second:
```
* (defun fact (x f) (if (zerop x) f (fact (1- x) (* x f))))
* (time (dotimes (count 10000) (fact 993 1)))
Evaluation took:
  2.545 seconds of real time
  2.540000 seconds of total run time (2.440000 user, 0.100000 system)
  [ Run times consist of 0.276 seconds GC time, and 2.264 seconds non-GC time. ]
  99.80% CPU
  5,079,065,766 processor cycles
  5,923,816,112 bytes consed

NIL
```
Annoyingly,  while the standard constrains what the 'time macro reports,  it
does not specify  what the output will look like as you can see.  Let's  try 
ecl again.  after running  it through  the default 'compile-file. 
```ecl1.lisp
(defun fact (x f) (if (zerop x) f (fact (1- x) (* x f))))
(time (dotimes (count 10000) (fact 993 1)))
(si:quit)
```
```ecl
> (compile-file "ecl1.lisp" :load t)
real time : 10.029 secs
run time  : 14.120 secs
gc count  : 2359 times
consed    : 6801762144 bytes
```
A little better! Still more than four times worse than  sbcl.  We  can  tell
that the lisp compilers  aren't cheating in the benchmark because the number
of bytes consed (~allocated) looks consistent. 

POST SCRIPTUM
I was going to bang on a lot here, but I guess that can be another phlog.
If anyone wants to show me another python factorial definition/benchmark,
please point me to your phlog (whether or no you're a pro).
Lisp or another language either for that matter.