Re^2: Perl::Critic and Subroutines

[tobyink]

"I am not a fan of this policy :)"

There seems little point to it. There is a very slight compile time speed penalty to double-quoted strings. This benchmark demonstrates that:

use Benchmark ':all';

cmpthese(250_000, {
    e_double => sub { eval q{"foo"} },
    e_single => sub { eval q{'foo'} },
});

But at runtime, there's no difference, as they compile to the same optree...

$ perl -MO=Concise -e'$x=q{foo}' > single.txt
-e syntax OK
$ perl -MO=Concise -e'$x=qq{foo}' > double.txt
-e syntax OK
$ diff -s single.txt double.txt
Files single.txt and double.txt are identical
$ rm single.txt double.txt

That is not always the case in all programming languages though. The PHP compiler is less smart than the Perl compiler, so in PHP there's a real speed penalty on double-quoted strings...

<?php

class Bench {
    public $name;
    protected $_start;
    protected $_finish;
    
    public function __construct ($name) {
        $this->name = $name;
    }

    public function start () {
        if ($this->_start) die("already started");
        $this->_start = microtime(true);
    }

    public function finish () {
        if ($this->_finish) die("already finished");
        $this->_finish = microtime(true);
    }
    
    public function total_time () {
        return $this->_finish - $this->_start;
    }
    
    public function run ($callable, $count=1) {
        $this->start();
        for ($i = 0; $i < $count; $i++)
            call_user_func($callable);
        $this->finish();
    }
    
    public function __toString () {
        return sprintf("%s: %0.6f s", $this->name, $this->total_time()
+);
    }
    
    public static function cmpthese ($iterations, $tests) {
        foreach ($tests as $name => $code) {
            $bench = new Bench ($name);
            $bench->run($code, $iterations);
            $per_second = $iterations / $bench->total_time();
            printf("%s: %0.2f /s\n", $bench->name, $per_second);
        }
    }
}

Bench::cmpthese(100000, array(
    "single quotes" => create_function('', 'return \'foo\';'),
    "double quotes" => create_function('', 'return "foo";'),
));

[jthalhammer]

"I am not a fan of this policy :)"

There seems little point to it.

I actually think this is one of the best policies. As you pointed out, the performance benefits are very small. But it is immensely helpful for clarifying intent and detecting typos. Consider this code:

my $name = <STDIN>;
print "Hello, name";

Unless you had test coverage on that (or you just spotted it by eye) you'd never find that bug. But ProhibitUselessInterpolation will find it for you.