The document provides an overview of modern Perl, highlighting its evolution since the 1990s and introducing key features from recent releases, including Perl 5.10, 5.12, and 5.14. It discusses significant updates such as the defined-or operator, switch statements, smart matching, and enhancements in date/time handling and object-relational mapping with DBIx::Class. The presentation also emphasizes various templating options for web and non-web applications, showcasing the functionality of the Template Toolkit and examples of modern Perl methodologies.

1. Introducing Modern Perl Dave Cross Magnum Solutions Ltd [email_address]

2. Modern Perl Perl has been around for a long time

3. Achieved great popularity in the 1990s

4. “The duct tape of the internet”

5. Perl has moved on a lot since then

6. Many people's perceptions of Perl haven't

7. Modern Perl Keeping up to date with Perl

8. Surveying modern modules and techniques

9. A lot to cover

10. Only an overview

11. Plenty of pointers to more information

12. What We Will Cover Modern Core Perl

13. Template Toolkit

14. DateTime

15. DBIx::Class

16. TryCatch

17. What We Will Cover Moose

18. autodie

19. Catalyst

20. PSGI/Plack

21. Schedule 10:00 Start

22. 11:30 – 11:45 Coffee

23. 13:00 – 14:00 Lunch

24. 15:30 – 15:40 Coffee

25. 18:00 End

26. 18:00 Pre-Conference Meeting

27. Resources Slides available on-line http://mag-sol.com/train/yapc/2011 Also see Slideshare http://www.slideshare.net/davorg/slideshows Get Satisfaction http://getsatisfaction.com/magnum

28. Modern Core Perl

29. Perl Releases Perl 5 has moved to a regular release cycle

30. Major release every year

31. Minor releases when required

32. Release Numbering Even major numbers are production releases 5.10, 5.12, 5.14 Odd major numbers are dev releases 5.11, 5.13, 5.15

33. Perl 5.10 Released 18 th Dec 2007 Perl's 20 th birthday Many new features

34. Well worth upgrading

35. New Features Defined-or operator

36. Switch operator

37. Smart matching

38. say()

39. Lexical $_

40. New Features State variables

41. Stacked file tests

42. Regex improvements

43. Many more

44. Defined Or Boolean expressions “short-circuit”

45. $val = $val || $default;

46. $val ||= $default;

47. What if 0 is a valid value?

48. Need to check “definedness”

49. $val = defined $val ? $val : $default;

50. $val = $default unless defined $val;

51. Defined Or The defined or operator makes this easier

52. $val = $val // $default;

53. A different slant on truth

54. Checks definedness

55. Shortcircuit version too

56. $val //= $value;

57. Switch Statement Switch.pm was added with Perl 5.8

58. Source filter

59. Parser limitations Regular expressions

60. eval 5.10 introduces a build-in switch statement

61. Given ... When Switch is spelled “given”

62. Case is spelled “when”

63. Powerful matching syntax

64. Given Example given ($foo) { when (/^abc/) { $abc = 1; } when (/^def/) { $def = 1; } when (/^xyz/) { $xyz = 1; } default { $nothing = 1; } }

65. New Keywords Four new keywords given

66. when

67. default

68. continue

69. given given(EXPR)

70. Assigns the result of EXPR to $_ within the following block

71. Similar to do { my $_ = EXPR; ... }

72. when when (EXPR)

73. Uses smart matching to compare $_ with EXPR

74. Equivalent to when ($_ ~~ EXPR)

75. ~~ is the new smart match operator

76. Compares two values and “does the right thing”

77. default default defines a block that is executed if no when blocks match

78. default block is optional

79. continue continue keyword falls through to the next when block

80. Normal behaviour is to break out of given block once the first when condition is matched

81. continue given($foo) { when (/x/) { say '$foo contains an x'; continue } when (/y/) { say '$foo contains a y' } default { say '$foo contains no x or y' } }

82. Smart Matching ~~ is the new Smart Match operator

83. Different kinds of matches

84. Dependent on the types of the operands

85. See “perldoc perlsyn” for the full details

86. CAVEAT: Subject to change

87. Smart Match Examples $foo ~~ $bar; # == or cmp

88. @foo ~~ $bar; # array contains value

89. %foo ~~ $bar; # hash key exists

90. $foo ~~ qr{$bar}; # regex match

91. @foo ~~ @bar; # arrays are identical

92. %foo ~~ %bar; # hash keys match

93. Many more alternatives

94. say() say() is a new alternative to print()

95. Adds a new line at the end of each call

96. say($foo); # print $foo, “\n”;

97. Two characters shorter than print

98. Less typing

99. Lexical $_ $_ is a package variable

100. Always exists in main package

101. Can lead to subtle bugs when not localised correctly

102. Can now use my $_ to create a lexically scoped variable called $_

103. State Variables Lexical variables disappear when their scope is destroyed

104. sub variables { my $x; say ++$x; } variables() for 1 .. 3;

105. State Variables State variables retain their value when their scope is destroyed

106. sub variables { state $x; say ++$x; } variables() for 1 .. 3;

107. Like static variables in C

108. Stacked File Tests People often think you can do this

109. -f -w -x $file

110. Previously you couldn't

111. Now you can

112. Equivalent to

113. -x $file && -w _ && -f _

114. Regex Improvements Plenty of regular expression improvements

115. Named capture buffers

116. Possessive quantifiers

117. Relative backreferences

118. New escape sequences

119. Many more

120. Named Capture Buffers Variables $1, $2, etc change if the regex is altered

121. Named captures retain their names

122. (?<name> ... ) to define

123. Use new %+ hash to access them

124. Named Capture Example while (<DATA>) { if (/(?<header>[\w\s]+) :\s+(?<value>.+)/x) { print &quot;$+{header} -> &quot;; print &quot;$+{value}\n&quot;; } }

125. Possessive Quantifiers ?+ , *+ , ++

126. Grab as much as they can

127. Never give it back

128. Finer control over backtracking

129. 'aaaa' =~ /a++a/

130. Never matches

131. Relative Backreferences \g{N}

132. More powerful version of \1 , \2 , etc

133. \g{1} is the same as \1

134. \g{-1} is the last capture buffer

135. \g{-2} is the one before that

136. New Escape Sequences \h – Horizontal white space

137. \v – Vertical white space

138. Also \H and \V

139. Accessing New Features Some new features would break backwards compatibility

140. They are therefore turned off by default

141. Turn them on with the feature pragma

142. use feature 'say';

143. use feature 'switch';

144. use feature 'state';

145. use feature ':5.10';

146. Implicit Loading Two ways to automatically turn on 5.10 features

147. Require a high enough version of Perl

148. use 5.10.0; # Or higher

149. -E command line option

150. perl -e 'say “hello”'

151. perl -E 'say “hello”'

152. Perl 5.12 Released 12 April 2010 5.12.4 20 June 2011 Many new enhancements

153. 5.12 Enhancements Smart match changes

154. New modules autodie

155. parent

156. 5.12 Enhancements package NAME VERSION syntax

157. ... operator

158. Implicit strictures

159. Y2038 compliance

160. ... Operator Called the “yada-yada” operator

161. Used to stand in for unwritten code

162. sub unimplemented { ... }

163. Code compiles

164. Throws an “unimplemented” exception when run

165. package NAME VER Declare the version of a package in the package declaration

166. package My::Package 1.23;

167. Equivalent to

168. package My::Package; our $VERSION = 1.23;

169. Implicit Strictures Requiring a version of Perl greater than 5.11 implicitly turns on use strict

170. use 5.12.0;

171. Is equivalent to

172. use strict; use feature ':5.12';

173. Y2038 Compliance Core time functions are now Y2038 compliant

174. Smart Match Changes Some changes to Smart Match operator

175. No longer commutative

176. See new table in perlsyn

177. CAVEAT: More changes coming

178. New Modules Some new modules in the standard distribution

179. autodie

180. parent Better version of base.

181. Perl 5.14 Released 14 May 2011 5.14.1 16 June 2011 Many new enhancements

182. 5.16 due spring 2012

183. 5.14 Enhancements Non-destructive substitution

184. Container functions accept references

185. Package block

186. New modules

187. Non-destructive substitution New /r option on s/// and tr///

188. Copies input

189. Acts on copy

190. Original unmodifed

191. $_ = 'cat'; $new = s/cat/dog/r'; # $_ remains 'cat'

192. Container functions accept references Array & hash functions used to require arrays or hashes push @array, $value

193. @keys = keys %hash Even if you have a reference push @$arrayref, $value

194. @keys = keys %$hashref

195. Container functions accept references Array & hash functions now accept references push $array_ref, $value

196. @keys = keys $hash_ref Currently experimental

197. Package block Attach a code block to a package declaration

198. package MyPackage { ... }

199. Equivalent to

200. { package MyPackage; ... }

201. Can also declare a version

202. package MyPackage 1.23 { ... }

203. New Modules Many modules for parsing META files

204. CPAN::Meta::YAML & JSON::PP

205. CPAN::Meta

206. CPAN::Meta::Spec & CPAN::Meta::History

207. Module::Metadata

208. New Modules Other new modules

209. CPAN::Meta::YAML & JSON::PP

210. CPAN::Meta

211. CPAN::Meta::Spec & CPAN::Meta::History