Introducing Modern Perl

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 Template Toolkit

13. DateTime

14. DBIx::Class

15. TryCatch

16. What We Will Cover Moose

17. autodie

18. Catalyst

19. PSGI/Plack

20. Schedule 09:00 – Begin

21. 11:00 – Coffee break

22. 13:00 – Lunch

23. 14:00 – Begin

24. 16:00 – Coffee break

25. 17:00 – End

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

27. Template Toolkit

28. Templates Many people use templates to produce web pages

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)

34. DIY Templating Must be easy - so many people do it

35. See perlfaq4

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

37. DIY Templating $text = 'this has a $foo in it and a $bar'; %user_defs = ( foo => 23, bar => 19, ); $text =~ s/\$(\w+)/$user_defs{$1}/g;

38. Don't do that

39. Templating Options Dozens of template modules on CPAN

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

41. Many, many more

42. Questions to consider HTML only?

43. Template language

44. Template Toolkit http://tt2.org/

45. Very powerful

46. Both web and non-web

47. Simple template language

48. Plugins give access to much of CPAN

49. Can use Perl code if you want But don't do that

50. Good Book Too!

51. The Template Equation Data + Template = Output

52. Data + Alternative Template = Alternative Output

53. Different views of the same data

54. Only the template changes

55. Simple TT Example use Template; use My::Object; my ($id, $format) = @ARGV; $format ||= 'html'; my $obj = My::Object->new($id) or die; my $tt = Template->new; $tt->process("$format.tt", { obj => $obj }, "$id.$format") or die $tt->error;

56. html.tt <html> <head> <title>[% obj.name %]</title> </head> <body> <h1>[% obj.name %]<h1> <p><img src=“[% obj.img %]” /><br /> [% obj.desc %]</p> <ul> [% FOREACH child IN obj.children -%] <li>[% child.name %]</li> [% END %] </body> </html>

57. text.tt [% obj.name | upper %] Image: [% obj.img %] [% obj.desc %] [% FOREACH child IN obj.children -%] * [% child.name %] [% END %]

58. Adding New Formats No new code required

59. Just add new output template

60. Perl programmer need not be involved

61. Equation Revisited Data + Template = Output Template Toolkit Template + Output = Data Template::Extract Data + Output = Template Template::Generate

62. DateTime

63. Dates & Times Perl has built-in functions to handle dates and times

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

68. Dates & Times on CPAN Look to CPAN for a better answer

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?

73. Perl DateTime Project http://datetime.perl.org/

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

77. Using DateTime use DateTime; my $dt = DateTime->now; say $dt; # 2010-08-02T10:06:07 say $dt->dmy; # 2010-08-02 say $dt->hms; # 10:06:07

78. Using DateTime use DateTime; my $dt = DateTime->new(year => 2010, month => 8, day => 2); say $dt->ymd('/'); # 2010/08/02 say $dt->month; # 8 say $dt->month_name; # August

79. Arithmetic A DateTime object is a point in time

80. For date arithmetic you need a duration

81. Number of years, weeks, days, etc

82. Arithmetic use DateTime; my $dt = DateTime->new(year => 2010, month => 8, day => 2); my $two_weeks = DateTime::Duration->new(weeks => 2); $dt += $two_weeks; say $dt; # 2010-08-16T00:00:00

83. Formatting Output use DateTime; my $dt = DateTime->new(year => 2010, month => 4, day => 14); say $dt->strftime('%A, %d %B %Y'); # Wednesday, 14 April 2010

84. strftime uses UNIX standards

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

86. Parsing & Formatting Ready made parsers and formatters for popular date and time formats

87. DateTime::Format::HTTP

88. DateTime::Format::MySQL

89. DateTime::Format::Excel

90. DateTime::Format::Baby the big hand is on...

91. Alternative Calendars Handling non-standard calendars

92. DateTime::Calendar::Julian

93. DateTime::Calendar::Hebrew

94. DateTime::Calendar::Mayan

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

96. Calendar Examples use DateTime::Calendar::Mayan; my $dt = DateTime::Calendar::Mayan->now; say $dt->date; # 12.19.17.9.13

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

98. DBIx::Class

99. Object Relational Mapping Mapping database relations into objects

100. Tables (relations) map onto classes

101. Rows (tuples) map onto objects

102. Columns (attributes) map onto attributes

103. Don't write SQL

104. SQL Is Tedious Select the id and name from this table

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

110. Replacing SQL Instead of

111. SELECT * FROM my_table WHERE my_id = 10

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

113. Replacing SQL We can write

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

115. Or something similar

116. Writing An ORM Layer Not actually that hard to do yourself

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

121. Perl ORM Options Plenty of choices on CPAN

122. Class::DBI

123. Rose::DB::Object

124. ORLite

125. DBIx::Class The current favourite Fey::ORM

126. DBIx::Class Standing on the shoulders of giants

127. Learning from problems in Class::DBI

128. More flexible

129. More powerful

130. DBIx::Class Example Modeling a CD collection

131. Three tables

132. artist (artistid, name)

133. cd (cdid, artist, title)

134. track (trackid, cd, title)

135. Main Schema Define main schema class

136. Music/DB.pm package Music::DB; use base qw/DBIx::Class::Schema/; __PACKAGE__->load_classes(); 1;

137. Object Classes - Artist Music/DB/Artist.pm package Music::DB::Artist; use base qw/DBIx::Class/; __PACKAGE__->load_components(qw/Core/); __PACKAGE__->table('artist'); __PACKAGE__->add_columns(qw/ artistid name /); __PACKAGE__->set_primary_key('artistid'); __PACKAGE__->has_many(cds => 'Music::DB::Cd'); 1;

138. Object Classes- CD Music/DB/CD.pm package Music::DB::CD; use base qw/DBIx::Class/; __PACKAGE__->load_components(qw/Core/); __PACKAGE__->table('cd'); __PACKAGE__->add_columns(qw/ cdid artist title year /); __PACKAGE__->set_primary_key('cdid'); __PACKAGE__->belongs_to( artist => 'Music::DB:Artist'); 1;

139. Inserting Artists my $schema = Music::DB->connect($dbi_str); my @artists = ('Florence + The Machine', 'Belle and Sebastian'); my $art_rs = $schema->resultset('Artist'); foreach (@artists) { $art_rs->create({ name => $_ }); }

140. Inserting CDs Hash of Artists and CDs my %cds = ( 'Lungs' => 'Florence + The Machine', 'The Boy With The Arab Strap' => 'Belle and Sebastian', 'Dear Catastrophe Waitress' => 'Belle and Sebastian', );

141. Inserting CDs Find each artist and insert CD foreach (keys $cds) { my ($artist) = $art_rs->search( { name => $cds{$_} } ); $artist->add_to_cds({ title => $_, }); }

142. Retrieving Data Get CDs by artist my $name = 'Belle and Sebastian'; my ($artist) = $art_rs->search({ name => $name, }); foreach ($artist->cds) { say $_->title; }

143. Searching for Data Search conditions can be more complex

144. Alternatives $rs->search({year => 2006}, {year => 2007}); Like $rs->search({name => { 'like', 'Dav%' }});

145. Searching for Data Combinations $rs->search({forename => { 'like', 'Dav%' }, surname => 'Cross' });

146. Don't Repeat Yourself There's a problem with this approach

147. Information is repeated

148. Columns and relationships defined in the database schema

149. Columns and relationships defined in class definitions

150. Repeated Information CREATE TABLE artist ( artistid INTEGER PRIMARY KEY, name TEXT NOT NULL );

151. Repeated Information package Music::DB::Artist; use base qw/DBIx::Class/; __PACKAGE__->load_components(qw/Core/); __PACKAGE__->table('artist'); __PACKAGE__->add_columns(qw/ artistid name /); __PACKAGE__->set_primary_key('artistid'); __PACKAGE__->has_many(cds => 'Music::DB::Cd'); 1;

152. Database Metadata Some people don't put enough metadata in their databases

153. Just tables and columns

154. No relationships. No constraints

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

156. Database Metadata Describe your data in your database

157. It's what your database is for

158. It's what your database does best

159. No Metadata (Excuse 1) "This is the only application that will ever access this database"

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?

164. No Metadata (Excuse 2) "Database doesn't support those features"

165. Nonsense

166. MySQL 3.x is not a database It's a set of data files with a vaguely SQL-like query syntax MySQL 4.x is a lot better

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

168. Don't be constrained by using inferior tools

169. DBIC::Schema::Loader Creates classes by querying your database metadata

170. No more repeated data

171. We are now DRY

172. Schema definitions in one place

173. But...

174. Performance problems

175. Performance Problems You don't really want to generate all your class definitions each time your program is run

176. Need to generate the classes in advance

177. dump_to_dir method

178. Regenerate classes each time schema changes

179. Alternative Approach Need one canonical definition of the data tables

180. Doesn't need to be SQL DDL

181. Could be Perl code

182. Generate DDL from DBIx::Class definitions Harder approach

183. Might need to generate ALTER TABLE

184. Conclusions ORM is a bridge between relational objects and program objects

185. Avoid writing SQL in common cases

186. DBIx::Class is the currently fashionable module

187. Caveat: ORM may be overkill for simple programs

188. More Information Manual pages (on CPAN)

189. DBIx::Class

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

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

192. Mailing list (Google for it)

193. TryCatch

194. Error Handling How do you handle errors in your code?

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

197. Problems What if someone doesn't check return code?

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

199. Caller assumes that $obj is a valid object

200. Bad things follow

201. Basic Exceptions Throw an exception instead

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

204. Dealing with Exceptions Use eval to catch exceptions

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

206. Exceptions as Objects $@ can be set to an object

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

208. Try Catch TryCatch adds “syntactic sugar”

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

210. Looks a lot like many other languages

211. TryCatch with Scalar try { some_function_that_might_die(); } catch ($e) { if ($e =~ /some error/) { # handle error } else { die $e; } }

212. TryCatch with Object try { some_function_that_might_die(); } catch ($e) { if ($e->type eq 'file') { # handle error } else { die $e; } }

213. Better Checks try { some_function_that_might_die(); } catch (My::Error $e) { # handle error }

214. Even Better Checks try { some_function_that_might_die(); } catch (HTTP::Error $e where { $e->code == 404 }) { # handle 404 error }

215. Multiple Checks try { some_function_that_might_die(); } catch (HTTP::Error $e where { $e->code == 404 }) { # handle 404 error } catch (HTTP::Error $e where { $e->code == 500 }) { # handle 500 error } catch (HTTP::Error $e) { # handle other HTTP error } catch ($e) { # handle other error }

216. More Information perldoc TryCatch

217. See also Try::Tiny

218. Moose

219. Moose A complete modern object system for Perl 5

220. Based on Perl 6 object model

221. Built on top of Class::MOP MOP - Meta Object Protocol

222. Set of abstractions for components of an object system

223. Classes, Objects, Methods, Attributes An example might help

224. Moose Example package Point; use Moose; has 'x' => (isa => 'Int', is => 'ro'); has 'y' => (isa => 'Int', is => 'rw'); sub clear { my $self = shift; $self->{x} = 0; $self->y(0); }

225. Understanding Moose There's a lot going on here

226. use Moose Loads Moose environment

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

228. Turns on strict and warnings

229. Creating Attributes has 'x' => (isa => 'Int', is => 'ro') Creates an attribute called 'x'

230. Constrainted to be an integer

231. Read-only accessor has 'y' => (isa => 'Int', is => 'rw')

232. Defining Methods sub clear { my $self = shift; $self->{x} = 0; $self->y(0); } Standard method syntax

233. Uses generated method to set y

234. Direct hash access for x

235. Subclassing package Point3D; use Moose; extends 'Point'; has 'z' => (isa => 'Int'); after 'clear' => sub { my $self = shift; $self->{z} = 0; };

236. Subclasses extends 'Point' Similar to use base

237. Overwrites @ISA instead of appending has 'z' => (isa = 'Int') Adds new attribute 'z'

238. No accessor function - private attribute

239. Extending Methods after 'clear' => sub { my $self = shift; $self->{z} = 0; };

240. New clear method for subclass

241. Called after method for superclass

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

243. Creating Objects Moose classes are used just like any other Perl class

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

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

246. More About Attributes Use the has keyword to define your class's attributes

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

248. Use is to define rw or ro

249. Omitting is gives an attribute with no accessors

250. Getting & Setting By default each attribute creates a method of the same name.

251. Used for both getting and setting the attribute

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

253. say $dave->first_name;

254. Change Accessor Name Change accessor names using reader and writer

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

256. See also MooseX::FollowPBP

257. Required Attributes Moose class attributes are optional

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

262. Attribute Defaults Set a default value for an attribute with default

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

264. Can use a subroutine reference

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

266. Attribute Properties lazy Only populate attribute when queried trigger Subroutine called after the attribute is set isa Set the type of an attribute Many more

267. More Moose Many more options

268. Support for concepts like delegation and roles

269. Powerful plugin support MooseX::* Lots of work going on in this area

270. autodie

271. More on Exceptions Exceptions force callers to deal with error conditions

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?

275. Not Checking Errors open my $fh, '<', 'somefile.txt'; while (<$fh>) { # do something useful }

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

277. You might not even get any warnings

278. Automatic Exceptions use Fatal qw(open);

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

283. However Fatal.pm has its own problems

284. Unintelligent check for success or failure

285. Checks return value for true/false

286. Assumes false is failure

287. Can't be used if function can legitimately return a false value e.g. fork

288. Also Nasty error messages

289. $ perl -MFatal=open -E'open my $fh, "notthere"' 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

290. Enter autodie autodie is a cleverer Fatal

291. In Perl core since 5.10.1

292. Fatal needed a list of built-ins

293. autodie assumes all built-ins use autodie;

294. Turning autodie on/off Lexically scoped use autodie;

295. no autodie; Turn off for specific built-ins no autodie 'open';

296. Failing Calls autodie has more intelligence about failing calls

297. Not just a boolean check

298. Understands fork, system, etc

299. Errors are Objects Errors thrown by autodie are objects

300. Can be inspected for details of the error

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

302. Nicer Errors Too $ perl -Mautodie -E'open my $fh, "not-there"' Can't open($fh, 'not-there'): No such file or directory at -e line 1

303. More Information perldoc Fatal

304. perldoc autodie

305. autodie - The art of Klingon Programming http://perltraining.com.au/tips/2008-08-20.html

306. Catalyst

307. MVC Frameworks MVC frameworks are a popular way to write applications Particularly web applications

308. M, V and C Model Data storage & data access View Data presentation layer Controller Business logic to glue it all together

309. MVC Examples Ruby on Rails

310. Django (Python)

311. Struts (Java)

312. CakePHP

313. Many examples in most languages

314. Perl has many options

315. MVC in Perl Maypole The original Perl MVC framework CGI::Application Simple MVC for CGI programming Jifty Developed and used by Best Practical Catalyst Currently the popular choice

316. Newer MVC in Perl Dancer

317. Squatting

318. Mojolicious

319. Catalyst MVC framework in Perl

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

325. Simple Catalyst App Assume we already have model CD database from DBIx::Class section Use catalyst.pl to create project

326. $ catalyst.pl CD created "CD" created "CD/script" created "CD/lib" created "CD/root" ... many more ...

327. What Just Happened? Catalyst just generated a lot of useful stuff for us

328. Test web servers Standalone and FastCGI Configuration files

329. Test stubs

330. Helpers for creating models, views and controllers

331. A Working Application We already have a working application

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

335. Next Steps Use various helper programs to create models and views for your application

336. Write controller code to tie it all together

337. Many plugins to handle various parts of the process Authentication

338. URL resolution

339. Session handling

340. etc...

341. Create a View $ script/cd_create.pl view Default TT exists "/home/dave/training/cdlib/CD/script/../lib/CD/View" exists "/home/dave/training/cdlib/CD/script/../t" created "/home/dave/training/cdlib/CD/script/../lib/CD/View/Default.pm" created "/home/dave/training/cdlib/CD/script/../t/view_Default.t"

342. Remove Default Message In lib/CD/Controller/Root.pm

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

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

348. New Front Page

349. Adding Data Of course that's hard-coded data

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

355. Easier Catalyst A lot of web applications do similar things

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)

361. Cat::Plugin::AutoCRUD Does a lot of work

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

367. Conclusions There's a lot to bear in mind when writing a web app

368. Using the right framework can help

369. Catalyst is the most popular Perl framework

370. As powerful as any other framework In any language Lots of work still going on

371. Large team, active development

372. Recommended Book The Definitive Guide to Catalyst Kieren Diment

373. Matt S Trout

374. PSGI/Plack

375. PSGI/Plack “ PSGI is an interface between Perl web applications and web servers, and Plack is a Perl module and toolkit that contains PSGI middleware, helpers and adapters to web servers.” http://plackperl.org/

376. PSGI/Plack PSGI is a specification (based on Python's WSGI)

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

378. The Problem There are many ways to write web applications

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

382. Server Architectures CGI

383. FastCGI

384. mod_perl

385. etc...

386. Frameworks There are many Perl web application frameworks

387. Each creates applications in subtly different ways

388. Hard to port applications between them

389. The Goal What if we had a specification that allowed us to easily move web applications between server architectures and frameworks

390. PSGI is that specification

391. PSGI Application my $app = sub { my $env = shift; return [ 200, [ ‘Content-Type’, ‘text/plain’ ], [ ‘Hello World’ ], ]; };

392. PSGI Application A code reference

393. Passed a reference to an environment hash

394. Returns a reference to a three-element array Status code

395. Headers

396. Body

397. A Code Reference my $app = sub { my $env = shift; return [ 200, [ ‘Content-Type’, ‘text/plain’ ], [ ‘Hello World’ ], ]; };

398. A Code Reference my $app = sub { my $env = shift; return [ 200, [ ‘Content-Type’, ‘text/plain’ ], [ ‘Hello World’ ], ]; };

399. Environment Hash my $app = sub { my $env = shift; return [ 200, [ ‘Content-Type’, ‘text/plain’ ], [ ‘Hello World’ ], ]; };

400. Environment Hash my $app = sub { my $env = shift; return [ 200, [ ‘Content-Type’, ‘text/plain’ ], [ ‘Hello World’ ], ]; };

401. Return Array Ref my $app = sub { my $env = shift; return [ 200, [ ‘Content-Type’, ‘text/plain’ ], [ ‘Hello World’ ], ]; };

402. Return Array Ref my $app = sub { my $env = shift; return [ 200, [ ‘Content-Type’, ‘text/plain’ ], [ ‘Hello World’ ], ]; };

403. Running PSGI App Put code in app.psgi

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

405. Browse to URL

406. PSGI-Aware Server Plack contains a simple test server called plackup

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

408. Plack::Request Plack::Request turns the environment into a request object

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

410. Plack::Response Plack::Response builds a PSGI response object

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

412. Middleware Middleware wraps around an application

413. Returns another PSGI application

414. Simple spec makes this easy

415. Plack::Middleware::*

416. Plack::Builder adds middleware configuration language

417. Middleware Example use Plack::Builder; use Plack::Middleware::Runtime; my $app = sub { my $env = shift; return [ 200, [ 'Content-type', 'text/plain' ], [ 'Hello world' ], ] }; builder { enable 'Runtime'; $app; }

418. Middleware Example $ HEAD http://localhost:5000 200 OK Date: Tue, 20 Jul 2010 20:25:52 GMT Server: HTTP::Server::PSGI Content-Length: 11 Content-Type: text/plain Client-Date: Tue, 20 Jul 2010 20:25:52 GMT Client-Peer: 127.0.0.1:5000 Client-Response-Num: 1 X-Runtime: 0.000050

419. Middleware Example $ HEAD http://localhost:5000 200 OK Date: Tue, 20 Jul 2010 20:25:52 GMT Server: HTTP::Server::PSGI Content-Length: 11 Content-Type: text/plain Client-Date: Tue, 20 Jul 2010 20:25:52 GMT Client-Peer: 127.0.0.1:5000 Client-Response-Num: 1 X-Runtime: 0.000050

420. Plack::App::* Ready-made solutions for common situations

421. Plack::App::CGIBin Cgi-bin replacement Plack::App::Directory Serve files with directory index Plack::App::URLMap Map apps to different paths

422. Plack::App::* Many more bundled with Plack

423. Configured using Plack::Builder

424. Plack::App::CGIBin use Plack::App::CGIBin; use Plack::Builder; my $app = Plack::App::CGIBin->new( root => '/var/www/cgi-bin' )->to_app; builder { mount '/cgi-bin' => $app; };

425. Plack::App::Directory use Plack::App::Directory; my $app = Plack::App::Directory->new( root => '/home/dave/Dropbox/psgi' )->to_app;

426. Framework Support Many modern Perl applications already support PSGI

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

428. Many more

429. Catalyst Support Catalyst::Engine::PSGI

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

431. Also Catalyst::Helper::PSGI

432. script/myapp_create.pl PSGI

433. PSGI Server Support Many new web servers support PSGI

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

435. Perlbal::Plugin::PSGI

436. PSGI Server Support nginx support

437. mod_psgi

438. Plack::Handler::Apache2

439. Plack::Handler::Apache2 <Location /psgi> SetHandler perl-script PerlResponseHandler Plack::Handler::Apache2 PerlSetVar psgi_app /path/to/app.psgi </Location>

440. PSGI/Plack Summary PSGI is a specification

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

445. Further Information perldoc PSGI

446. perldoc Plack

447. http://plackperl.org/

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

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

450. #plack on irc.perl.org

451. Modern Perl Summary Perl has changed a lot in the last five years

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

456. That's all folks Any questions?

Introducing Modern Perl

Recommended

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Introducing Modern Perl (20)

More from Dave Cross (20)

Recently uploaded (20)

Introducing Modern Perl