I assume you didn't understand the explanation given in the perlsecret link. Ok, so consider:

1. Baby Cart.   An array variable may be accessed using this "canonical" (in the sense that it always works) syntax:

   @{bareword     }
   @{symbolic reference  }
   @{hard reference   }

   (A symbolic reference — sometimes casually called a "soft" reference — only works with package-global variables as used in the example below. That's one reason symbolic references are Officially Frowned Upon; see symbolic references in perlref and also Why it's stupid to `use a variable as a variable name' and also the perlfaq7 FAQ "How can I use a variable as a variable name?" for others. Symbolic referencing also only works when  strict 'refs' are disabled.) The "baby cart" just goes one step further and uses an anonymous array constructor  [ ... ] to generate an array hard reference to be dereferenced. E.g.:

   c:\@Work\Perl\monks>perl -wMstrict -le
   "no strict 'refs';
    ;;
    our @array = qw(One Two Three);
    ;;
    my $soft_ref = 'array';
    my $hard_ref = \@array;
    ;;
    print @{ array }, '*', @{ $soft_ref }, '*', @{ $hard_ref };
    print qq/@{ array }-@{ $soft_ref }-@{ $hard_ref }/;
    ;;
    print qq/@{[ something_returning_a_list() ]}/;
    ;;
    sub something_returning_a_list { return qw(Nine Eight Seven); }
   "
   OneTwoThree*OneTwoThree*OneTwoThree
   One Two Three-One Two Three-One Two Three
   Nine Eight Seven
   [download]

2. Crab.   This is just string concatenation using the  . operator (see perlop). Scalars are stringized and concatenated together. Other data is handled in scalar context imposed by the concatenation operator. E.g.:

   c:\@Work\Perl\monks>perl -wMstrict -le
   "my ($x, $y, $z) = qw(Fie Foe Fum);
    my @ra = qw(foo bar baz);
    ;;
    my $s = $x . $y . $y . @ra;
    print $s;
   "
   FieFoeFoe3
   [download]

3. Reference, Deference.   The "canonical" syntax for scalar access is exactly orthogonal to that for arrays (or any other basic Perl data type):

   ${bareword     }
   ${symbolic reference  }
   ${hard reference   }

   The  ${ \$sftp->error } expression simply takes whatever scalar is returned by the method call to  $sftp->error and takes a hard reference to it. The hard reference is then dereferenced normally, and the resulting scalar value can be used like any other scalar, e.g., in string interpolation.
4. Comma.   The  , is just the comma operator (see perlop). In list context (as imposed, e.g., by the print built-in), it separates list items: scalars, arrays, epressions evaluating to scalars or arrays, etc. In
       warn "Put failed: ", $sftp->error, "\n";
   $sftp->error is just one more scalar item in the argument list fed to warn.