The Cost of Dynamism (was Re: Pyhon 2.x or 3.x, which is faster?)

[BartC]

On 13/03/2016 09:39, Steven D'Aprano wrote:
> On Sun, 13 Mar 2016 04:54 am, BartC wrote:

>> Common sense tells you it is unlikely.
>
> Perhaps your common sense is different from other people's common sense. To
> me, and many other Python programmers, it's common sense that being able to
> replace functions or methods on the fly is a useful feature worth having.
> More on this below.
>
> Perhaps this is an example of the "Blub Paradox":

Perhaps it's time to talk about something which many languages have, but 
Python hasn't. Not as far as I know anyway.

That's references to names (sometimes called pointers). So if I write:

  a = 100
  f(a)

then function f gets passed the value that a refers to, or 100 in this 
case. But how do you pass 'a' itself?

Perhaps you can say:

   f('a')

and f can do some sort of lookup, if it knows the caller's context, for 
such a name and retrieve the value that way. But that's rather 
heavy-handed, and f can't distinguish between a reference to a name, and 
a string.

Unless maybe you wrap this up in a class and .... Well, you end up with 
something that might emulate a name reference, but with so much 
complexity and such overheads that it is not worthwhile.

Yet, this is a feature I use extensively, far more often than I would 
use mutable functions. And in fact it was used in the code for my jpeg 
example, where in the Python I has to use a workaround (see below).

I would argue that such references are more useful than mutable function 
names, as the latter can be more easily emulated and with little or no 
extra overheads.

-------------------------------------------------

Non-Python example of reference parameters:

fastidct8(
     block[j],          # each argument can be updated by the callee
     block[j+8],
     block[j+16],
     block[j+24],
     block[j+32],
     block[j+40],
     block[j+48],
     block[j+56])

proc fastidct8(&a1,&a2,&a3,&a4,&a5,&a6,&a7,&a8) =
     const w1 = 2841  # (Incidentally, here's a use-case for proper
     const w2 = 2676  # consts. Evaluated at compile-time here ...
     const w3 = 2408
     const w5 = 1609
     const w6 = 1108
     const w7 = 565
....
     a1 := (x8 + x2) >> 8
     a2 := (x4 + x3) >> 8
     a3 := (x1 + x5) >> 8
     a4 := (x9 + x7) >> 8
     a5 := (x9 - x7) >> 8
     a6 := (x1 - x5) >> 8
     a7 := (x4 - x3) >> 8
     a8 := (x8 - x2) >> 8
end

Python version:

(block[j],
  block[j+8],
  block[j+16],
  block[j+24],
  block[j+32],
  block[j+40],
  block[j+48],
  block[j+56]) = fastidct8(
     block[j],
     block[j+8],
     block[j+16],
     block[j+24],
     block[j+32],
     block[j+40],
     block[j+48],
     block[j+56])

def fastidct8(a1,a2,a3,a4,a5,a6,a7,a8):
     w1 = 2841   #  ... but at run-time in here)
     w2 = 2676
     w3 = 2408
     w5 = 1609
     w6 = 1108
     w7 = 565
....
     a1 = (x8 + x2) >> 8
     a2 = (x4 + x3) >> 8
     a3 = (x1 + x5) >> 8
     a4 = (x9 + x7) >> 8
     a5 = (x9 - x7) >> 8
     a6 = (x1 - x5) >> 8
     a7 = (x4 - x3) >> 8
     a8 = (x8 - x2) >> 8
     return [a1,a2,a3,a4,a5,a6,a7,a8]

-- 
Bartc