Moose Design Patterns

Moose Design
Patterns
Ynon Perek
ynonperek@yahoo.com
http://ynonperek.com

Tuesday, February 28, 2012

Good Code Bad Code


OOP Use Cases

• Write code that other developers
will use
• Write code that will survive in an ever
changing environment


Meet The Moose

Moose

• Post Modern Object Oriented Perl
• Consistent OO Framework
• Stable


A First Class
Class Def
package Person;

•
use Moose;
A class is just a package
has 'name', is => 'ro', isa => 'Str';
has 'age', is => 'rw', isa => 'Int';

• A method is just a sub

• An attribute is ...
Class Use
We’ll get to that later package main;
use feature ':5.10';

my $p = Person->new(name => "James");
say $p->name;


Object Methods
package Car;
use Moose;

has 'speed', is => 'ro'; • A method takes
the object
sub go {
    my $self = shift; (invocant) as its
    print "Vroom Vroom [speed: ", ﬁrst argument
            $self->speed,
            "]n";
}
• That’s why we use
package main; my $self = shift
my $c = Car->new(speed => 10);
$c->go;


Whats In The Box

• A new method

• use strict, use warnings

• Type Validation

• Organize Your Code


OO Design

OO Design
Patterns
Tested, Proven development
paradigms for speeding up
development process


Pattern Structure

• Name
• Problem
• Solution
• Consequences


Categories
Creational Behavioral Structural

Singleton Observer Mixins
Template
Factory
Method Composite
Builder
Flyweight


Creational Patterns
• Abstract instantiation process
• We must only create one log ﬁle instance
for the entire system
• An XML tree is built gradually,
node-by-node


Singleton Pattern

• Ensure a class only has one instance
• Manage Resource Sharing


Moose Singleton
package Logger;
use MooseX::Singleton;

sub debug { ... }
sub warn { ... }

package main;

my $logger = Logger->instance;
my $same = Logger->instance;

my $and_again = Logger->new;

$logger->debug("Hello World");


Factory
• Create a different object based
on some conditional
• Treat the newly created objects
the same way
• Practical: abstract away OS related code


Factory
package AppConfig;
use Moose::Role;

requires 'debug_mode'; • Use a Role to
requires 'native_separators';
specify common
requires 'root_fs'; behavior


Factory
package ConfigFactory;
use Moose;

sub build_config {
    my $cfg; • All creation logic
    given ($^O) { stays in the
        $cfg = WinConfig->new when /MSWin32/;
        $cfg = UnixConfig->new;
factory
    }
    return $cfg;
}


Factory

package main; • Users only need
to know about
my $cfg = ConfigFactory->build_config;
the role, not the
say $cfg->debug_mode; various
implementations


Creational Patterns


Behavioral Patterns

• Assignment of responsibility
between objects and classes
• Use either inheritance or composition


Template Methods

Template Method

• Separate the algorithm from the actual
implementation
• Deﬁne the skeleton of an algorithm
• Example: Paint on a canvas or printer


Painter Example
Draw Pixel


Roles: Partials
package Painter;

• Template methods are use Moose::Role;

implemented using roles requires 'drawPixel';

• Use requires to deﬁne a sub draw_line { ... }
sub draw_triangle { ... }
partial implementation sub draw_rectangle { ... }


Roles: Partials
package ScreenPainter;
use Moose;

with 'Painter';

sub draw_pixel { ... }

package main;
my $painter = ScreenPainter->new;

$painter->draw_line(0, 0, 100, 100);


Behavioral Patterns


Structural

• Control structure of an object
• Is it composed of other objects ?
• How are these parts used ?
• Composition, Decorator, Adapter


Composition: What

Send Mail Send Mail
Contact Email
Call
Call

Phone


Moose Composition

• Moose has a built-in support for delegation
• Use handles on an attribute to create an
effective composition
• Prefer composition over inheritance


Delegation: How
package Contact;

• Can take regular use Moose;

expressions has 'email' => (
    is => 'ro',
• Can take hashref     handles => [ qw/send_mail/ ]
);

• perldoc
Moose::Manual::Delegation my $c = Contact->new;
$c->send_mail(subject => "Hello",
              text => "...");


Delegation

• Delegation is explicit
• Performed via attributes
• Highly recommended


OO Design
Consider design patterns

Use the power of perl

Clean Code is worth it


Thanks For
Listening
Ynon Perek
ynonperek@yahoo.com
http://ynonperek.com


Moose Design Patterns

More Related Content

Similar to Moose Design Patterns

More from Ynon Perek

Recently uploaded

Moose Design Patterns