Ciconf 2012 - Better than Ad-hoc

Better than Ad-hoc
How to Make Things Suck (Less)

Monday, August 13, 2012

SAURON, THE DARK LORD

I’ll leave what happens
next to the imagination.


Seriously though...


What are patterns?


- Repeatable solutions to common design problems



- Standardized names




- Essential for framework and library sustainability





- Rules can be bent





- Rules can be bent

- The result of good initial design or necessary refactoring





- Rules can be bent


- Will change the way you think about programming





- Rules can be bent


- Will change the way you think about programming

- Will lead the people to the promised land


Classical Patterns


Classical Patterns
- First real work done in the 1980s


Classical Patterns

- GOF released in 1994 (“Design Patterns, Elements of
Reusable Object Oriented Software”)


Classical Patterns


- Much writing and evolution since


Classical Patterns


- Much writing and evolution since

- Important, but not sacred


Quick Overview


Quick Overview
- Creational patterns deal with how objects are created


Quick Overview

- Structural patterns deal with how objects are composed


Quick Overview

- Structural patterns deal with how objects are composed

- Behavior patterns deal with how objects are utilized


Creational Patterns


abstract class AbstractFactory()
{
protected function shared(){...//shared}

abstract public function doSomething(){}
}

class ConcreteFactory extends AbstractFactory(){
public function doSomething(){..//unique}
}

$factory = new ConcreteFactory();


class FactoryMethod()
{
public function __construct(){...//shared}

public function __call($class, $args){
if ( class_exists($class) ) {
return new $class($args);
}
throw new Exception(“$class does not exist.”);
}
}

$factory = new FactoryMethod();
$factory->WidgetA(array(‘conﬁg’ => ‘item’));

class ObjectPool()
{
public $register = array(
‘Foo’,
‘Bar’
);

public function __construct($register = false){
...//register objects passed in constructor, build pool
}
}

$pool = new ObjectPool();
$pool->Foo->DoSomething();

class Singleton()
{
public $instance = false;

private function __construct($register = false){...}

public function __clone(){//throw error}

public static function instance(){
if( ! self::$instance )
self::$instance = new Singleton();
return self::$instance;
}
}

$s = Singleton::instance();

class Multiton()
{
public $instances = array();

private function __construct(){...}

public static function instance($name = ‘default’){
if( ! self::$instances[$name] )
self::$instances[$name] = new Multiton();
return self::$instances[$name];
}
}

$a = Multiton::instance(‘foo’);
$b = Multiton::instance(‘bar’);

class Director()
{
public function __construct(){...}

public function build($obj){
...//shared logic for manipulating object
}
}

class ConcreteBuilder()
{
}

$director = new Director();
$object = $director->build(new ConcreteBuilder())

class ConcretePrototype()
{
public $obj = false;

public $baz = “something cool”

public function __construct(){
$this->obj = new Foo();
}
}

$c = new ConcretePrototype();
$p = clone $c; //shallow copy
$x = unserialize(serialize($p)); //deep copy

Structural Patterns


class Foo()
{
public function __construct(){}
}

class FooAdapter()
{
public static function __callStatic($method, $args){
//Requests to Foo are translated. Foo is called and
response is returned.
}
}

$response = FooAdapter::FooMethod($args);

interface BridgeImplementation(){
public function doMethod($args);
}

class ConcreteA implements BridgeImplmentation(){
public function doMethod($args){...}
}

abstract class Foo{...}

class ReﬁnedFoo extends Foo{...}

$foo = new ReﬁnedFoo($args, new ConcreteA());
$result = $foo->doMethod($args);

class Compositte
{
public $nodes = array();

public $properties = array();

public function __construct($name, $properties){...}

public function node(Composite $node);
}

$nodeA = new Composite(array(‘bah’ => ‘test’));
$nodeB = new Composite(array(‘var’ => ‘haha’));
$nodeB->node(new Composite(array(‘baz’ => ‘bar’));
$nodeA->node($nodeB);

class Facade
{
public static function simpleMethod(){
$foo = HiddenByFacadeA::foo();
$baz = HiddenByFacadeB::bar($foo);
return HiddenByFacadeB::doh($baz);
}
}

class HiddenByFacadeA{...}

class HiddenByFacadeB{...}

$simple = Facade::simpleMethod();

class RemoteProxy
{
private static function request($method, $args){
../maybe some curl stuff here
return $remoteServiceCallResult;
}

public static function __callStatic($method, $args){
return self::request($method, $args);
}
}

$result = RemoteProxy::someMethod();


class Filter
{
public static function applyOne($data, $filter){
return ( $filter instanceof Closure )
? $filter($data) : self::$filter($data);
}

public static function applyAll($d, array $filters){
foreach($filters as $f) $data = self::applyOne($d, $f);
return $data;
}
...
}

$r = Filter::applyAll($data, array(‘foo’, function(){...}));

Behavioral Patterns


class ChainOfResponsibility()
{
public $next = false;

public function setNext($chained){
static::$next = $chained;
}
}

class ChainableA extends ChainOfResponsibility(){...}
class ChainableB extends ChainOfResponsibility(){...}
class ChainableC extends ChainOfResponsibility(){...}

new ChainableA()->setNext(
new ChainableB()->setNext(new ChainableC())
);

class ObserverA extends Observer(){...}

class ObservedFoo extends Observed()
{
public $observers = array(‘ObserverA’, ‘ObserverB’);

public function __call($method, $args){
...//do something
$this->notifyObservers($this->observers);
}
}

$subject = new ObservedFoo();
$subject->doSomething();

class Invoker extends Observer {...}

interface Command(){...}

class CommandA implements Command(){...}

$executeLater = Invoker::schedule(
“condition”,
“someMethod”,
new CommandA(array(‘foo’ => ‘bar’))
);


abstract class AbstractInterpreter(){...}

class InterpreterA extends AbstractInterpreter{...}

interface Expression(){...}

class String implements Expression{...}

class Number implements Expression{...}

class Command implements Expression{...}
...

$interpreted = new Interpreter()->interpret
(“var=doBaz.foo[tabba|too|3|a] && abacadbra[var]”)

interface Iterator {...}

abstract class MyIterator implements Iterator(){...}

class Util extends MyIterator(){...}

$iterator = new Util();

while( $iterator->valid() )
{
$iterator->current(); //Do something with this
$iterator->next();
}


class CareTaker{...}

trait Memento
{
public function recordState(){
CareTaker::recordState(__CLASS__, serialize($this));
}

public function restoreState(){...}
}

class Foo
{
use Memento; ...
}

interface Strategy{...}

class ConcreteStrategy implements Strategy {...}

class Context
{
public $strategy = false;

public function __construct($strategy){...}

public function applyStrategy(){...}
}

$context = new Context( new ConcreteStrategy() );

abstract class AbstractTemplate
{
...//shared implementation, enforced methods
}

class ConcreteTemplateA extends AbstractTemplate
{
..//concrete (custom) implementation
}

$template = new ConcreteTemplateA( );


Patterns on the Web


Patterns on the Web
- Once upon a time, nobody was thinking about software
design patterns in web apps


Patterns on the Web

- Desktop and mobile computing now often dependent
on remote (web) services


Patterns on the Web


- Now web apps / server apps can be wayyy complicated


Patterns on the Web


- Now web apps / server apps can be wayyy complicated

- Patterns help us apply systematic rigor to the complexity


Patterns in CodeIgniter


class Blog extends CI_Controller
{

public function index(){
...
$this->load->view(‘blog/index’);
}
}

class BlogModel extends CI_Model
{

public function posts(){...}
}

class CI_Hooks {...}

$config['enable_hooks'] = TRUE;

$hook['pre_controller'] = array(
'class' => 'MyClass',
'function' => 'Myfunction',
'filename' => 'Myclass.php',
'filepath' => 'hooks',
'params' => array('beer', 'wine', 'snacks')
);

$EXT->call_hook('pre_controller');


class CI_Controller {
private static $instance;


public static function &get_instance(){...}
}

function &get_instance()
{

return CI_Controller::get_instance();
}


class CI_Controller{...
public function __construct()
{
self::$instance =& $this;

foreach (is_loaded() as $var => $class) {
$this->$var =& load_class($class);
}

$this->load =& load_class(‘Loader’, ‘core’);

$this->load->initialize();
log_message(‘debug’, ‘Controller Class Initialized’);
}...
}

//registry
function &is_loaded($class = '')
{

static $_is_loaded = array();

if ($class !== '')

{

$_is_loaded[strtolower($class)] = $class;

}

return $_is_loaded;
}


function &load_class($class, $directory = 'libraries',
$preﬁx = 'CI_'){

static $_classes = array();
...

// Does the class exist? If so, we're done...

if (isset($_classes[$class])){

return $_classes[$class];

}
...

// Keep track of what we just loaded

is_loaded($class);
...

$_classes[$class] = new $name();

return $_classes[$class];
}

//Index.php (FrontController)

// Load CI core ﬁles
// Set some constants

// Pass on the request


if ( ! file_exists($driver_file))
{
show_error('Invalid DB driver');
}

require_once($driver_file);

// Instantiate the DB adapter
$driver = 'CI_DB_'.$params['dbdriver'].'_driver';
$DB = new $driver($params);


Reading List
- “Design Patterns: Elements of Reusable Object-
Oriented Software” by Erich Gamma, Richard
Helm, Ralph Johnson and John Vlissides

- SourceMaking.com and Design Patterns: Simply

- “Use of Design Patterns in PHP-based Web
Application Frameworks” by Andris Paikens


Reading List
- Everything on Wikipedia about Design Patterns

- “CodeComplete 2: A practical handbook of
software construction” by Steve McConnel

- “The Meditations” by Marcus Aurelius

- “Politics and the English Language” George Orwell


Me
@calvinfroedge

http://www.calvinfroedge.com

github.com/calvinfroedge


Fin


Ciconf 2012 - Better than Ad-hoc

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Ciconf 2012 - Better than Ad-hoc

Similar to Ciconf 2012 - Better than Ad-hoc (20)

Recently uploaded

Recently uploaded (20)

Ciconf 2012 - Better than Ad-hoc