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 apples comparisons.

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 1
        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


Reply via email to