For example:

no strict 'refs';
$bla = "something";
$blaref = "bla";
$$blaref = "something else";

print $bla;  # prints "something else"
[download]

Just about the only reason to use symbolic reference nowadays is to dynamically create named subroutines or classes (i.e. setting @{"${classname}::ISA"})

my $subname = "packagename::some_sub";
no strict 'refs';

# note that we use a typeglob here
*$subname = sub {
  print "Hello from subroutine $subname";
};

packagename::some_sub();
[download]

# A simple example from http://perldoc.perl.org
$name = "foo";
$$name = 1;            # Sets $foo

# $name is evaluated ("foo") as the name of the variable
[download]

Which is almost always NOT what you want to do (unless you really understand symbolic refs and have a good reason to do so). So if your code doesn't run under use strict 'refs'; you are accidentally using symbolic refs. This is why, using strict is often harped on.

While you are learning perl, it is much better to know how to avoid symbolic refs than knowing the details of them.

This is most likely your best reference.

so are you saying that "foo", once a text string stored in $name, is now a variable in its own right with the value 1 stored in it? I think im still confused (oh and by the way, I read perlref and didnt get that either)

No "foo" isn't changed, $foo is. ${"foo"} is a symbolic reference to $foo.
"What should it profit a man, if he should win a flame war, yet lose his cool?"

Symbolic references should be avoided as much as possible, as convincingly demonstrated by MJD in three parts: part 1 and part 2 and part 3.

If you have a specific problem where you feel you need to use symbolic references, post your problem and we can advise on a cleaner way to solve it.

use warnings;
use strict;
no strict 'refs';

my %hash = ( badger => 'nadger', mutt => 'nut' );
# Package variable, named badger
our $badger = 'furry';
# Lexical variable - gives a warning that it is shadowing
# the package var
my $badger = 'stripey';

my $str = 'badger';

# The value of $str is used to lookup in the hash
# Hence this prints 'nadger'
print $hash{$str}, "\n";

# With strict refs off, we can use '$str' as a reference and
# so this prints 'furry', the value of the $badger package var
print ${$str}, "\n";

# This is a normal variable lookup, whose value will be
# 'stripey', since the lexical is shadowing the package var
# in this scope.
print $badger, "\n";
[download]

This means that symbolic references have similar properties to hash keys, in particular perl can't check at compile time whether you have mis-spelled the variable name, instead it will just look up the wrong name give you an undef value.

Also as you can see, symbolic references don't really have much advantage over hashes, if you think you want a symbolic reference, it is quite likely a hash will do the job for you.

And lastly, emulating a structure by using named keys in a hash shares some of the disadvantages of symbolic references. If you're using a hash reference to implement an object you can get compile-time checking back again by using accessors, made easy by handy modules such as Class::Accessor.

Now that perl has references there are very few reasons to use these.

our $reference  = "global";
{
    my $reference = "local";
    print "reference equals ${reference}, ";
    print "symbolic reference equals ${'reference'}.\n";
}
print "Here ${reference} and ${'reference'} both come out of the sysbo
+l table.\n";
print "This also shows how local differs from local\n";
{
    local $reference = "local";
    print "reference equals ${reference}, ";
    print "symbolic reference equals ${'reference'}.\n";
}
[download]