['The Professor', [qw(sunscreen water_bottle slide_rule radio) ]],

should be

['The Professor', [qw(sunscreen water_bottle slide_rule batteries radio) ]],

vfor 'The Professor':
[qw(sunscreen water_bottle slide_rule radio)]
should be:
[qw(sunscreen water_bottle slide_rule radio batteries)]

In the section "Building Recursively Defined Data" in Chapter 9, a code bit reads:

#####

my $skipper_home = {
'.cshrc' => undef,
Please_rescue_us.pdf => undef,
Things_I_should_have_packed => undef,

bin => {
navigate => undef,
discipline_gilligan => undef,
eat => undef,
},
};

#########

It should quote the keys for 'Please_rescue_us.pdf' and 'Things_I_should_have_packed', like this:

#########

my $skipper_home = {
'.cshrc' => undef,
'Please_rescue_us.pdf' => undef,
'Things_I_should_have_packed' => undef,

bin => {
navigate => undef,
discipline_gilligan => undef,
eat => undef,
},
};

#########

$ make ziptest

should be
$ make zipdist

The code of Exercise 2 is not correct.
The Ordinary "is" still faster.
The solution was in the comments to the quoted URL: http://www.perlmonks.com/?node_id=393128

The @files is not known to Benchmark. With the code on p 231 the Ordinary is still faster, but
@files is empty. Probably most clear is to change the q{} to sub {} in the code for the Ordinary
and Schwartzian.

Running with the q{} quoted code of the example:
Benchmark: running Ordinary, Schwartzian for at least 2 CPU seconds...
Ordinary: 2 wallclock secs ( 2.03 usr + 0.00 sys = 2.03 CPU) @ 398461.58/s (n=808877)
Schwartzian: 3 wallclock secs ( 2.04 usr + 0.03 sys = 2.07 CPU) @ 337243.48/s (n=698094)

Changing q{} to sub {} shows the following results
Running with the sub on /etc/* (81 files):
Benchmark: running Ordinary, Schwartzian for at least 2 CPU seconds...
Ordinary: 3 wallclock secs ( 0.38 usr + 1.73 sys = 2.11 CPU) @ 58.77/s (n=124)
Schwartzian: 2 wallclock secs ( 1.21 usr + 0.84 sys = 2.05 CPU) @ 214.63/s (n=440)

Running with the sub on /bin/* (81 files):
Benchmark: running Ordinary, Schwartzian for at least 2 CPU seconds...
Ordinary: 3 wallclock secs ( 0.35 usr + 1.66 sys = 2.01 CPU) @ 129.85/s (n=261)
Schwartzian: 2 wallclock secs ( 1.12 usr + 1.00 sys = 2.12 CPU) @ 416.98/s (n=884)

This is perl, v5.8.6 built for darwin-thread-multi-2level
on Mac OS X 10.4.9 G3 500 MHz.

Note from the Author or Editor:
Change as noted.

The test for shuffle() is totally broken.

First of all, the least serious problem is a typo on page 244, next to last line: it should read $shuffled->[$index] instead of $shuffle->[$index] (note: shuffled vs. shuffle).

However, the whole comparing doesn't make any sense. Both $array and $shuffled are references to the same (anonymous) array, and after the array elements have been shuffled both of them still point to that array. Thus comparing their elements means comparing each array element to itself. And of course this leads to $same_count always being `scalar @$array'.

And even if these problems were fixed, the call to cmp_ok() doesn't make sense. All array elements may have retained their position, but they might as well all have changed it; and of course everything in between is also possible. It probably makes most sense here to compare the elements of the _sorted_ original and shuffled arrays.

Note from the Author or Editor:
For the code at the bottom of page 244, there are two errors:

The line that reads:

my $shuffled = $array;

should read

my $shuffled = [ @$array ];

And, the second code line from the bottom of the page has an incorrect variable name. The name is written as "$shuffle", but should be "$shuffled" with a "d" at the end:

$same_count++ if $shuffled->[$index] eq $array->[$index];

The text mentions making a copy of the array.
In the code below the reference is copied. Both $array and $shuffled therefore still point to
the same data.

The test will not work.

Note from the Author or Editor:
The offending line is:

my $shuffled = $array;

That should be:

my $shuffled;
@shuffled = @$array;