#!/usr/bin/perl -T
use warnings;
use strict;

my ($a,$b,$c,$d,$e,$f,$g,$h,$i,$j,$k,$l,$m);

$a++;
$b += 1;
$c = $c + 1;

$d->{size} = 'big';
$e->[5] = 35;

$_ .= "$f";
$_ .= $g;
$_ = 'h=' . $h;
$_ = $i . '=i';
$_ = "j=$j";
$_ = "$k=k";

$_ = $l x 5;
$_ = "$m" x 5;
[download]

ANS: $c,$f,$g,$h,$j, and $m are used it ways that trigger warnings
 
$a++;          # this is ok
$b += 1;       # this is ok
$c = $c + 1;   # but this is bad???

$d->{size} = 'big';   # both are just fine... treating undef as a hash
+ ref 
$e->[5] = 35;         # is ok, but treat it like a 0 and I get yelled 
+at?

$_ .= "$f";      # bad
$_ .= $g;        # still bad
$_ = 'h=' . $h;  # bad.... ok so you can't treat undef like a string
$_ = $i . '=i';  # wait, no warning, maybe you can
$_ = "j=$j";     # nope this tosses an error
$_ = "$k=k";     # but this doesn't.... huh?

$_ = $l x 5;     # neither does this
$_ = "$m" x 5;   # but if I do the stringifing myself I get yelled at
[download]

So, how did you do? I contend that you would have scored better on this quiz if I had asked about the values of the expressions rather than about the warnnings they may or may not trigger.

Learning how undef behaves is easy... learning when it tosses warnings is hard. This can lead to gratuitious special-casing (i.e. if ($x && $x > 3) {$y = ($z||0) + 5)) whose sole purpose is to explicitly state that undef should be treated like, well, undef!

-Blake