#load modules
use strict;
use stricter 'comments', 2;

#This prints something
print "a";
print "b";
print "c";
[download]

> perl comment.pl
  Script not adequatly commented at /comment.pl line 7.
[download]

:)

However, there are situations that require reverting to no stricter, perhaps more often than you think.

Sure, I hate MixedCase identifiers, but in some shops that's the requirement. (I prefer Mixed_Case over MixedCase, but I want Mixed_Case to mean something special, more than lower_case, but perhaps less emphatically than UPPER_CASE.)

C-style for loops are concise when dealing with complicated indexing, though granted they are just compact syntax for while loops, if more emphatic-looking.

I'll grant unless is not very appealing, but is lazy. However, I like until, because it's often paired up as in do {...} until (). But I suppose it's equivalence with while (not(...)) is what's got everyone agitated.

I think we should tread carefully, so that Perl doesn't suffer more from the shortcomings of Lisp or Pascal (as in "There might be one way to do it in Pascal).

In the end, we'll all have to make our own choices (except those who get their choices handed to them ;)

use stricter 'must halt';
# There's no infinite loops in this code!
...
[download]

... though it might take me a while before I upload this to CPAN.

Really? It only took me a few minutes to write my version.

...*shifty eyes*

This is the sort of thing that prompted me to ask Damian about the lilihood for fist fights in the parking lot after work.

Andy Lester has a lint tool for his local requirements, and that's fine, but once you start putting things in the code you have to figure out what to do with third-party modules that don't care for your particular style. :)

Personally, I'm anxiously awaiting someone's meditation on "strict considered harmful." ;-)

Here you have two:

• to strict or not to strict
• Perlmonk's "best pratices" in the real world

However, they were not very popular when they came out.

just a suggestion.

Yup -- that's the way to do it, I think. I wrote "source filter" in the original partly as it was the thing that occurred to me when the joke first came to me and partly to hint that I wasn't being serious. As people started saying "I wish that existed," I realized that to actually do it would need B (or, as diotalevi said, B::Lint) or PPI. And it should really be an external check -- or something easily turned off or commented out for production. You don't really want your CGI script to take 10 seconds to fire up because it's busy checking to see if you wrote q{} instead of ''.

-xdg

Code written by xdg and posted on PerlMonks is public domain. It is provided as is with no warranties, express or implied, of any kind. Posted code may not have been tested. Use of posted code is at your own risk.

Perl-Critic does exactly that. It's an extensible static source code analyzer based on PPI. It enforces about 60 of Damian's Best Practices, plus a few others. The current interfaces are the  perlcritic command-line and Test-Perl-Critic which runs via test a script. But I could easily see hooking into a source filter that analyzed the code at compile-time.

-Jeff

In two words: type inferrence.

If you annotate your code with types, and further annotate subs as inferrable, and use a pragma for this saftey (sounds like a lot, but really isn't), then you get compile time errors for bad usage of data.

Other safety features Perl 6 has been designed with include:

• Better support for exception handling, especially with UNDO blocks, and 'let' variables
• use fatal;
• More complete lexical scopes
• more "serious" object oriented system - the opaque data type, better support for interfaces through roles

I'd like to see a 'stricter taint'.

It would mark everything as tainted, and expand the scope of things that blow a taint error. For example:

use stricter qw(taint);
use foo qw(frob);
use bar qw(clam);
my $blah = frob("something");
clam($blah);
[download]

$blah would be tainted because we don't trust the foo module to return something rational, and clam($blah) would blow an error because we don't trust the bar module, so we don't know what clam does, and we just passed it something tainted.