Introducing Modern Perl

Introducing Modern Perl Dave Cross Magnum Solutions Ltd [email_address]

Modern Perl
Perl has been around for a long time
Achieved great popularity in the 1990s
“The duct tape of the internet”
Perl has moved on a lot since then
Many people's perceptions of Perl haven't

Modern Perl
Keeping up to date with Perl
Surveying modern modules and techniques
A lot to cover
Only an overview
Plenty of pointers to more information

What We Will Cover
Template Toolkit
DateTime
DBIx::Class
TryCatch

What We Will Cover
Moose
autodie
Catalyst
PSGI/Plack

Schedule
09:00 – Begin
11:00 – Coffee break
13:00 – Lunch
14:00 – Begin
16:00 – Coffee break
17:00 – End

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

Template Toolkit

Templates
Many people use templates to produce web pages
Advantages are well known
Standard look and feel (static/dynamic)
Reusable components
Separation of code logic from display logic
Different skill-sets (HTML vs Perl)

DIY Templating
Must be easy - so many people do it
See perlfaq4
“How can I expand variables in text strings?”

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;
Don't do that

Templating Options
Dozens of template modules on CPAN
Text::Template, HTML::Template, Mason, Template Toolkit
Many, many more
Questions to consider
HTML only?
Template language

Template Toolkit
http://tt2.org/
Very powerful
Both web and non-web
Simple template language
Plugins give access to much of CPAN
Can use Perl code if you want
But don't do that

Good Book Too!

The Template Equation
Data + Template = Output
Data + Alternative Template = Alternative Output
Different views of the same data
Only the template changes

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;

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>

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

Adding New Formats
No new code required
Just add new output template
Perl programmer need not be involved

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

DateTime

Dates & Times
Perl has built-in functions to handle dates and times
time – seconds since 1st Jan 1970
localtime – convert to human-readable
timelocal (in Time::Local) – inverse of localtime
strftime (in POSIX) – formatting dates and times

Dates & Times on CPAN
Look to CPAN for a better answer
Dozens of date/time modules on CPAN
Date::Manip is almost never what you want
Date::Calc, Date::Parse, Class::Date, Date::Simple, etc
Which one do you choose?

Perl DateTime Project
http://datetime.perl.org/
"The DateTime family of modules present a unified way to handle dates and times in Perl"
"unified" is good
Dozens of modules that work together in a consistent fashion

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

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

Arithmetic
A DateTime object is a point in time
For date arithmetic you need a duration
Number of years, weeks, days, etc

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

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
strftime uses UNIX standards
Control input format with DateTime::Format::Strptime

Parsing & Formatting
Ready made parsers and formatters for popular date and time formats
DateTime::Format::HTTP
DateTime::Format::MySQL
DateTime::Format::Excel
DateTime::Format::Baby
the big hand is on...

Alternative Calendars
Handling non-standard calendars
DateTime::Calendar::Julian
DateTime::Calendar::Hebrew
DateTime::Calendar::Mayan
DateTime::Fiction::JRRTolkien::Shire

Calendar Examples
use DateTime::Calendar::Mayan; my $dt = DateTime::Calendar::Mayan->now; say $dt->date; # 12.19.17.9.13
use DateTime::Fiction::JRRTolkien::Shire; my $dt = DateTime::Fiction::JRRTolkien::Shire->now; say $dt->on_date; # Trewsday 14 Afterlithe 7474

DBIx::Class

Object Relational Mapping
Mapping database relations into objects
Tables (relations) map onto classes
Rows (tuples) map onto objects
Columns (attributes) map onto attributes
Don't write SQL

SQL Is Tedious
Select the id and name from this table
Select all the details of this row
Select something about related tables
Update this row with these values
Insert a new record with these values
Delete this record

Replacing SQL
Instead of
SELECT * FROM my_table WHERE my_id = 10
and then dealing with the prepare/execute/fetch code

Replacing SQL
We can write
use My::Object; # warning! not a real orm my $obj = My::Object->retrieve(10)
Or something similar

Writing An ORM Layer
Not actually that hard to do yourself
Each class needs an associated table
Each class needs a list of columns
Create simple SQL for basic CRUD operations
Don't do that

Perl ORM Options
Plenty of choices on CPAN
Class::DBI
Rose::DB::Object
ORLite
DBIx::Class
The current favourite
Fey::ORM

DBIx::Class
Standing on the shoulders of giants
Learning from problems in Class::DBI
More flexible
More powerful

DBIx::Class Example
Modeling a CD collection
Three tables
artist (artistid, name)
cd (cdid, artist, title)
track (trackid, cd, title)

Main Schema
Define main schema class
Music/DB.pm
package Music::DB; use base qw/DBIx::Class::Schema/; __PACKAGE__->load_classes(); 1;

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;

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;

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 => $_ }); }

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

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

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

Searching for Data
Search conditions can be more complex
Alternatives
$rs->search({year => 2006}, {year => 2007});
Like
$rs->search({name => { 'like', 'Dav%' }});

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

Don't Repeat Yourself
There's a problem with this approach
Information is repeated
Columns and relationships defined in the database schema
Columns and relationships defined in class definitions

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

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;

Database Metadata
Some people don't put enough metadata in their databases
Just tables and columns
No relationships. No constraints
You may as well make each column VARCHAR(255)

Database Metadata
Describe your data in your database
It's what your database is for
It's what your database does best

No Metadata (Excuse 1)
"This is the only application that will ever access this database"
Nonsense
All data will be shared eventually
People will update your database using other applications
Can you guarantee that someone won't use mysql to update your database?

No Metadata (Excuse 2)
"Database doesn't support those features"
Nonsense
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
MySQL 5.x is most of the way there
Don't be constrained by using inferior tools

DBIC::Schema::Loader
Creates classes by querying your database metadata
No more repeated data
We are now DRY
Schema definitions in one place
But...
Performance problems

Performance Problems
You don't really want to generate all your class definitions each time your program is run
Need to generate the classes in advance
dump_to_dir method
Regenerate classes each time schema changes

Alternative Approach
Need one canonical definition of the data tables
Doesn't need to be SQL DDL
Could be Perl code
Generate DDL from DBIx::Class definitions
Harder approach
Might need to generate ALTER TABLE

Conclusions
ORM is a bridge between relational objects and program objects
Avoid writing SQL in common cases
DBIx::Class is the currently fashionable module
Caveat: ORM may be overkill for simple programs

More Information
Manual pages (on CPAN)
DBIx::Class
DBIx::Class::Manual::*
DBIx::Class::Schema::Loader
Mailing list (Google for it)

TryCatch

Error Handling
How do you handle errors in your code?
Return error values from subroutines
sub get_object { my ($class, $id) = @_; if (my $obj = find_obj_in_db($id)) { return $obj; } else { return; } }

Problems
What if someone doesn't check return code?
my $obj = MyClass->get_object(100); print $obj->name; # error
Caller assumes that $obj is a valid object
Bad things follow

Basic Exceptions
Throw an exception instead
sub get_object { my ($class, $id) = @_; if (my $obj = find_obj_in_db($id)) { return $obj; } else { die “No object found with id: $id”; } }
Now caller has to deal with exceptions

Dealing with Exceptions
Use eval to catch exceptions
my $obj = eval { MyClass->get_object(100) }; if ($@) { # handle exception... } else { print $obj->name; # error }

Exceptions as Objects
$@ can be set to an object
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, ); } }

Try Catch
TryCatch adds “syntactic sugar”
try { ... } catch ($e) { ... }
Looks a lot like many other languages

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

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

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

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

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 }

More Information
perldoc TryCatch
See also Try::Tiny

Moose
A complete modern object system for Perl 5
Based on Perl 6 object model
Built on top of Class::MOP
MOP - Meta Object Protocol
Set of abstractions for components of an object system
Classes, Objects, Methods, Attributes
An example might help

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

Understanding Moose
There's a lot going on here
use Moose
Loads Moose environment
Makes our class a subclass of Moose::Object
Turns on strict and warnings

Creating Attributes
has 'x' => (isa => 'Int', is => 'ro')
Creates an attribute called 'x'
Constrainted to be an integer
Read-only accessor
has 'y' => (isa => 'Int', is => 'rw')

Defining Methods
sub clear { my $self = shift; $self->{x} = 0; $self->y(0); }
Standard method syntax
Uses generated method to set y
Direct hash access for x

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

Subclasses
extends 'Point'
Similar to use base
Overwrites @ISA instead of appending
has 'z' => (isa = 'Int')
Adds new attribute 'z'
No accessor function - private attribute

Extending Methods
after 'clear' => sub { my $self = shift; $self->{z} = 0; };
New clear method for subclass
Called after method for superclass
Cleaner than $self->SUPER::clear()

Creating Objects
Moose classes are used just like any other Perl class
$point = Point->new(x => 1, y => 2);
$p3d = Point3D->new(x => 1, y => 2, z => 3);

More About Attributes
Use the has keyword to define your class's attributes
has 'first_name' => ( is => 'rw' );
Use is to define rw or ro
Omitting is gives an attribute with no accessors

Getting & Setting
By default each attribute creates a method of the same name.
Used for both getting and setting the attribute
$dave->first_name('Dave');
say $dave->first_name;

Change Accessor Name
Change accessor names using reader and writer
has 'name' => ( is => 'rw', reader => 'get_name', writer => 'set_name', );
See also MooseX::FollowPBP

Required Attributes
Moose class attributes are optional
Change this with required
has 'name' => ( is => 'ro', required => 1, );
Forces constructor to expect a name
Although that name could be undef

Attribute Defaults
Set a default value for an attribute with default
has 'size' => ( is => 'rw', default => 'medium', );
Can use a subroutine reference
has 'size' => ( is => 'rw', default => &rand_size, );

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

More Moose
Many more options
Support for concepts like delegation and roles
Powerful plugin support
MooseX::*
Lots of work going on in this area

autodie

More on Exceptions
Exceptions force callers to deal with error conditions
But you have to explicitly code to throw exceptions
open my $fh, '<', 'somefile.txt' or die $!;
What if you forget to check the return value?

Not Checking Errors
open my $fh, '<', 'somefile.txt'; while (<$fh>) { # do something useful }
If the 'open' fails, you can't read any data
You might not even get any warnings

Automatic Exceptions
use Fatal qw(open);
Comes with Perl since 5.003
Errors in built-in functions become fatal errors
This solves our previous problem
open my $fh, '<', 'somefile.txt';

However
Fatal.pm has its own problems
Unintelligent check for success or failure
Checks return value for true/false
Assumes false is failure
Can't be used if function can legitimately return a false value
e.g. fork

Also
Nasty error messages
$ 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

Enter autodie
autodie is a cleverer Fatal
In Perl core since 5.10.1
Fatal needed a list of built-ins
autodie assumes all built-ins
use autodie;

Turning autodie on/off
Lexically scoped
use autodie;
no autodie;
Turn off for specific built-ins
no autodie 'open';

Failing Calls
autodie has more intelligence about failing calls
Not just a boolean check
Understands fork, system, etc

Errors are Objects
Errors thrown by autodie are objects
Can be inspected for details of the error
try { open my $fh, '<', 'not-there'; } catch ($e) { warn 'Error opening ', $e->args->[-1], " "; warn 'File: ', $e->file, " "; warn 'Function: ', $e->function, " "; warn 'Package: ', $e->package, " "; warn 'Caller: ', $e->caller, " "; warn 'Line: ', $e->line, " "; }

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

More Information
perldoc Fatal
perldoc autodie
autodie - The art of Klingon Programming
http://perltraining.com.au/tips/2008-08-20.html

Catalyst

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

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

MVC Examples
Ruby on Rails
Django (Python)
Struts (Java)
CakePHP
Many examples in most languages
Perl has many options

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

Newer MVC in Perl
Dancer
Squatting
Mojolicious

Catalyst
MVC framework in Perl
Building on other heavily-used tools
Model uses DBIx::Class
View uses Template Toolkit
These are just defaults
Can use anything you want

Simple Catalyst App
Assume we already have model
CD database from DBIx::Class section
Use catalyst.pl to create project
$ catalyst.pl CD created "CD" created "CD/script" created "CD/lib" created "CD/root" ... many more ...

What Just Happened?
Catalyst just generated a lot of useful stuff for us
Test web servers
Standalone and FastCGI
Configuration files
Test stubs
Helpers for creating models, views and controllers

A Working Application
We already have a working application
$ 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
Of course, it doesn't do much yet

Simple Catalyst App

Next Steps
Use various helper programs to create models and views for your application
Write controller code to tie it all together
Many plugins to handle various parts of the process
Authentication
URL resolution
Session handling
etc...

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"

Remove Default Message
In lib/CD/Controller/Root.pm
sub index :Path :Args(0) { my ( $self, $c ) = @_; # Hello World $c->response_body($c->welcome_message); }
Remove response_body line
Default behaviour is to render index.tt
Need to create that

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>

New Front Page

Adding Data
Of course that's hard-coded data
Need to add a model class
And then more views
And some controllers
There's a lot to do
I recommend working through a tutorial

Easier Catalyst
A lot of web applications do similar things
Given a database
Produce screens to edit the data
Surely most of this can be automated
It's called Catalyst::Plugin::AutoCRUD
(Demo)

Cat::Plugin::AutoCRUD
Does a lot of work
On the fly
For every request
No security on table updates
So it's not right for every project
Very impressive though

Conclusions
There's a lot to bear in mind when writing a web app
Using the right framework can help
Catalyst is the most popular Perl framework
As powerful as any other framework
In any language
Lots of work still going on
Large team, active development

Recommended Book
The Definitive Guide to Catalyst
Kieren Diment
Matt S Trout

PSGI/Plack

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/

PSGI/Plack
PSGI is a specification (based on Python's WSGI)
Plack is a reference implementation (based on Ruby's Rack)

The Problem
There are many ways to write web applications
There are many ways to write web applications in Perl
Each is subtly different
Hard to move an application between server architectures

Server Architectures
CGI
FastCGI
mod_perl
etc...

Frameworks
There are many Perl web application frameworks
Each creates applications in subtly different ways
Hard to port applications between them

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

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

PSGI Application
A code reference
Passed a reference to an environment hash
Returns a reference to a three-element array
Status code
Headers
Body

A Code Reference

Environment Hash

Return Array Ref

Running PSGI App
Put code in app.psgi
Drop in into a configured PSGI-aware web server
Browse to URL

PSGI-Aware Server
Plack contains a simple test server called plackup
$ plackup app.psgi HTTP::Server::PSGI: Accepting connections at http://localhost:5000/

Plack::Request
Plack::Request turns the environment into a request object
use Plack::Request; use Data::Dumper; my $app = sub { my $req = Plack::Request->new(shift); return [ 200, [ 'Content-type', 'text/plain' ], [ Dumper $req ], ]; }

Plack::Response
Plack::Response builds a PSGI response object
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; }

Middleware
Middleware wraps around an application
Returns another PSGI application
Simple spec makes this easy
Plack::Middleware::*
Plack::Builder adds middleware configuration language

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

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

Plack::App::*
Ready-made solutions for common situations
Plack::App::CGIBin
Cgi-bin replacement
Plack::App::Directory
Serve files with directory index
Plack::App::URLMap
Map apps to different paths

Plack::App::*
Many more bundled with Plack
Configured using Plack::Builder

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

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

Framework Support
Many modern Perl applications already support PSGI
Catalyst, CGI::Application, Dancer, Jifty, Mason, Maypole, Mojolicious, Squatting, Web::Simple
Many more

Catalyst Support
Catalyst::Engine::PSGI
use MyApp; MyApp->setup_engine('PSGI'); my $app = sub { MyApp->run(@_) };
Also Catalyst::Helper::PSGI
script/myapp_create.pl PSGI

PSGI Server Support
Many new web servers support PSGI
Starman, Starlet, Twiggy, Corona, HTTP::Server::Simple::PSGI
Perlbal::Plugin::PSGI

PSGI Server Support
nginx support
mod_psgi
Plack::Handler::Apache2

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

PSGI/Plack Summary
PSGI is a specification
Plack is an implementation
PSGI makes your life easier
Most of the frameworks and server you use already support PSGI
No excuse not to use it

Further Information
perldoc PSGI
perldoc Plack
http://plackperl.org/
http://blog.plackperl.org/
http://github.com/miyagawa/Plack
#plack on irc.perl.org

Modern Perl Summary
Perl has changed a lot in the last five years
Perl continues to grow and change
Perl is not a “scripting language”
Perl is a powerful and flexible programming language
Perl is a great way to get your job done

That's all folks
Any questions?

Introducing Modern Perl

by Dave Cross

Accessibility

Categories

Upload Details

Usage Rights

1 Embed 1

Statistics

Introducing Modern Perl Presentation Transcript