Perl 5.14 for Pragmatists

Every new release of Perl comes with a big list of changes, plenty of which seem carefully worded to make the average Perl programmer wonder, “Wait, do I care about this? What the heck is the global interpreter phase?” Perl 5.14 is chocked full of great improvements will actually be useful in day to day programming, and this talk focuses on those, leaving the weird esoterica for another day.

Transcript

1. Perl 5.14 for pragmatists
2. perlhist 5.14
3. perlhist 5.14 - after 5.8, we had to wait 5 years for 5.10
4. perlhist 5.14 - after 5.8, we had to wait 5 years for 5.10 - 5.12 came out 2 years after 5.10
5. perlhist 5.14 - after 5.8, we had to wait 5 years for 5.10 - 5.12 came out 2 years after 5.10 - 5.14 came out 1 year after 5.12
6. perlhist 5.14 - after 5.8, we had to wait 5 years for 5.10 - 5.12 came out 2 years after 5.10 - 5.14 came out 1 year after 5.12 - 5.16 will come 1 year from 5.14
7. perlhist 5.14
8. perlhist 5.14 - 5.10 was a huge set of changes (too many!)
9. perlhist 5.14 - 5.10 was a huge set of changes (too many!) - 5.12 was a lot smaller
10. perlhist 5.14 - 5.10 was a huge set of changes (too many!) - 5.12 was a lot smaller - 5.14 is in between
11. perlhist 5.14 - 5.10 was a huge set of changes (too many!) - 5.12 was a lot smaller - 5.14 is in between - just right?
12. perl5140delta 5.14 is a Mixed Bag
13. perl5140delta 5.14 is a Mixed Bag - this talk isn’t just for beginners
14. perl5140delta 5.14 is a Mixed Bag - this talk isn’t just for beginners - some of these changes are at the edges
15. perl5140delta 5.14 is a Mixed Bag - this talk isn’t just for beginners - some of these changes are at the edges - but they’re all practical
16. perl5140delta 5.14 is a Mixed Bag - this talk isn’t just for beginners - some of these changes are at the edges - but they’re all practical - except for the ones that aren’t
17. perl5150delta By the way, 5.16...
18. perl5150delta By the way, 5.16... - ...and beyond are going to be interesting
19. perl5150delta By the way, 5.16... - ...and beyond are going to be interesting - stick around right here after the break and hear Jesse “Double Pumpking” Vincent talk about it
20. perlpolicy ...and 5.10 is EOL
21. perlpolicy ...and 5.10 is EOL - we accept critical bugfixes for 2 maint tracks
22. perlpolicy ...and 5.10 is EOL - we accept critical bugfixes for 2 maint tracks - that’s now 5.14 and 5.12
23. perlpolicy ...and 5.10 is EOL - we accept critical bugfixes for 2 maint tracks - that’s now 5.14 and 5.12 - we do security fixes for releases in last 3 years
24. perlpolicy ...and 5.10 is EOL - we accept critical bugfixes for 2 maint tracks - that’s now 5.14 and 5.12 - we do security fixes for releases in last 3 years - 5.10 was 2007; it gets no promise of support
25. perlpolicy ...and 5.10 is EOL - we accept critical bugfixes for 2 maint tracks - that’s now 5.14 and 5.12 - we do security fixes for releases in last 3 years - 5.10 was 2007; it gets no promise of support - if you’re still on 5.8, you’re in the weeds
26. but enough about other versions
27. let’s talk about 5.14
28. feature First: A Warning
29. feature First: A Warning - 5.14 is backwards compatible
30. feature First: A Warning - 5.14 is backwards compatible - but has some new behaviors
31. feature First: A Warning - 5.14 is backwards compatible - but has some new behaviors - they’re not all enabled by default; feature.pm
32. feature First: A Warning - 5.14 is backwards compatible - but has some new behaviors - they’re not all enabled by default; feature.pm - no new feature.pm features in 5.14!
33. feature First: A Warning - 5.14 is backwards compatible - but has some new behaviors - they’re not all enabled by default; feature.pm - no new feature.pm features in 5.14! I’m a perldoc ref!
34. feature First: A Warning - 5.14 is backwards compatible - but has some new behaviors - they’re not all enabled by default; feature.pm - no new feature.pm features in 5.14!
35. perlsyn Stuff That’s Gone
36. perlsyn - modules deprecated in 5.12 are gone in 5.14 Stuff That’s Gone
37. perlsyn - modules deprecated in 5.12 are gone in 5.14 - you’ll have to install them from CPAN Stuff That’s Gone
38. perlsyn - modules deprecated in 5.12 are gone in 5.14 - you’ll have to install them from CPAN - do you care? no, because they are: Stuff That’s Gone
39. perlsyn - modules deprecated in 5.12 are gone in 5.14 - you’ll have to install them from CPAN - do you care? no, because they are: - Class::ISA Stuff That’s Gone
40. perlsyn - modules deprecated in 5.12 are gone in 5.14 - you’ll have to install them from CPAN - do you care? no, because they are: - Class::ISA - Pod::Plainer Stuff That’s Gone
41. perlsyn - modules deprecated in 5.12 are gone in 5.14 - you’ll have to install them from CPAN - do you care? no, because they are: - Class::ISA - Pod::Plainer - Switch Stuff That’s Gone
42. Perl4::CoreLibs Stuff That’s Going
43. Perl4::CoreLibs - Devel::DProf - use Devel::NYTProf instead! - the Perl 4 core - bigrat.pl, ftp.pl, etc - Perl4::CoreLibs - Shell (again) Stuff That’s Going
44. attributes :=
45. attributes := sub login : Local { ... }
46. attributes := sub login : Local { ... } my $x : Private = 10;
47. attributes := sub login : Local { ... } my $x : Private = 10; my $x := 10;
48. attributes := sub login : Local { ... } my $x : Private = 10; my $x := 10;
49. perlop qw() for my $show qw(Smallville Lost V) { $tivo->cancel_pass( $show ); }
50. perlop qw() for my $show (qw(Smallville Lost V)) { $tivo->cancel_pass( $show ); }
51. perl5140delta That’s it!
52. perl5140delta - those are all the things being removed That’s it!
53. perl5140delta - those are all the things being removed - these are not scary removals That’s it!
54. perlsyn One More Thing!
55. perlsyn One More Thing! $str =~ m/foo/sand bar;
56. perlsyn One More Thing! $str =~ m/foo/sand bar; $str =~ m/foo/s and bar;
57. perlre New Regex Modifiers my $hostname = get_hostname; $hostname =~ s/\..*//;
58. perlre New Regex Modifiers my $hostname = get_hostname =~ s/\..*//;
59. perlre New Regex Modifiers (my $hostname = get_hostname) =~ s/\..*//;
60. perlre New Regex Modifiers my $hostname = get_hostname =~ s/\..*//r;
61. perlre New Regex Modifiers my @short_names = map { s/\..*//; } @long_names;
62. perlre New Regex Modifiers my @short_names = map { s/\..*//; $_ } @long_names;
63. perlre New Regex Modifiers my @short_names = map { my $x = $_; $x =~ s/\..*//; $x } @long_names;
64. perlre New Regex Modifiers my @short_names = map { s/\..*//r } @long_names;
65. perlre New Regex Modifiers my @short_names = map s/\..*//r, @long_names;
66. perlre New Regex Modifiers /u /a /aa /l /d
67. perllocale New Regex Modifiers
68. perllocale New Regex Modifiers /l - use locale rules
69. perllocale New Regex Modifiers /l - use locale rules YOU DON’T WANT THIS
70. perlre New Regex Modifiers
71. perlre New Regex Modifiers /u - use Unicode rules
72. perlre New Regex Modifiers /u - use Unicode rules \d matches BENGALI DIGIT FOUR
73. perlre New Regex Modifiers /u - use Unicode rules \d matches BENGALI DIGIT FOUR \w matches LATIN SMALL LETTER ETH
74. perlre New Regex Modifiers /u - use Unicode rules \d matches BENGALI DIGIT FOUR \w matches LATIN SMALL LETTER ETH “\N{LATIN SMALL LIGATURE FF}” =~ /ff/ui
75. perlre New Regex Modifiers /a - Unicode, but ASCII rules for classes \d rejects BENGALI DIGIT FOUR \w rejects LATIN SMALL LETTER ETH “\N{LATIN SMALL LIGATURE FF}” =~ /ff/ai
76. perlre New Regex Modifiers /aa - Unicode, ASCII won’t match non-ASCII \d rejects BENGALI DIGIT FOUR \w rejects LATIN SMALL LETTER ETH “\N{LATIN SMALL LIGATURE FF}” !~ /ff/aai
77. perlre New Regex Modifiers /aa - Unicode, ASCII won’t match non-ASCII \d rejects BENGALI DIGIT FOUR \w rejects LATIN SMALL LETTER ETH “\N{LATIN SMALL LIGATURE FF}” !~ /ff/aai “\N{LATIN SMALL LIGATURE FF}” !~ /\pL/aai
78. perlre New Regex Modifiers
79. perlre New Regex Modifiers /d - default semantics
80. perlre New Regex Modifiers /d - default semantics Use Unicode if it’s seems like it’s
81. perlre New Regex Modifiers /d - default semantics Use Unicode if it’s seems like it’s maybe kinda unicode or the pattern
82. perlre New Regex Modifiers /d - default semantics Use Unicode if it’s seems like it’s maybe kinda unicode or the pattern uses \p or \N{...}
83. perlre New Regex Modifiers /d - default semantics Use Unicode if it’s seems like it’s maybe kinda unicode or the pattern uses \p or \N{...} Otherwise, on ASCII systems use ASCII
84. perlre New Regex Modifiers /d - default semantics Use Unicode if it’s seems like it’s maybe kinda unicode or the pattern uses \p or \N{...} Otherwise, on ASCII systems use ASCII Otherwise, on EBCDIC systems use Latin-1
85. perlre New Regex Modifiers /d - duhhhh-derrrrr semantics Use Unicode if it’s seems like it’s maybe kinda unicode or the pattern uses \p or \N{...} Otherwise, on ASCII systems use ASCII Otherwise, on EBCDIC systems use Latin-1
86. perlre New Regex Modifiers # To be really ASCII-only: die “funny un-American characters” if $str =~ /\P{ASCII}/; $str =~ /...actual pattern.../;
87. perlunitut What should I do??
88. perlunitut - Learn as much as you can! What should I do??
89. perlunitut - Learn as much as you can! - Seriously! What should I do??
90. perlunitut - Learn as much as you can! - Seriously! - Decode user input, encode output What should I do??
91. perlunitut - Learn as much as you can! - Seriously! - Decode user input, encode output - use re ‘/aa’ What should I do??
92. perlunitut - Learn as much as you can! - Seriously! - Decode user input, encode output - use re ‘/aa’ - use the \p_ classes What should I do??
93. perlunitut - Learn as much as you can! - Seriously! - Decode user input, encode output - use re ‘/aa’ - use the \p_ classes - But mostly: learn more. What should I do??
94. perluniprops Unicode Properties - \p{...} - \p{Alphabetic} \p{Letter} - \p{Number} - \p{Punctuation}, \p{Symbol} - UAX 44 table 9
95. perlre New Regex Modifiers
96. perlre New Regex Modifiers $ perl-5.12.4 -E ‘say qr//’
97. perlre New Regex Modifiers $ perl-5.12.4 -E ‘say qr//’ (?-xism:)
98. perlre New Regex Modifiers $ perl-5.12.4 -E ‘say qr//’ (?-xism:) $ perl-5.14.1 -E ‘say qr//’
99. perlre New Regex Modifiers $ perl-5.12.4 -E ‘say qr//’ (?-xism:) $ perl-5.14.1 -E ‘say qr//’ (?^u:)
100. perlunitut Perl is really good at Unicode.
101. perlunitut Perl is really good at Unicode. Unicode is just that complex.
102. perlunitut - ...well, as long as we’re on the subject... More Unicode!
103. charnames Unicode 6
104. charnames Unicode 6
105. charnames Unicode 6
106. charnames Unicode 6
107. charnames Unicode 6
108. charnames Unicode 6
109. charnames Unicode 6
110. charnames Unicode 6
111. charnames Unicode 6
112. charnames Unicode 6
113. charnames Unicode 6
114. perlunitut - “unicode_strings” feature is improved - \N{...} understands abbreviations, does named sequences - ...and you can make your own - better support for surrogates and non- characters More Unicode!
115. Container Improvements
116. perl5120delta Stuff From 5.12
117. perl5120delta - local works more better Stuff From 5.12
118. perl5120delta - local works more better - assigning to $[ gets a warning Stuff From 5.12
119. perl5120delta - local works more better - assigning to $[ gets a warning - each works on arrays Stuff From 5.12
120. perl5140delta That Stuff in 5.14
121. perl5140delta - local works even more betterer That Stuff in 5.14
122. perl5140delta - local works even more betterer - assigning to ($[) gets a warning That Stuff in 5.14
123. perl5140delta - local works even more betterer - assigning to ($[) gets a warning - each works on arrayrefs That Stuff in 5.14
124. perlfunc each on arrayrefs my @array = qw( foo bar baz ) ; while (my ($k, $v) = each @array) { say “$k: $v”; }
125. perlfunc each on arrayrefs my @array = qw( foo bar baz ) ; while (my ($k, $v) = each @array) { say “$k: $v”; } 0: foo 1: bar 2: baz
126. perlfunc each on arrayrefs my $array = [ qw( foo bar baz ) ]; while (my ($k, $v) = each $array) { say “$k: $v”; } 0: foo 1: bar 2: baz
127. perlfunc each on arrayrefs
128. perlfunc each on arrayrefs my ($x, $y) = each @{ $h->{foo}[1] }
129. perlfunc each on arrayrefs my ($x, $y) = each @{ $h->{foo}[1] } my ($x, $y) = each $h->{foo}[1]
130. AVOID each @array
131. perlfunc built-ins on references
132. perlfunc built-ins on references push $arrayref
133. perlfunc built-ins on references push $arrayref pop $arrayref
134. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref
135. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref
136. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref
137. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref keys $arrayref
138. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref keys $arrayref values $arrayref
139. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref keys $arrayref values $arrayref each $arrayref
140. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref keys $arrayref values $arrayref each $arrayref keys $hashref
141. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref keys $arrayref values $arrayref each $arrayref keys $hashref values $hashref
142. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref keys $arrayref values $arrayref each $arrayref keys $hashref values $hashref each $hashref
143. perlfunc built-ins on references push $arrayref pop $arrayref shift $arrayref unshift $arrayref splice $arrayref keys $arrayref values $arrayref each $arrayref keys $hashref values $hashref each $hashref EXPERIMENTAL
144. perlfunc built-ins on references
145. perlfunc built-ins on references sub demo (+$) {
146. perlfunc built-ins on references sub demo (+$) { my ($x, $y) = @_;
147. perlfunc built-ins on references sub demo (+$) { my ($x, $y) = @_; # do stuff
148. perlfunc built-ins on references sub demo (+$) { my ($x, $y) = @_; # do stuff }
149. perlfunc built-ins on references sub demo (+$) { my ($x, $y) = @_; # do stuff } demo( @array, $n );
150. perlfunc built-ins on references sub demo (+$) { my ($x, $y) = @_; # do stuff } demo( @array, $n ); demo(\@array, $n );
151. perlfunc built-ins on references sub demo (+$) { my ($x, $y) = @_; # do stuff } demo( @array, $n ); demo(\@array, $n ); demo( %hash, $n );
152. perlfunc built-ins on references sub demo (+$) { my ($x, $y) = @_; # do stuff } demo( @array, $n ); demo(\@array, $n ); demo( %hash, $n ); demo(\%hash, $n );
153. perlfunc Package Blocks package Library::Awesome; our $VERSION = 1.234; sub foo { ... } 1;
154. perlfunc Package Blocks package Library::Awesome 1.234 { sub foo { ... } } 1;
155. perlfunc Package Blocks package Library::Awesome 1.234 { sub foo { ... } } 1;
156. perlfunc Package Blocks package Library::Awesome 0.2-1alpha { sub foo { ... } } 1;
157. perlfunc Package Blocks package Library::Awesome 1.234; sub foo { ... } 1;
158. perlmodlib Speaking of Packages
159. perlmodlib Speaking of Packages - Perl 5.14 removed a bunch of modules
160. perlmodlib Speaking of Packages - Perl 5.14 removed a bunch of modules - ...so there was room to add new ones!
161. HTTP::Tiny HTTP::Tiny use 5.14.0; use HTTP::Tiny; my $http = HTTP::Tiny->new; my $res = $http->get( $url ); print $res->{content} if $res->{success};
162. JSON::PP JSON::PP use JSON::PP; my $data = decode_json( $json_string ); my $json = encode_json( $data_struct );
163. JSON::PP
164. JSON::PP use 5.14.0;
165. JSON::PP use 5.14.0; use autodie;
166. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny;
167. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP;
168. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’;
169. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new;
170. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose );
171. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success};
172. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success}; my $dist = decode_json( $json );
173. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success}; my $dist = decode_json( $json ); my $tgz = $http->get( $json->{download_url} );
174. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success}; my $dist = decode_json( $json ); my $tgz = $http->get( $json->{download_url} ); die $tgz->{reason} unless $tgz->{success};
175. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success}; my $dist = decode_json( $json ); my $tgz = $http->get( $json->{download_url} ); die $tgz->{reason} unless $tgz->{success}; open my $fh, ‘>’, $dist->{archive};
176. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success}; my $dist = decode_json( $json ); my $tgz = $http->get( $json->{download_url} ); die $tgz->{reason} unless $tgz->{success}; open my $fh, ‘>’, $dist->{archive}; $fh->print( $tgz->{content} );
177. JSON::PP use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success}; my $dist = decode_json( $json ); my $tgz = $http->get( $json->{download_url} ); die $tgz->{reason} unless $tgz->{success}; open my $fh, ‘>’, $dist->{archive}; $fh->print( $tgz->{content} ); $fh->close;
178. IO::File use 5.14.0; use autodie; use HTTP::Tiny; use JSON::PP; my $moose = ‘http://api.metacpan.org/release/Moose’; my $http = HTTP::Tiny->new; my $json = $http->get( $moose ); die $json->{reason} unless $json->{success}; my $dist = decode_json( $json ); my $tgz = $http->get( $json->{download_url} ); die $tgz->{reason} unless $tgz->{success}; open my $fh, ‘>’, $dist->{archive}; $fh->print( $tgz->{content} ); $fh->close;
179. perlopentut IO::File open my $fh, ‘<’, $some_filename or die “can’t open fh: $!”; print {$fh} “Some output.”; close $fh or die “can’t close fh: $!”;
180. autodie IO::File use 5.10.1; use autodie; open my $fh, ‘>’, $some_filename; print {$fh} “Some output.”; close $fh;
181. IO::File IO::File use 5.10.1; use autodie; use IO::File; open my $fh, ‘>’, $some_filename; $fh->print( “Some output.” ); $fh->close;
182. IO::File IO::File use 5.14.0; use autodie; use IO::File; open my $fh, ‘>’, $some_filename; $fh->print( “Some output.” ); $fh->close;
183. IO::File IO::File use 5.14.0; use autodie; open my $fh, ‘>’, $some_filename; $fh->print( “Some output.” ); $fh->close;
184. IO::File IO::File use 5.14.0; use autodie; open my $fh, ‘>’, $some_filename; $fh->print( “Some output.” ); $fh->close or die “can’t close: $!”;
185. perlvar $@
186. Try::Tiny $@
187. Try::Tiny $@ - Well, actually, you use Try::Tiny, right?
188. Try::Tiny $@ - Well, actually, you use Try::Tiny, right? - But this makes Try::Tiny more reliable, too!
189. Try::Tiny $@ - Well, actually, you use Try::Tiny, right? - But this makes Try::Tiny more reliable, too! - You see, eval and $@ are totally awful
190. perlfunc use 5.12.0; { package X; sub DESTROY { eval { } } } eval { my $x = bless {} => ‘X’; die “DEATH!!”; }; warn “ERROR: $@”;
191. perlfunc use 5.12.0; { package X; sub DESTROY { eval { } } } eval { my $x = bless {} => ‘X’; die “DEATH!!”; }; warn “ERROR: $@”; $ perl5.12.4 test.pl ERROR:
192. perlfunc use 5.14.0; { package X; sub DESTROY { eval { } } } eval { my $x = bless {} => ‘X’; die “DEATH!!”; }; warn “ERROR: $@”;
193. perlfunc 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!!
194. Socket IPv6 Support!
195. Socket IPv6 Support! - IPv4 is getting pretty old
196. Socket IPv6 Support! - IPv4 is getting pretty old - not a big deal
197. Socket IPv6 Support! - IPv4 is getting pretty old - not a big deal - won’t run out of addresses until 2011-04-15
198. Socket IPv6 Support! - IPv4 is getting pretty old - not a big deal - won’t run out of addresses until 2011-04-15 - …the future!
199. More Random Stuff
200. perlsyn say “I \o{23145} Perl 5.14!”;
201. perlsyn say “I \o{23145} Perl 5.14!”; I — Perl 5.14!
202. perlsyn say “I \23145 Perl 5.14!”; I ?45 Perl 5.14!
203. perlsyn say “I \023145 Perl 5.14!”; I 145 Perl 5.14!
204. perlre # Pretend there are 15 captures: qr{ (1) (2) (3) (4) \7 \10 (5) (6) (7) (8) (9) \7 \10 (10) \7 \10 }x;
205. perlre # Pretend there are 15 captures: qr{ (1) (2) (3) (4) \o{7} \o{10} (5) (6) (7) (8) (9) \o{7} \o{10} (10) \g{7} \g{10} }x;
206. perlsyn my @hex = (0x0D, 0x0A); my @bin = (0b1101, 0b1010);
207. perlsyn my @hex = (0x0D, 0x0A); my @bin = (0b1101, 0b1010); my @hex = (0X0D, 0X0A); my @bin = (0B1101, 0B1010);
208. perlfunc printf “%hhu\n”, 10; printf “%tu\n”, 10; printf “%zu\n”, 10;
209. perlfunc printf “%hhu\n”, 10; # char printf “%tu\n”, 10; # ptrdiff_t printf “%zu\n”, 10; # size_t
210. perlfunc 0.0416303447718782
211. perlfunc perl -E ‘srand(1); say rand;’
212. perlfunc my $seed = srand;
213. http://www.perl.org/get.html
214. Any questions?