On 2/23/2018 11:32 AM, Python wrote:
On Fri, Feb 23, 2018 at 03:11:36AM -0500, Terry Reedy wrote:
Why do you care about the 50 million calls? That's crazy -- the important
thing is *calculating the Fibonacci numbers as efficiently as possible*.
If you are writing practical programs, that's true. But the Julia
benchmarks are not practical programs; they are designed to compare
the performance of various language features across a range of
If that were so, then the comparison should use the fastest *Python*
Doing that would completely fail to accomplish the task of comparing
the performance of recursive function calls in the two languages,
which is what the benchmark was designed to do.
That is an non goal because *languages* do not have clock-time speeds,
only programs written in concrete implementations run on real hardware.
Why do you think it fair to compare function call times using the
slowest rather than the fastest implementation of Python function calls?
Real Python programmers who are seriously concerned about time try to
use the fastest implementation appropriate to the situation.
> So, no actually, it shouldn't.
To me, it is 'not using the fasted Python' that fails to make apples to
It has been said here that comparisons should use the same algorithm
doing the much the same work in both implementation. However, a Python
function call does *much more work* than in most languages, because the
meaning of 'function call' is much more flexible in Python than most
languages. The usual comparison is like lemons (other language calls)
to oranges (Python language calls, much more flexible). To be fair, the
comparison should be to a Python implementation that either notices or
accepts a declaration that, for instance, fib(n) only needs to pass an
int by position.
Comparing int addition to python object addition also compares unlike
operations. To compare using the same addition algorithm, one must use
an implementation that can restrict '+' to just int addition.
The Juila fib benchmark uses the type of function call Julia is good at.
Suppose we define fib in a way that uses Python features.
def fib(n, dummy):
if n >= 2:
return fib(n=n-1, dummy=dummy) + fib(dummy=dummy, n=n-2)
elif n >= 0:
return None, n # or some error indicator including the bad value
If the language does not support 'parameter=value' syntax (which existed
long before Python), use ('n', n) and ('dummy', dummy) instead.
Now let's compare call times.
Or lets try 'fib(n-1, dummy) + fib(dummy=dummy, n=n-2)' to compare
functions that can identify argments either by position or by name.
Or f(n-1, dummy) + f(dummy=dummy, n=n-2) + f(*(n-3, dummy)), and change
'2' to '3', to utilize another Python call feature. If the language
does not support *args, omit '*'.
Terry Jan Reedy