Version of my "Introduction to Modern Perl" training course that I gave at YAPC::Europe 2011 in Riga.

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

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

8. Surveying modern modules and techniques

9. A lot to cover

10. Only an overview

11. Plenty of pointers to more information

13. Template Toolkit

14. DateTime

15. DBIx::Class

16. TryCatch

18. autodie

19. Catalyst

20. PSGI/Plack

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

28. Modern Core Perl

30. Major release every year

31. Minor releases when required

34. Well worth upgrading

36. Switch operator

37. Smart matching

38. say()

39. Lexical $_

41. Stacked file tests

42. Regex improvements

43. Many more

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;

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

53. A different slant on truth

54. Checks definedness

55. Shortcircuit version too

56. $val //= $value;

58. Source filter

62. Case is spelled “when”

63. Powerful matching syntax

66. when

67. default

68. continue

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

71. Similar to do { my $_ = 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”

78. default block is optional

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

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

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

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

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

97. Two characters shorter than print

98. Less typing

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 $_

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

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

107. Like static variables in C

109. -f -w -x $file

110. Previously you couldn't

111. Now you can

112. Equivalent to

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

115. Named capture buffers

116. Possessive quantifiers

117. Relative backreferences

118. New escape sequences

119. Many more

121. Named captures retain their names

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

123. Use new %+ hash to access them

126. Grab as much as they can

127. Never give it back

128. Finer control over backtracking

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

130. Never matches

132. More powerful version of , , etc

133. {1} is the same as

134. {-1} is the last capture buffer

135. {-2} is the one before that

137. – Vertical white space

138. Also and

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';

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”'

155. parent

157. ... operator

158. Implicit strictures

159. Y2038 compliance

161. Used to stand in for unwritten code

162. sub unimplemented { ... }

163. Code compiles

164. Throws an “unimplemented” exception when run

166. package My::Package 1.23;

167. Equivalent to

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

170. use 5.12.0;

171. Is equivalent to

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

175. No longer commutative

176. See new table in perlsyn

177. CAVEAT: More changes coming

179. autodie

182. 5.16 due spring 2012

184. Container functions accept references

185. Package block

186. New modules

188. Copies input

189. Acts on copy

190. Original unmodifed

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

194. @keys = keys %$hashref

198. package MyPackage { ... }

199. Equivalent to

200. { package MyPackage; ... }

201. Can also declare a version

202. package MyPackage 1.23 { ... }

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

205. CPAN::Meta

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

207. Module::Metadata

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

210. CPAN::Meta

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

212. Module::Metadata

214. perldoc perl5120delta

215. Perldoc perl5140delta

216. Template Toolkit

218. Advantages are well known

219. Standard look and feel (static/dynamic)

220. Reusable components

221. Separation of code logic from display logic

222. Different skill-sets (HTML vs Perl)

224. See perlfaq4

225. “How can I expand variables in text strings?”

227. Don't do that

229. Text::Template, HTML::Template, Mason, Template Toolkit

230. Many, many more

232. Template language

234. Very powerful

235. Both web and non-web

236. Simple template language

237. Plugins give access to much of CPAN

239. Good Book Too!

241. Data + Alternative Template = Alternative Output

242. Different views of the same data

243. Only the template changes

248. Just add new output template

249. Perl programmer need not be involved

251. DateTime

253. time – seconds since 1st Jan 1970

254. localtime – convert to human-readable

255. timelocal (in Time::Local) – inverse of localtime

256. strftime (in POSIX) – formatting dates and times

258. Dozens of date/time modules on CPAN

259. Date::Manip is almost never what you want

260. Date::Calc, Date::Parse, Class::Date, Date::Simple, etc

261. Which one do you choose?

263. &quot;The DateTime family of modules present a unified way to handle dates and times in Perl&quot;

264. &quot;unified&quot; is good

265. Dozens of modules that work together in a consistent fashion

269. For date arithmetic you need a duration

270. Number of years, weeks, days, etc

273. strftime uses UNIX standards

274. Control input format with DateTime::Format::Strptime

276. DateTime::Format::HTTP

277. DateTime::Format::MySQL

278. DateTime::Format::Excel

281. DateTime::Calendar::Julian

282. DateTime::Calendar::Hebrew

283. DateTime::Calendar::Mayan

284. DateTime::Fiction::JRRTolkien::Shire

286. use DateTime::Fiction::JRRTolkien::Shire; my $dt = DateTime::Fiction::JRRTolkien::Shire->now; say $dt->on_date; # Trewsday 14 Afterlithe 7474

287. DBIx::Class

289. Tables (relations) map onto classes

290. Rows (tuples) map onto objects

291. Columns (attributes) map onto attributes

292. Don't write SQL

294. Select all the details of this row

295. Select something about related tables

296. Update this row with these values

297. Insert a new record with these values

298. Delete this record

300. SELECT * FROM my_table WHERE my_id = 10

301. and then dealing with the prepare/execute/fetch code

303. use My::Object; # warning! not a real orm my $obj = My::Object->retrieve(10)

304. Or something similar

306. Each class needs an associated table

307. Each class needs a list of columns

308. Create simple SQL for basic CRUD operations

309. Don't do that

311. Class::DBI

312. Rose::DB::Object

313. ORLite

316. Learning from problems in Class::DBI

317. More flexible

318. More powerful

320. Three tables

321. artist (artistid, name)

322. cd (cdid, artist, title)

323. track (trackid, cd, title)

336. Information is repeated

337. Columns and relationships defined in the database schema

338. Columns and relationships defined in class definitions

342. Just tables and columns

343. No relationships. No constraints

344. You may as well make each column VARCHAR(255)

346. It's what your database is for

347. It's what your database does best

349. Nonsense

350. All data will be shared eventually

351. People will update your database using other applications

352. Can you guarantee that someone won't use mysql to update your database?

354. Nonsense

356. MySQL 5.x is most of the way there

357. Don't be constrained by using inferior tools

359. No more repeated data

360. We are now DRY

361. Schema definitions in one place

362. But...

363. Performance problems

365. Need to generate the classes in advance

366. dump_to_dir method

367. Regenerate classes each time schema changes

369. Doesn't need to be SQL DDL

370. Could be Perl code

372. Might need to generate ALTER TABLE

374. Avoid writing SQL in common cases

375. DBIx::Class is the currently fashionable module

376. Caveat: ORM may be overkill for simple programs

378. DBIx::Class

379. DBIx::Class::Manual::*

380. DBIx::Class::Schema::Loader

381. Mailing list (Google for it)

382. TryCatch

384. Return error values from subroutines

385. sub get_object { my ($class, $id) = @_; if (my $obj = find_obj_in_db($id)) { return $obj; } else { return; } }

387. my $obj = MyClass->get_object(100); print $obj->name; # error

388. Caller assumes that $obj is a valid object

389. Bad things follow

391. sub get_object { my ($class, $id) = @_; if (my $obj = find_obj_in_db($id)) { return $obj; } else { die “No object found with id: $id”; } }

392. Now caller has to deal with exceptions

394. my $obj = eval { MyClass->get_object(100) }; if ($@) { # handle exception... } else { print $obj->name; # error }

396. sub get_object { my ($class, $id) = @_; if (my $obj = find_obj_in_db($id)) { return $obj; } else { die MyException->new( type => 'obj_not_found', id => $id, ); } }

398. try { ... } catch ($e) { ... }

399. Looks a lot like many other languages

406. See also Try::Tiny

407. Moose

409. Based on Perl 6 object model

411. Set of abstractions for components of an object system

416. Makes our class a subclass of Moose::Object

417. Turns on strict and warnings

419. Constrainted to be an integer

422. Uses generated method to set y

423. Direct hash access for x

427. No accessor function - private attribute

429. New clear method for subclass

430. Called after method for superclass

431. Cleaner than $self->SUPER::clear()

433. $point = Point->new(x => 1, y => 2);

434. $p3d = Point3D->new(x => 1, y => 2, z => 3);

436. has 'first_name' => ( is => 'rw' );

437. Use is to define rw or ro

438. Omitting is gives an attribute with no accessors

440. Used for both getting and setting the attribute

441. $dave->first_name('Dave');

442. say $dave->first_name;

444. has 'name' => ( is => 'rw', reader => 'get_name', writer => 'set_name', );

445. See also MooseX::FollowPBP

447. Change this with required

448. has 'name' => ( is => 'ro', required => 1, );

449. Forces constructor to expect a name

450. Although that name could be undef

452. has 'size' => ( is => 'rw', default => 'medium', );

453. Can use a subroutine reference

454. has 'size' => ( is => 'rw', default => amp;rand_size, );

457. Support for concepts like delegation and roles

459. autodie

461. But you have to explicitly code to throw exceptions

462. open my $fh, '<', 'somefile.txt' or die $!;

463. What if you forget to check the return value?

465. If the 'open' fails, you can't read any data

466. You might not even get any warnings

468. Comes with Perl since 5.003

469. Errors in built-in functions become fatal errors

470. This solves our previous problem

471. open my $fh, '<', 'somefile.txt';

473. Unintelligent check for success or failure

474. Checks return value for true/false

475. Assumes false is failure

478. $ perl -MFatal=open -E'open my $fh, &quot;notthere&quot;' Can't open(GLOB(0x86357a4), notthere): No such file or directory at (eval 1) line 4 main::__ANON__('GLOB(0x86357a4)', 'notthere') called at -e line 1

480. In Perl core since 5.10.1

481. Fatal needed a list of built-ins

486. Not just a boolean check

487. Understands fork, system, etc

489. Can be inspected for details of the error

490. try { open my $fh, '<', 'not-there'; } catch ($e) { warn 'Error opening ', $e->args->[-1], &quot;&quot;; warn 'File: ', $e->file, &quot;&quot;; warn 'Function: ', $e->function, &quot;&quot;; warn 'Package: ', $e->package, &quot;&quot;; warn 'Caller: ', $e->caller, &quot;&quot;; warn 'Line: ', $e->line, &quot;&quot;; }

493. perldoc autodie

495. Catalyst

499. Django (Python)

500. Struts (Java)

501. CakePHP

502. Many examples in most languages

503. Perl has many options

506. Squatting

507. Mojolicious

509. Building on other heavily-used tools

510. Model uses DBIx::Class

511. View uses Template Toolkit

512. These are just defaults

513. Can use anything you want

515. $ catalyst.pl CD created &quot;CD&quot; created &quot;CD/script&quot; created &quot;CD/lib&quot; created &quot;CD/root&quot; ... many more ...

518. Test stubs

519. Helpers for creating models, views and controllers

521. $ CD/script/cd_server.pl ... lots of output [info] CD powered by Catalyst 5.7015 You can connect to your server at http://localhost:3000

522. Of course, it doesn't do much yet

523. Simple Catalyst App

525. Write controller code to tie it all together

527. URL resolution

528. Session handling

529. etc...

532. sub index :Path :Args(0) { my ( $self, $c ) = @_; # Hello World $c->response_body($c->welcome_message); }

533. Remove response_body line

534. Default behaviour is to render index.tt

535. Need to create that

537. New Front Page

539. Need to add a model class

540. And then more views

541. And some controllers

542. There's a lot to do

543. I recommend working through a tutorial

545. Given a database

546. Produce screens to edit the data

547. Surely most of this can be automated

548. It's called Catalyst::Plugin::AutoCRUD

549. (Demo)

551. On the fly

552. For every request

553. No security on table updates

554. So it's not right for every project

555. Very impressive though

557. Using the right framework can help

558. Catalyst is the most popular Perl framework

560. Large team, active development

562. Matt S Trout

563. PSGI/Plack

566. Plack is a reference implementation (based on Ruby's Rack)

568. There are many ways to write web applications in Perl

569. Each is subtly different

570. Hard to move an application between server architectures

572. FastCGI

573. mod_perl

574. etc...

576. Each creates applications in subtly different ways

577. Hard to port applications between them

579. PSGI is that specification

582. Passed a reference to an environment hash

584. Headers

585. Body

593. Drop in into a configured PSGI-aware web server

594. Browse to URL

596. $ plackup app.psgi HTTP::Server::PSGI: Accepting connections at http://localhost:5000/

598. use Plack::Request; use Data::Dumper; my $app = sub { my $req = Plack::Request->new(shift); return [ 200, [ 'Content-type', 'text/plain' ], [ Dumper $req ], ]; }

600. use Plack::Request; use Plack::Response; use Data::Dumper; my $app = sub { my $req = Plack::Request->new(shift); my $res = Plack::Response->new(200); $res->content_type('text/plain'); $res->body(Dumper $req); return $res->finalize; }

602. Returns another PSGI application

603. Simple spec makes this easy

604. Plack::Middleware::*

605. Plack::Builder adds middleware configuration language

612. Configured using Plack::Builder

616. Catalyst, CGI::Application, Dancer, Jifty, Mason, Maypole, Mojolicious, Squatting, Web::Simple

617. Many more

619. use MyApp; MyApp->setup_engine('PSGI'); my $app = sub { MyApp->run(@_) };

620. Also Catalyst::Helper::PSGI

621. script/myapp_create.pl PSGI

623. Starman, Starlet, Twiggy, Corona, HTTP::Server::Simple::PSGI

624. Perlbal::Plugin::PSGI

626. mod_psgi

627. Plack::Handler::Apache2

630. Plack is an implementation

631. PSGI makes your life easier

632. Most of the frameworks and server you use already support PSGI

633. No excuse not to use it

635. perldoc Plack

636. http://plackperl.org/

637. http://blog.plackperl.org/

638. http://github.com/miyagawa/Plack

639. #plack on irc.perl.org

641. Perl continues to grow and change

642. Perl is not a “scripting language”

643. Perl is a powerful and flexible programming language

644. Perl is a great way to get your job done