I applaud your desire to want to learn proper variable scoping. It may take a bit of reading and re-reading until it "clicks", but once it does it will be well worth it (meaning your code will be easier to read, debug, and maintain).

To understand variable scoping, you need to understand the difference between lexical variables and global variables. There are many excellent resources to help you, including:

• perldoc perlsub
• perldoc perlfunc my
• perldoc perlfunc our
• perldoc perlfaq7 "What's the difference between dynamic and lexical (static) scoping? Between local() and my()?"
• The PerlMonks Tutorials section, specifically the subsection on variables (my personal favorites include 'our' is not 'my' and Coping with Scoping, but they are all very good)

Please take a look at some of those references. If you have specific questions, feel free to ask. Sorry for only posting links, but those references describe lexical scoping far better than I could and I'd only be repeating what they already say.

It's just that if you don't, there are all kinds of annoying, easily-avoided errors which can get into your code. Using strict reduces the number of possible errors. One very simple mistake: you used "$count" twice in your program to count different things and didn't notice.

while(<FILE>){
  # do something
  $count++; # count lines  in FILE
}

# somewhere else in your script

sub count_digits {
    $string = shift();
    $count = $string =~ tr/0-9/0-9/;
    return $count;
}
[download]

Now when you use $count, which one is it?

Imagine you call someone for help because your car won't start. He says "You checked the fuel gauge, right? It has gas in the tank?" and you say "oh, I didn't check". He has the right to tell you to go and check and call him back, because that's so obvious. He might love fixing cars, and be prepared to do it for free, but he doesn't want to put gas in the tank for you, where's the fun in that?

When you ask people for help here and you haven't used strict, you're like the guy who hasn't checked the gas. Using strict means your program has been automatically checked for the most obvious kind of error, leaving, hopefully, something more interesting.

People telling you to use strict and use warnings are trying to save you time and frustration down the road. 'strict' enforces predeclaration of lexically scoped variables. Up to this point, you've been using package global variables. That's fine for a quick and dirty ten line script, but you'll quickly run out of gas on the superhighway if you never take advantage of lexical scoping.

This isn't the simplest of concepts, but it doesn't have to start out as difficult as it seems. To begin with, before you use any variable, declare it like this:

my $var;
my %charnames;
# etc...
[download]

This will, in the most basic sense, ensure that you're complying with strictures. The next step will be to learn why you're doing this, and how it's helpful. I recommend that if you're going to teach yourself Perl, you let one of the pros help out. Beg, buy, borrow, or steal the Llama book: Learning Perl, published by O'Reilly & Associates. That's the best starting point I can think of. It's where most of us began. ...at least most of us who began learning Perl after the book was published. ;)

Using 'use warnings;' and 'use strict;' will often give you tons of messages telling you that something's wrong. It's natural to want to avoid such discouraging messages, but these two instructions (called 'pragmas') will identify certain problems for you long before you get into trouble from them. They're something like a smoke alarm. You don't just take the batteries out of a smoke alarm when it sounds, you go find out what caused it to go off. Similarly, when you get messages from using strict and warnings, they are telling you that your code has problems. It's usually better to track down the problems, than to ignore them by removing the pragmas.

Your error messages all refer to 'explicit package name', which is somewhat confusing. The problem is that you're using these variables without telling Perl anything about them - such as where you want them to exist. Perl allows you to do this, but as your programs get longer, this will cause problems. It is things like this that 'warn' and 'strict' help to avoid.

For example, it is often convenient to use $i or $j as a counter or an index into an array. However, if you have several arrays, all using $i, you'll have problems if that same $i is visible and accessible to all the arrays. You need to tell Perl where each $i is allowed to be seen, or else you need to remember the value and location of all your variables, which becomes extremely difficult.

The magic word for declaring variables to be lexically scoped (visible within a block of code, or a sub) is 'my'. It is a good idea to declare your variables close to where you're using them, and to also try to limit their scope as much as possible in order to avoid clashes with other variables with the same name. So, for example, you could do this:

my $i=100;
# Some code here...
...

sub_1 {
my $i; # This $i is undefined.  It's not the same $i that was defined 
+outside the sub.
# Code that uses $i
...
}

# $i now = 100, as before, since we're not in the sub.

sub_2 {
my $i = 4; # This $i = 4.
print "$i\n"; # Prints 4.
}

# Once again, $i = 100.
[download]

As your programs get longer, 'warnings' and 'strict' become more important in keeping you sane. Without them, it is very easy to introduce subtle, hard to find bugs that could take many hours to track down. It's a good idea to use these pragmas consistently, unless you have a very good reason to ignore them. And then it's still a good idea to disable them only for the smallest bit of code nesessary, and to enable them again when you're past that bit.

when i run this with the "use strict use warnings" i get this:

Global symbol "$path" requires explicit package name at punctuation.pl
+ line 6.
[download]

...
what is an explicit package name? how do i delcare it?

In this case, it says:

(F) You've said "use strict vars", which indicates that all variables 
+must either be lexically scoped (using "my"), declared beforehand usi
+ng "our", or explicitly qualified to say which package the global var
+iable is in (using "::").
[download]