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. DateTime

14. DBIx::Class

15. TryCatch

17. autodie

18. Catalyst

19. PSGI/Plack

21. 11:00 – Coffee break

22. 13:00 – Lunch

23. 14:00 – Begin

24. 16:00 – Coffee break

25. 17:00 – End

27. Template Toolkit

29. Advantages are well known

30. Standard look and feel (static/dynamic)

31. Reusable components

32. Separation of code logic from display logic

33. Different skill-sets (HTML vs Perl)

35. See perlfaq4

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

38. Don't do that

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

41. Many, many more

43. Template language

45. Very powerful

46. Both web and non-web

47. Simple template language

48. Plugins give access to much of CPAN

50. Good Book Too!

52. Data + Alternative Template = Alternative Output

53. Different views of the same data

54. Only the template changes

59. Just add new output template

60. Perl programmer need not be involved

62. DateTime

64. time – seconds since 1st Jan 1970

65. localtime – convert to human-readable

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

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

69. Dozens of date/time modules on CPAN

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

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

72. Which one do you choose?

74. "The DateTime family of modules present a unified way to handle dates and times in Perl"

75. "unified" is good

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

80. For date arithmetic you need a duration

81. Number of years, weeks, days, etc

84. strftime uses UNIX standards

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

87. DateTime::Format::HTTP

88. DateTime::Format::MySQL

89. DateTime::Format::Excel

92. DateTime::Calendar::Julian

93. DateTime::Calendar::Hebrew

94. DateTime::Calendar::Mayan

95. DateTime::Fiction::JRRTolkien::Shire

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

98. DBIx::Class

100. Tables (relations) map onto classes

101. Rows (tuples) map onto objects

102. Columns (attributes) map onto attributes

103. Don't write SQL

105. Select all the details of this row

106. Select something about related tables

107. Update this row with these values

108. Insert a new record with these values

109. Delete this record

111. SELECT * FROM my_table WHERE my_id = 10

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

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

115. Or something similar

117. Each class needs an associated table

118. Each class needs a list of columns

119. Create simple SQL for basic CRUD operations

120. Don't do that

122. Class::DBI

123. Rose::DB::Object

124. ORLite

127. Learning from problems in Class::DBI

128. More flexible

129. More powerful

131. Three tables

132. artist (artistid, name)

133. cd (cdid, artist, title)

134. track (trackid, cd, title)

147. Information is repeated

148. Columns and relationships defined in the database schema

149. Columns and relationships defined in class definitions

153. Just tables and columns

154. No relationships. No constraints

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

157. It's what your database is for

158. It's what your database does best

160. Nonsense

161. All data will be shared eventually

162. People will update your database using other applications

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

165. Nonsense

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

168. Don't be constrained by using inferior tools

170. No more repeated data

171. We are now DRY

172. Schema definitions in one place

173. But...

174. Performance problems

176. Need to generate the classes in advance

177. dump_to_dir method

178. Regenerate classes each time schema changes

180. Doesn't need to be SQL DDL

181. Could be Perl code

183. Might need to generate ALTER TABLE

185. Avoid writing SQL in common cases

186. DBIx::Class is the currently fashionable module

187. Caveat: ORM may be overkill for simple programs

189. DBIx::Class

190. DBIx::Class::Manual::*

191. DBIx::Class::Schema::Loader

192. Mailing list (Google for it)

193. TryCatch

195. Return error values from subroutines

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

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

199. Caller assumes that $obj is a valid object

200. Bad things follow

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

203. Now caller has to deal with exceptions

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

207. 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, ); } }

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

210. Looks a lot like many other languages

217. See also Try::Tiny

218. Moose

220. Based on Perl 6 object model

222. Set of abstractions for components of an object system

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

228. Turns on strict and warnings

230. Constrainted to be an integer

233. Uses generated method to set y

234. Direct hash access for x

238. No accessor function - private attribute

240. New clear method for subclass

241. Called after method for superclass

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

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

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

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

248. Use is to define rw or ro

249. Omitting is gives an attribute with no accessors

251. Used for both getting and setting the attribute

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

253. say $dave->first_name;

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

256. See also MooseX::FollowPBP

258. Change this with required

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

260. Forces constructor to expect a name

261. Although that name could be undef

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

264. Can use a subroutine reference

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

268. Support for concepts like delegation and roles

270. autodie

272. But you have to explicitly code to throw exceptions

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

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

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

277. You might not even get any warnings

279. Comes with Perl since 5.003

280. Errors in built-in functions become fatal errors

281. This solves our previous problem

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

284. Unintelligent check for success or failure

285. Checks return value for true/false

286. Assumes false is failure

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

291. In Perl core since 5.10.1

292. Fatal needed a list of built-ins

297. Not just a boolean check

298. Understands fork, system, etc

300. Can be inspected for details of the error

301. 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;; }

304. perldoc autodie

306. Catalyst

310. Django (Python)

311. Struts (Java)

312. CakePHP

313. Many examples in most languages

314. Perl has many options

317. Squatting

318. Mojolicious

320. Building on other heavily-used tools

321. Model uses DBIx::Class

322. View uses Template Toolkit

323. These are just defaults

324. Can use anything you want

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

329. Test stubs

330. Helpers for creating models, views and controllers

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

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

334. Simple Catalyst App

336. Write controller code to tie it all together

338. URL resolution

339. Session handling

340. etc...

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

344. Remove response_body line

345. Default behaviour is to render index.tt

346. Need to create that

348. New Front Page

350. Need to add a model class

351. And then more views

352. And some controllers

353. There's a lot to do

354. I recommend working through a tutorial

356. Given a database

357. Produce screens to edit the data

358. Surely most of this can be automated

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

360. (Demo)

362. On the fly

363. For every request

364. No security on table updates

365. So it's not right for every project

366. Very impressive though

368. Using the right framework can help

369. Catalyst is the most popular Perl framework

371. Large team, active development

373. Matt S Trout

374. PSGI/Plack

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

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

380. Each is subtly different

381. Hard to move an application between server architectures

383. FastCGI

384. mod_perl

385. etc...

387. Each creates applications in subtly different ways

388. Hard to port applications between them

390. PSGI is that specification

393. Passed a reference to an environment hash

395. Headers

396. Body

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

405. Browse to URL

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

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

411. 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; }

413. Returns another PSGI application

414. Simple spec makes this easy

415. Plack::Middleware::*

416. Plack::Builder adds middleware configuration language

423. Configured using Plack::Builder

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

428. Many more

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

431. Also Catalyst::Helper::PSGI

432. script/myapp_create.pl PSGI

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

435. Perlbal::Plugin::PSGI

437. mod_psgi

438. Plack::Handler::Apache2

441. Plack is an implementation

442. PSGI makes your life easier

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

444. No excuse not to use it

446. perldoc Plack

447. http://plackperl.org/

448. http://blog.plackperl.org/

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

450. #plack on irc.perl.org

452. Perl continues to grow and change

453. Perl is not a “scripting language”

454. Perl is a powerful and flexible programming language

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