package Something::Or::Other;

use strict;
use warnings
no warnings 'once';

# Stuff here

1;
[download]

The 'once' item is one I don't want in a values repository. But, I don't use the no warnings 'once' item in my scripts because I should be using all my variables more than once. (If it's a repository, it should be in an Exporter module.)

The same goes double with strict. The only strict item I ever turn off is 'refs', but I turn it off a lot, in specific situations when I really do have to use soft references. But, I know why I'm using soft references and I am planning on using soft references. Everywhere else, I'm too lazy to keep track, so I want the compiler to keep track for me, so I turn strict on.

Soft references are dangerous in every situation ... just in most of them. So, if they were always errors, a lot of code wouldn't work. (Like, the code in Exporter, the most commonly used non-pragma module in Perl.)

So is the point of strict, then, to take the rope out of the hands of a programmer so that they can't hang themselves? I guess there's a place for that. I withdraw my objection. :)
----
May your tongue cleave to the roof of your mouth with the force of a thousand caramels.

The point is to provide automated rope-removal, should the programmer want it. It's all in the spirit of TIMTOWDI.

------
We are the carpenters and bricklayers of the Information Age.

The idea is a little like C++ templates, except not quite so brain-meltingly complicated. -- TheDamian, Exegesis 6

... strings and arrays will suffice. As they are easily available as native data types in any sane language, ... - blokhead, speaking on evolutionary algorithms

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

Abigail

Better to have anything that is that dangerous always be an error. Ask yourself: is it an error or isn't it?

This code is an error under strict 'refs':

foreach my $field (qw( foo bar baz)) {
    *$field = sub { 
        my $self = shift;
        $self->{$field} = shift if @_;
        $self->{$field};
    };
}
[download]

This is an incredibly great way to create accessors/mutators for an object in the simplist and most common case. It makes it easy to create new accessors/mutators, and is very memory-efficent (since there is actually only one subroutine in memory that handles many different cases).

OTOH, the following also won't work under strict 'refs':

use CGI qw(:all);
my @names = param();
foreach my $name (@names) {
    $$name = param($name);
}
[download]

The fact that the above doesn't work under strict 'refs' is a good thing. It would allow any parameters passed to the CGI to clobber the values of existing scalars in the namespace. (This is based on a real example I saw in a SoPW a while back by a well-meaning but obviously inexperianced CGI programmer).

Thus, a new user should always use strict to catch potential errors, but an experianced coder will know when it's OK to shut it off.