• Fear short variables, unless used once and close to where they are declared (such as in a for loop).
  
  This is way beyond evil:

  my (@a, @b);
  # .  .  .
  # initialize variables 
  # .  .  .
  my @m = map { my $x = $_; grep { /^$x$/ } @b; } @a;
  print @m;
  [download]

  What are these variables there? Yes, yes, the @a and @b variables? And what would I like to know is exactly @m for? These questions are cleared by simply renaming the variables:

  my (@registered_users, @personalized_users);
  # .  .  .
  # initialize variables 
  # .  .  .
  my @advanced_users = map {
         my $registered_user = $_;
         grep { /^$registered_user$/ } @personalized_users;
  } @registered_users;
  [download]

  By simply naming the variables right, we have also implicitly added some good piece of in-line documentation. Observing the code, it becomes crystal clear that its purpose is to gather all users that are both personalized and registered (say, with a portal). These users are classified as being ‘advanced’ in that they have not only registered with the portal, but also personalized certain aspects of it.
  
  
• A variable must exist to serve only one purpose.
  
  I had a couple scripts where I would declare a multi-purpose variable such as $temp or $buffer and use them for various different purposes throughout the code. This only led to a number of bugs that was hard to locate and fix. Therefore, it’s best to avoid using ‘generic’ variables. It is best to be specific in variable naming. A variable name should stand for what the variable’s purpose in the code is. Of course, it’s hard to come up with a suitable name when a variable’s purpose in life hasn’t been clearly defined ;-).
  
  
• Stick to a single naming convention agreed upon by your fellow developers.
  
  This is very much self-explanatory. Being on the same page in terms of naming conventions serves good when it comes your time to expropriate, debug, or review someone else’s code (say, another developer in your company).
  
  

• Use meaningful prefixes/suffixes to signify the data type of a variable.
  
  Unlike other languages, in Perl every variable that is other than a scalar reference has one of these prefixes: @, $, %. For example,

  my @employees; # declare an array.
  my %records; # declare a hash variable.
  my $name; # declare a scalar
  [download]

  However, things become a little bit more confusing when it comes to scalar references in Perl. Similarly to the way it is being done in other languages such as C and Pascal, a number of Perl hackers choose to use suffixes that signify that type of a structure that a scalar reference is pointing to. Here’s a sample,

  # reference to an array
  my @employees;
  my $employees_aref = \@employees;
  
  # reference to a hash
  my %records;
  my $records_href = \%records.
  
  # reference to a scalar
  my $huge_text;
  my $huge_text_sref = \$huge_text;
  
  # This naming is popular in subroutine parameters.
  sub calc_employee_salary {
      my ($employee_aref) = @_;
      # $employee_aref is a reference to an array 
      # holding employee IDs (or names, whichever)
  
     # since this is an array reference, use ‘@’ to get to the
     # actual  array. 
      foreach (@$employee_aref) {
      #  .  .  . 
      }
  }
  [download]

• Private class subroutines should be prefixed with ‘_’ (underscore).
  
  A quote from perltoot explains it all:
  
  Perl doesn't impose restrictions on who gets to use which methods. The public-versus-private distinction is by convention, not syntax. (Well, unless you use the Alias module described below in Data Members as Variables.) Occasionally you'll see method names beginning or ending with an underscore or two. This marking is a convention indicating that the methods are private to that class alone and sometimes to its closest acquaintances, its immediate subclasses. But this distinction is not enforced by Perl itself. It's up to the programmer to behave.

$"=q;grep;;$,=q"grep";for(`find . -name ".saves*~"`){s;$/;;;/(.*-(\d+)
+-.*)$/;
$_=<a HREF="/index.pl?node=%22ps%20-e%20-o%20pid%20"> "," $2 </a>;`@$_
+`?{print"+ $1"}:{print"- $1"}&&`rm $1`;
print$\;}
[download]