The Advanced Perl course that I ran for the UKUUG in Feb 2009.

1. Advanced Perl Techniques A One Day Perl Tutorial Dave Cross Magnum Solutions Ltd [email_address]

3. Turn intermediate programmers into advanced programmers

4. “ Modern” Perl

5. Perl is not dying

7. We'll be moving fairly fast

8. Lots of pointers to other information

9. Feel free to ask questions

11. Dates and times

14. Object oriented programming with Moose

15. Templates

18. 11:15 – Coffee break

19. 13:00 – Lunch

20. 14:00 – Begin

21. 15:30 – Coffee break

22. 17:00 – End

24. Perl 5.10

26. Well worth upgrading

28. Switch operator

29. Smart matching

30. say()

31. Lexical $_

33. Stacked file tests

34. Regex improvements

35. Many more

37. $val = $val || $default;

38. $val ||= $default;

39. What if 0 is a valid value?

40. Need to check “definedness”

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

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

44. $val = $val // $default;

45. A different slant on truth

46. Checks definedness

47. Short version too

48. $val //= $default;

50. Source filter

54. Case is spelled “when”

55. Powerful matching syntax

58. when

59. default

60. continue

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

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

65. Uses smart matching to compare $_ with EXPR

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

67. ~~ is the new smart match operator

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

70. default block is optional

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

73. 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' } }

75. Different kinds of matches

76. Dependent on the types of the operands

77. See “perldoc perlsyn” for the full details

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

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

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

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

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

84. Many more alternatives

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

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

88. Two characters shorter than print

89. Less typing

91. Always exists in main package

92. Can lead to subtle bugs when not localised correctly

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

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

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

98. Like static variables in C

100. -f -w -x $file

101. Previously you couldn't

102. Now you can

103. Equivalent to

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

106. Named capture buffers

107. Possessive quantifiers

108. Relative backreferences

109. New escape sequences

110. Many more

112. Named captures retain their names

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

114. Use new %+ hash to access them

117. Grab as much as they can

118. Never give it back

119. Finer control over backtracking

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

121. Never matches

123. More powerful version of , , etc

124. {1} is the same as

125. {-1} is the last capture buffer

126. {-2} is the one before that

128. – Vertical white space

129. Also and

131. They are therefore turned off by default

132. Turn them on with the feature pragma

133. use feature 'say';

134. use feature 'switch';

135. use feature 'state';

136. use feature ':5.10';

138. Require a high enough version of Perl

139. use 5.10.0; # Or higher

140. -E command line option

141. perl -e 'say “hello”'

142. perl -E 'say “hello”'

143. Dates and Times

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

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

147. Which one do you choose?

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

150. &quot;unified&quot; is good

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

155. For date arithmetic you need a duration

156. Number of years, weeks, days, etc

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

161. DateTime::Format::HTTP

162. DateTime::Format::MySQL

163. DateTime::Format::Excel

166. DateTime::Calendar::Julian

167. DateTime::Calendar::Hebrew

168. DateTime::Calendar::Mayan

169. DateTime::Fiction::JRRTolkien::Shire

171. use DateTime::Fiction::JRRTolkien::Shire my $dt = DateTime::Fiction::JRRTolkien::Shire->now; say $dt->on_date; # Mersday 24 Solmath 7473

172. Testing

174. Does your code do what it is supposed to do?

175. Will your code continue to do what it is supposed to do?

176. Write unit tests

177. Run those tests all the time

179. Before you add a feature

180. After you have added a feature

181. Before checking in code

182. Before releasing code

183. Constantly, automatically

185. A lot of work in this area over the last eight years

186. Test::Simple and Test::More included in Perl distribution

187. Many more testing modules on CPAN

193. Runs given tests using Test::Harness

194. Comes with the Perl distribution

196. -r recurse

197. -s shuffle tests

198. Many more

200. Now this ad-hoc format has a definition and a name

201. The Test Anything Protocol (TAP)

202. See Test::Harness::TAP (documentation module) and TAP::Parser

206. Some of my favourites

207. Test::File

208. Test::Exception, Test::Warn

209. Test::Differences

210. Test::XML (includes Test::XML::XPath)

212. Built using Test::Builder

213. Ensures that test modules all use the same framework

214. Use it as the basis of your own Test::* modules

215. Who tests the testers?

216. Test your Test::Builder test modules with Test::Builder::Tester

218. Fake them

219. Test::MockObject pretends to be other objects

220. Gives you complete control over what they return

222. It's important that your code reacts correctly when the reactor overheats

223. You don't have a reactor in the test environment

225. Especially if you're not 100% sure of your code

226. Or if you're running unattended smoke tests

227. Fake it with a mock object

229. If you have tried cooling a reactor down 5 times and the temperature is still over 100 then return an error

234. Reactor object has two interesting methods

235. temperature - returns the current temperature

236. cooldown - cools reactor and returns success or failure

241. Devel::Cover can help you to find out

242. Deep internal magic

244. cover

245. Devel::Cover Output

246. Devel::Cover Output

247. Devel::Cover Output

249. Other frameworks are available

251. http://fit.c2.com

253. perldoc Test::Tutorial

254. perldoc Test::Simple

255. perldoc Test::More

256. perldoc Test::Builder

257. etc...

258. Benchmarking

260. But how fast is fast enough?

264. Simple usage

265. use Benchmark; my %methods = ( method1 => sub { ... }, method2 => sub { ... }, ); timethese(10_000, methods);

266. Times 10,000 iterations of each method

269. Passing timethese a negative number runs each piece of code for a certain number of seconds

272. Optional export

273. use Benchmark 'cmpthese'; my %methods = ( method1 => sub { ... }, method2 => sub { ... }, ); cmpthese(10_000, methods);

275. method2 is 61% slower than method1

276. Can also pass negative number to cmpthese

278. Harder to ensure that the numbers are meaningful

279. Compare code fragments that do the same thing

282. See which parts it is worth working on

284. Is called many times, or

285. Both

287. Included with Perl distribution

288. Uses Perl debugger hooks

289. perl -d:DProf your_program

290. Produces a data file called tmon.out

291. Command line program dprofpp to view results

294. Based on work from the New York Times

295. Enhanced by Tim Bunce

297. Far more powerful

299. $ perl -d:NYTProf ./invoice.pl 244

300. Writes nytprof.out

301. $ nytprofhtml

302. Or

303. $ nytprofcsv

305. Don't optimise until you know what to optimise

306. Use profiling to find out what is worth optimising

307. Use benchmarking to compare different solutions

309. perldoc Devel::DProf

310. perldoc Devel::NYTProf

311. Chapters 5 and 6 of Mastering Perl

312. Object Relational Mapping

314. Tables (relations) map onto classes

315. Rows (tuples) map onto objects

316. Columns (attributes) map onto attributes

317. Don't write SQL

319. Select all the details of this row

320. Select something about related tables

321. Update this row with these values

322. Insert a new record with these values

323. Delete this record

325. SELECT * FROM my_table WHERE my_id = 10

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

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

329. Or something similar

331. Each class needs an associated table

332. Each class needs a list of columns

333. Create simple SQL for basic CRUD operations

334. Don't do that

336. Tangram

337. SPOPS (Simple Perl Object Persistence with Security)

338. Alzabo

339. Class::DBI

342. Learning from problems in Class::DBI

343. More flexible

344. More powerful

346. Three tables

347. artist (artistid, name)

348. cd (cdid, artist, title)

349. track (trackid, cd, title)

351. DB/Main.pm

352. package DB::Main; use base qw/DBIx::Class::Schema/; __PACKAGE__->load_classes(); 1;

354. package DB::Main::Artist; use base qw/DBIx::Class/; __PACKAGE__->load_components(qw/PK::Auto Core/); __PACKAGE__->table('artist'); __PACKAGE__->add_columns(qw/ artistid name /); __PACKAGE__->set_primary_key('artistid'); __PACKAGE__->has_many(cds => 'DB::Main::Cd'); 1;

356. package DB::Main::CD; use base qw/DBIx::Class/; __PACKAGE__->load_components(qw/PK::Auto Core/); __PACKAGE__->table('cd'); __PACKAGE__->add_columns(qw/ cdid artist title year /); __PACKAGE__->set_primary_key('cdid'); __PACKAGE__->belongs_to(artist => 'DB::Main::Artist'); 1;

359. my %cds = ( 'The Three EPs' => 'The Beta Band', 'Trailer Park' => 'Beth Orton');

361. foreach (keys $cds) { my ($artist) = $art_rs->search( { name => $cds{$_} } ); $artist->add_to_cds({ title => $_, }); }

363. my ($artist) = $art_rs->search({ name => 'Beth Orton', }); foreach ($artist->cds) { say $_->title; }

367. Information is repeated

368. Columns and relationships defined in the database schema

369. Columns and relationships defined in class definitions

373. Just tables and columns

374. No relationships. No constraints

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

377. It's what your database is for

378. It's what your database does best

380. Bollocks

381. All data will be shared eventually

382. People will update your database using other applications

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

385. Bollocks

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

388. Don't be constrained by using inferior tools

390. No more repeated data

391. We are now DRY

392. Schema definitions in one place

393. But...

394. Performance problems

396. Need to generate the classes in advance

397. dump_to_dir method

398. Regenerate classes each time schema changes

400. Doesn't need to be SQL DDL

401. Could be in Perl code

402. Write DBIx::Class definitions

403. Generate DDL from those

406. Avoid writing SQL in common cases

407. DBIx::Class is the currently fashionable module

408. Lots of plugins

409. Caveat: ORM may be overkill for simple programs

411. DBIx::Class

412. DBIx::Class::Manual::*

413. DBIx::Class::Schema::Loader

414. Mailing list (Google for it)

415. Moose

417. Based on experiments with Perl 6 object model

419. Set of abstractions for components of an object system

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

425. Turns on strict and warnings

427. Constrainted to be an integer

430. Standard method syntax

431. Uses generated method to set y

432. Direct hash access for x

436. No accessor function - private attribute

438. New clear method for subclass

439. Called after method for superclass

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

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

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

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

446. Use is to define rw or ro

447. Omitting is gives an attribute with no accessors

449. Used for both getting and setting the attribute

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

451. say $dave->first_name;

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

454. See also MooseX::FollowPBP

456. Change this with required

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

458. Forces constructor to expect a name

459. Although that name could be undef

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

462. Can use a subroutine reference

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

466. Support for concepts like delegation and roles

468. Templating

470. Advantages are well known

471. Standard look and feel (static/dynamic)

472. Reusable components

473. Separation of code logic from display logic

474. Different skill-sets (HTML vs Perl)

476. Reports

477. Business documents

478. Configuration files

479. Anywhere you produce output

481. See perlfaq4

482. How can I expand variables in text strings?

484. Don't do that

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

487. Many, many more

491. Very powerful

492. Both web and non-web

493. Simple template language

494. Plugins give access to much of CPAN

496. Good Book Too!

498. Data + Alternative Template = Alternative Output

499. Different views of the same data

500. Only the template changes

505. Just add new output template

506. Perl programmer need not be involved

508. Catalyst

511. Django (Python)

512. Struts (Java)

513. CakePHP

514. Many examples in most languages

515. Perl has many options

518. Building on other heavily-used tools

519. Model uses DBIx::Class

520. View uses Template Toolkit

521. These are just defaults

522. Can use anything you want

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

527. Test stubs

528. Helpers for creating models, views and controllers

530. $ 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

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

532. Simple Catalyst App

534. Write controller code to tie it all together

536. URL resolution

537. Session handling

538. etc...

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

542. Remove response_body line

543. Default behaviour is to render index.tt

544. Need to create that

546. <html> <head> <title>CDs</title> </head> <body> <ul> [% FOREACH cd IN [ 1 .. 10 ] %] <li>CD [% cd %]</li> [% END %] </ul> </body> </html>

547. New Front Page

549. Need to add a model class

550. And then more views

551. And some controllers

552. There's a lot to do

553. I recommend working through a tutorial

555. Given a database

556. Produce screens to edit the data

557. Surely most of this can be automated

558. It's called CatalystX::ListFramework::Builder

559. (Demo)

561. On the fly

562. For every request

563. No security on table updates

564. So it's not right for every project

565. Very impressive though

567. Using the right framework can help

568. Catalyst is the most popular Perl framework

570. Large team, active development

571. Further Information

573. Web sites

574. Books

575. Magazines

576. Mailing lists

577. Conferences

579. Mailing list

584. High quality articles

587. Lists of many Perl-related sites

589. Perl Best Practices - Damian Conway

590. Advanced Perl Programming - Simon Cozens

591. Perl Hacks - chromatic, Conway & Poe

592. Intermediate Perl - Schwartz, foy & Phoenix

593. Mastering Perl - brian d foy

595. Minimal Perl - Tim Maher

596. Pro Perl Debugging - Richard Foley & Joe McMahon

600. SysAdmin

602. See http://lists.cpan.org/

604. Lisbon 3-5 August 2009

606. See http://yapc.org/