This talk describes the most likely-to-be-used features added to Perl 5 between v5.10 and v5.16, inclusive.

1. Perl 5
what's new?

2. Perl 5.10
for people who are not totally insane

3. Perl 5.12
for everyday use

4. Perl 5.14
for pragmatists

5. Perl 5.16
for the working programmer

6. Lexical Semantics!

7. use feature ‘say’;
say “This is a test!”;
{
no feature ‘say’;
say “This is fatal!”;
}

8. use 5.16.0;
say “This is a test!”;
{
no feature ‘say’;
say “This is fatal!”;
}

9. #!/usr/bin/perl
use strict;
use warnings;
use 5.16.0; # use feature ‘:5.16’;
my $x = Reticulator->new;
$x->reticulate(@splines);

10. #!/usr/bin/perl
use strict;
use warnings;
# no feature;
my $x = Reticulator->new;
$x->reticulate(@splines);

11. #!/usr/bin/perl
use strict;
use warnings;
# use feature ‘:default’
my $x = Reticulator->new;
$x->reticulate(@splines);

12. array_base: $[

13. Cool New Features!

14. Better Error Message(s)
$str = “Greetings, $name. Your last
login was $last. It is now $time.”;
perldiag

15. Better Error Message(s)
$str = “Greetings, $name. Your last
login was $last. It is now $time.”;
Use of uninitialized value in
concatenation (.) or string at
hello.plx line 9.
perldiag

16. Better Error Message(s)
$str = “Greetings, $name. Your last
login was $last. It is now $time.”;
Use of uninitialized value $time in
concatenation (.) or string at
hello.plx line 9.
perldiag

17. State Variables
my $LINES_READ = 0;
sub read_line {
$LINES_READ++;
...
}
perlsub

18. State Variables
{
my $LINES_READ = 0;
sub read_line {
$LINES_READ++;
...
}
}
perlsub

19. State Variables
sub read_line {
state $LINES_READ = 0;
$LINES_READ++;
...
}
perlsub

20. truth and definedness
perlop

21. truth and definedness
sub record_sale {
perlop

22. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
perlop

23. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
my $price = $amount
perlop

24. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
my $price = $amount
|| $product->price;
perlop

25. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
my $price = $amount
|| $product->price;
...
perlop

26. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
my $price = $amount
|| $product->price;
...
}
perlop

27. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$price = defined $amount
? $amount
: $product->price;
...
}
perlop

28. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
my $price = $amount
|| $product->price;
...
}
perlop

29. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
my $price = $amount
// $product->price;
...
}
perlop

30. the new OR operator
sub record_sale {
my ($product, $amount) = @_;
$amount //= $product->cost;
...
}
perlop

31. say $what
- new built-in, say
- it’s like print
- but it adds a newline for you
perlfunc

32. say $what
perlfunc

33. say $what
print “Hello, world!n”;
perlfunc

34. say $what
print “Hello, world!n”;
print “$messagen”;
perlfunc

35. say $what
print “Hello, world!n”;
print “$messagen”;
print “$_n” for @lines;
perlfunc

36. say $what
print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
print “$_n” for @lines;
perlfunc

37. say $what
print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
say $message;
print “$_n” for @lines;
perlfunc

38. say $what
print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
say $message;
print “$_n” for @lines;
say for @lines;
perlfunc

40. $ perl -e ‘print “Foon”’

41. $ perl -e ‘print “Foon”’
$ perl -E ‘say “Foo”’

42. Recursion!
sub fact {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * fact($x - 1);
}

43. Recursion!
sub fact {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * fact($x - 1);
}

44. Recursion!
my $fact = sub {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * $fact->($x - 1);
};

45. Recursion!
my $fact = sub {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * $fact->($x - 1);
};

46. Recursion!
my $fact;
$fact = sub {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * $fact->($x - 1);
};

47. Recursion!
my $fact;
$fact = sub {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * $fact->($x - 1);
};

48. Recursion!
use Scalar::Util qw(weaken);
my $fact = do {
my $f1;
my $f2 = $f1 = sub {
my ($x) = @_;
return $x if $x == 1;
return $x * $f1->($x - 1);
};
weaken($f1);
$f1;
};

49. Recursion!
use 5.16.0; # current_sub
my $fact = sub {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * __SUB__->($x - 1);
};

50. Filehandles!

51. autodie
open my $fh, ‘<‘, $filename;
while (<$fh>) {
...
}
close $fh;
autodie

52. autodie
open my $fh, ‘<‘, $filename
or die “couldn’t open $filename: $!”;
while (<$fh>) {
...
}
close $fh
or die “couldn’t close $filename: $!”;
autodie

53. autodie
use autodie;
open my $fh, ‘<‘, $filename;
while (<$fh>) {
...
}
close $fh;
autodie

54. autodie
use autodie;
open my $fh, ‘<‘, $filename;
while (<$fh>) {
no autodie;
rmdir or warn “couldn’t remove $_: $!”;
}
close $fh;
autodie

55. autodie
use autodie;
sub foo {
my $filename = shift;
open my $fh, ‘<‘, $filename;
while (<$fh>) {
...
}
} # this implicit close DID NOT AUTODIE
autodie

56. IO::File
sub stream_to_fh {
my ($self, $fh) = @_;
fileno $fh
or die “can’t stream to closed fh”;
while (my $hunk = $self->next_hunk) {
print {$fh} $hunk;
}
close $fh or die “error closing: $!”;
}
perlopentut

57. IO::File
sub stream_to_fh {
my ($self, $fh) = @_;
$fh->fileno
or die “can’t stream to closed fh”;
while (my $hunk = $self->next_hunk) {
$fh->print($hunk);
}
$fh->close or die “error closing: $!”;
}
perlopentut

58. IO::File
sub stream_to_fh {
...
$fh->print($hunk);
...
$fh->close or die “error closing: $!”;
}
open my $target, ‘>’, ‘/dev/null’
or die “can’t open bit bucket: $!”;
stream_to_fh($target);
perlopentut

59. IO::File
use IO::File;
sub stream_to_fh {
...
$fh->print($hunk);
...
$fh->close or die “error closing: $!”;
}
open my $target, ‘>’, ‘/dev/null’
or die “can’t open bit bucket: $!”;
stream_to_fh($target);
perlopentut

60. IO::File
use 5.14.0;
sub stream_to_fh {
...
$fh->print($hunk);
...
$fh->close or die “error closing: $!”;
}
open my $target, ‘>’, ‘/dev/null’
or die “can’t open bit bucket: $!”;
stream_to_fh($target);
perlopentut

61. IO::File
use 5.14.0;
use autodie;
sub stream_to_fh {
...
$fh->print($hunk);
...
$fh->close or die “error closing: $!”;
}
open my $target, ‘>’, ‘/dev/null’
or die “can’t open bit bucket: $!”;
stream_to_fh($target);
perlopentut

62. Package Blocks
package Library::Awesome;
our $VERSION = 1.234;
sub foo { ... }
1;
perlfunc

63. Package Blocks
use 5.12.0;
package Library::Awesome 1.234;
sub foo { ... }
1;
perlfunc

64. Package Blocks
use 5.12.0;
package Library::Awesome 1.234-alpha;
sub foo { ... }
1;
perlfunc

65. Package Blocks
package Library::Awesome 1.234 {
sub foo { ... }
}
1;
perlfunc

66. overloading
- the -x overload
- the qr overload
- "no overloading"
- unknown overload warns
perldoc

67. Other New Features!

68. smrt match

69. smrt match
if ($x ~~ $y) {
...
}

70. smrt match
perldoc

71. smrt match
- if $x and $y are unknown, there are 23
possible dispatch paths
perldoc

72. smrt match
- if $x and $y are unknown, there are 23
possible dispatch paths
- and some of them redispatch recursively
perldoc

73. smrt match
- if $x and $y are unknown, there are 23
possible dispatch paths
- and some of them redispatch recursively
- no, you won't remember them all
perldoc

74. smrt match
- if $x and $y are unknown, there are 23
possible dispatch paths
- and some of them redispatch recursively
- no, you won't remember them all
- ...and they can't be intuited
perldoc

75. Matching

76. Matching
if ($x ~~ $y) {...}

77. Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}

78. Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}

79. Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}

80. Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}
if (%hash ~~ %h) {...}

81. Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}
if (%hash ~~ %h) {...}
if (%hash ~~ @arr) {...}

82. Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}
if (%hash ~~ %h) {...}
if (%hash ~~ @arr) {...}
if (%hash ~~ [ %h,...]) {...}

83. given ($x) {
when ($y) {
...
}
when ($z) {
...
}
}

84. given ($x) {
when ($y) {
try { ... }
catch {
warn “error: $_”;
return undef;
}
}
}

85. each @array

86. each @array
while (my ($i, $v) = each @array) {
say “$i: $v”;
}

87. push $aref, @etc;

88. Now With Fewer Bugs!

89. y2038

91. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’

92. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’
Mon Jan 18 22:14:07 2038

93. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’
Mon Jan 18 22:14:07 2038
~$ perl5.10.0 -E ‘say scalar localtime 2**31’

94. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’
Mon Jan 18 22:14:07 2038
~$ perl5.10.0 -E ‘say scalar localtime 2**31’
Fri Dec 13 15:45:52 1901

96. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’

97. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’
Mon Jan 18 22:14:07 2038

98. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’
Mon Jan 18 22:14:07 2038
~$ perl5.12.0 -E ‘say scalar localtime 2**31’

99. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’
Mon Jan 18 22:14:07 2038
~$ perl5.12.0 -E ‘say scalar localtime 2**31’
Mon Jan 18 22:14:08 2038

100. $@
perlvar

101. $@
Try::Tiny

102. $@
- Well, actually, you use Try::Tiny, right?
Try::Tiny

103. $@
- Well, actually, you use Try::Tiny, right?
- But this makes Try::Tiny more reliable, too!
Try::Tiny

104. $@
- Well, actually, you use Try::Tiny, right?
- But this makes Try::Tiny more reliable, too!
- You see, eval and $@ are totally awful
Try::Tiny

105. use 5.12.0;
{
package X;
sub DESTROY { eval { } }
}
eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};
warn “ERROR: $@”;
perlfunc

106. use 5.12.0;
{
package X;
sub DESTROY { eval { } }
}
eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};
warn “ERROR: $@”;
$ perl5.12.4 test.pl
ERROR:
perlfunc

107. use 5.14.0;
{
package X;
sub DESTROY { eval { } }
}
eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};
warn “ERROR: $@”;
perlfunc

108. use 5.14.0;
{
package X;
sub DESTROY { eval { } }
}
eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};
warn “ERROR: $@”;
$ perl5.14.1 test.pl
ERROR: DEATH!!
perlfunc

110. perl -le ‘print $^X’

111. perl -le ‘print $^X’
10.0: perl

112. perl -le ‘print $^X’
10.0: perl
10.1: perl

113. perl -le ‘print $^X’
10.0: perl
10.1: perl
12.0: perl

114. perl -le ‘print $^X’
10.0: perl
10.1: perl
12.0: perl
14.0: perl

115. perl -le ‘print $^X’
10.0: perl
10.1: perl
12.0: perl
14.0: perl
16.0: /Users/rjbs/perl5/perlbrew/perls/16.0/bin/perl

116. Simpler Strings

117. Perl is Good at Unicode
perlunicode

118. Perl 5.16 is Better
perlunicode

119. Perl 5.16 is Better
- Unicode 6.1
perlunicode

120. Perl 5.16 is Better
- Unicode 6.1
- every character property is available
perlunicode

121. Perl 5.16 is Better
- Unicode 6.1
- every character property is available
- X in regex is more sensible
perlunicode

122. “The Unicode Bug”
perlunicode

123. “The Unicode Bug”
- strings aren’t always treated as Unicode
perlunicode

124. “The Unicode Bug”
- strings aren’t always treated as Unicode
- this causes weird bugs that take ages to find
perlunicode

125. “The Unicode Bug”
- strings aren’t always treated as Unicode
- this causes weird bugs that take ages to find
- use feature ‘unicode_strings’;
perlunicode

126. “The Unicode Bug”
- strings aren’t always treated as Unicode
- this causes weird bugs that take ages to find
- use feature ‘unicode_strings’;
- or use 5.12.0
perlunicode

127. Unicode eval
- eval $str
- is that octets or chars?
- what if it includes "use utf8"
- or you're under "use utf8"?
perldoc

128. Unicode eval
- evalbytes $str
- unicode_eval
perldoc

129. My Favorite 5.12-ism?
if (length $input->{new_email}) {
$user->update_email(...);
}
perldiag

130. My Favorite 5.12-ism?
if (length $input->{new_email}) {
$user->update_email(...);
}
Use of uninitialized value in length
at - line 3120.
perldiag

131. My Favorite 5.12-ism?
if (length $input->{new_email}) {
$user->update_email(...);
}
perldiag

132. say “I o{23145} Perl 5.14!”;
perlsyn

133. say “I o{23145} Perl 5.14!”;
I ♥ Perl 5.14!
perlsyn

134. say “I 23145 Perl 5.14!”;
I ?45 Perl 5.14!
perlsyn

135. say “I 023145 Perl 5.14!”;
I 145 Perl 5.14!
perlsyn

136. qr{
(1) (2) (3) (4) 7 10
(5) (6) (7) (8) (9) 7 10
(10) 7 10
}x;
perlre

137. qr{
(1) (2) (3) (4) o{7} o{10}
(5) (6) (7) (8) (9) o{7} o{10}
(10) g{7} g{10}
}x;
perlre

138. Unicode 6.1
charnames

139. Unicode 6.1
charnames

140. Unicode 6
charnames

141. Unicode 6
charnames

142. Unicode 6
charnames

143. Unicode 6
charnames

144. Unicode 6
charnames

145. Unicode 6
charnames

146. Unicode 6
charnames

147. Unicode 6
charnames

148. Unicode 6
charnames

149. N{...}
use 5.16.0;
say “I N{HEAVY BLACK HEART} Queensr”
. “N{LATIN SMALL LETTER Y WITH DIAERESIS}”
. “che!”;

150. case folding

151. Case Folding
if (lc $foo eq lc $bar) {
...
}

152. Case Folding
if (fc $foo eq fc $bar) {
...
}

153. Case Folding

154. Case Folding
lc ‘ς‘ ➔ ‘ς‘

155. Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘

156. Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘

157. Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘
lc ‘ß’ ➔ ‘ß’

158. Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘
lc ‘ß’ ➔ ‘ß’
uc ‘ß’ ➔ ‘SS’

159. Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘
lc ‘ß’ ➔ ‘ß’
uc ‘ß’ ➔ ‘SS’
fc ‘ß’ ➔ ‘ss’

160. Case Folding

161. Case Folding
“file under: L$name”

162. Case Folding
“file under: L$name”
“file under: F$name”

163. Better Regex

164. named captures

165. Regex: Named Captures
perlre

166. Regex: Named Captures
- find matches by name, not position
perlre

167. Regex: Named Captures
- find matches by name, not position
- avoid the dreaded$1
perlre

168. Regex: Named Captures
- find matches by name, not position
- avoid the dreaded $1
- no longer second to Python or .Net!
perlre

169. Regex: Named Captures
# our hypothetical format
section:property = value
perlre

170. Regex: Named Captures
$line =~ /(w+):(w+) = (w+)/;
$section = $1
$name = $2;
$value = $3;
perlre

171. Regex: Named Captures
$line =~ /
(?<section> w+):
(?<name> w+)
s* = s*
(?<value> w+)
/x;
$section = $+{section};
$name = $+{name};
$value = $+{value};
perlre

172. New Regex Modifiers
my $hostname = get_hostname;
$hostname =~ s/..*//;
perlre

173. New Regex Modifiers
my $hostname = get_hostname =~ s/..*//;
perlre

174. New Regex Modifiers
(my $hostname = get_hostname) =~ s/..*//;
perlre

175. New Regex Modifiers
my $hostname = get_hostname =~ s/..*//r;
perlre

176. New Regex Modifiers
my @short_names =
map { s/..*//; } @long_names;
perlre

177. New Regex Modifiers
my @short_names =
map { s/..*//;
$_ } @long_names;
perlre

178. New Regex Modifiers
my @short_names =
map { my $x = $_;
$x =~ s/..*//;
$x } @long_names;
perlre

179. New Regex Modifiers
my @short_names =
map { s/..*//r } @long_names;
perlre

180. New Regex Modifiers
my @short_names =
map s/..*//r, @long_names;
perlre

181. New Regex Modifiers
perldoc

182. New Regex Modifiers
/u /a /aa /d /l
"൮" =~ /d/ ✓ ! ! ¿? ¿?
"ð" =~ /w/ ✓ ! ! ¿? ¿?
"ff" =~ /ff/i ✓ ✓ ! ¿? ¿?
"ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿?
perldoc

183. New Regex Modifiers
/u /a /aa /d /l
"൮" =~ /d/ ✓ ! ! ¿? ¿?
"ð" =~ /w/ ✓ ! ! ¿? ¿?
"ff" =~ /ff/i ✓ ✓ ! ¿? ¿?
"ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿?
perldoc

184. New Regex Modifiers
/u /a /aa /d /l
"൮" =~ /d/ ✓ ! ! ¿? ¿?
"ð" =~ /w/ ✓ ! ! ¿? ¿?
"ff" =~ /ff/i ✓ ✓ ! ¿? ¿?
"ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿?
perldoc

185. New Regex Modifiers
/u /a /aa /d /l
"൮" =~ /d/ ✓ ! ! ¿? ¿?
"ð" =~ /w/ ✓ ! ! ¿? ¿?
"ff" =~ /ff/i ✓ ✓ ! ¿? ¿?
"ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿?
perldoc

186. New Regex Modifiers
/u /a /aa /d /l
"൮" =~ /d/ ✓ ! ! ¿? ¿?
"ð" =~ /w/ ✓ ! ! ¿? ¿?
"ff" =~ /ff/i ✓ ✓ ! ¿? ¿?
"ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿?
perldoc

187. New Regex Modifiers
/u /a /aa /d /l
"൮" =~ /d/ ✓ ! ! ¿? ¿?
"ð" =~ /w/ ✓ ! ! ¿? ¿?
"ff" =~ /ff/i ✓ ✓ ! ¿? ¿?
"ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿?
perldoc

188. New Regex Modifiers
# To be really ASCII-only:
die “funny un-American characters”
if $str =~ /P{ASCII}/;
$str =~ /...actual pattern.../;
perlre

189. study

190. study
my $re = qr{...complex...};

191. study
my $re = qr{...complex...};
my $str = q{...long complex...};

192. study
my $re = qr{...complex...};
my $str = q{...long complex...};
$str =~ $re; # slow!!

193. study
my $re = qr{...complex...};
my $str = q{...long complex...};
$str =~ $re; # slow!!
study $str; # does stuff

194. study
my $re = qr{...complex...};
my $str = q{...long complex...};
$str =~ $re; # slow!!
study $str; # does stuff
$str =~ $re; # fast!!

195. study
my $re = qr{...complex...};
my $str = q{...long complex...};
$str =~ $re; # slow but right!!
study $str; # does stuff
$str =~ $re; # who knows!!

196. study
my $re = qr{...complex...};
my $str = q{...long complex...};
$str =~ $re; # slow but right!!
study $str; # does nothing
$str =~ $re; # slow but right!!

197. Modder Modlib

198. Newly Cored Librarys
- JSON
- HTTP::Tiny
- Module::Metadata
- CPAN::Meta
perlmodlib

199. Newly Ejected Librarys
- Devel::DProf
- Switch
- the perl4 core
- ...and more
perlmodlib

200. Old Stuff Removed

201. qw()
for my $show qw(Smallville Lost V) {
$tivo->cancel_pass( $show );
}
perlop

202. qw()
for my $show (qw(Smallville Lost V)) {
$tivo->cancel_pass( $show );
}
perlop

203. $[

204. $[ - first index of array
perlvar

205. $[ - first index of array
- so you can make $array[1] mean first
perlvar

206. $[ - first index of array
- so you can make $array[1] mean first
- isn’t that awesome???
perlvar

207. $[ - first index of array
- so you can make $array[1] mean first
- isn’t that awesome???
- yeah, about as awesome as Comic Sans
perlvar

208. $[
$[ = 1;
for (1 .. $#array) {
...
}
perlvar

209. $[
for ($[ .. $#array) {
...
}
perlvar

210. $[
Assigned to $[. Are you some kind of
idiot or something? at -e line 123.
perlvar

211. $[
Use of assignment to $[ is deprecated
at -e line 123.
perlvar

212. defined @arr

213. Any questions?

214. Thank you!