I consider it a silly micro-optimization, ... And did you benchmark the cost of accessing the symbol table versus a lexical variable?

I don't prefer it for performance. I prefer it for the simplified syntax.

Most of my programs do IO also. Usually a few seconds at the beginning and the end. In between they do lots of cpu-intensive stuff. Often many hours of it. So, for your delectation:

#! perl -slw
use strict;
use Benchmark qw[ cmpthese ];


sub deref {
    my $r = shift;
    ++$r->[$_][1] for 0..$#$r;
}

sub alias {
    our @a;
    local *a = shift;
    ++$a[$_][1] for 0 .. $#a
}

my @a = map[1..3],1..1e6;;

cmpthese -1, {
    deref => sub { deref( \@a ) },
    alias => sub { alias( \@a ) },
};

__END__
c:\test>junk5
        Rate deref alias
deref 4.16/s    --  -12%
alias 4.72/s   13%    --
[download]

So 8 minutes saved on each hour. 3 hours over a day.

BTW: If you'd called your "Modern Perl" movement, "Beginner's Perl", I wouldn't have a problem with it. Well, if you also dropped the justifictions and stuck with the facts.

Well sure, doing more work takes more time. If you let Perl do the iteration, the difference between dereferencing and aliasing is benchmarking noise (and the difference between manual iteration and internal iteration saves you even more time):

use Modern::Perl;

use Benchmark qw[ cmpthese ];

sub deref {
    my $r = shift;
    ++$r->[$_][1] for 0..$#$r;
}

sub alias {
    our @a;
    local *a = shift;
    ++$a[$_][1] for 0 .. $#a
}

sub deref_iter {
    my $r   = shift;
    $_->[1]++ for @$r;
}

sub alias_iter {
    our @a;
    local *a = shift;
    $_->[1]++ for @a;
}

my @a = map[1..3],1..1e6;

cmpthese -1, {
    deref      => sub { deref( \@a ) },
    alias      => sub { alias( \@a ) },
    deref_iter => sub { deref_iter( \@a ) },
    alias_iter => sub { alias_iter( \@a ) },
};
[download]

Basically, all you've done is avoid doing the extra indirection at the Perl level.

Which is fine if you could always avoid addressing the structure contents individually, but we both know you can't.

So when you can't get away with using internal iterators exclusively, it comes back to having to perform that extra dereference. And that was the point of the benchmark: to exercise and time the cost of that extra indirection.

All your revised benchmark did was remove the very code being tested. It's like saying your program will run faster if you always make the first line of your subroutines return.

True; but utterly meaningless.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

RIP an inspiration; A true Folk's Guy