Ciconf 2012 - Better than Ad-hoc

Better than Ad-hocHow 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(‘config’ => ‘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();Monday, August 13, 2012

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(){

public function __construct(){...}}

$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 RefinedFoo extends Foo{...}

$foo = new RefinedFoo($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 herereturn $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(){...}));Monday, August 13, 2012

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())

);Monday, August 13, 2012

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 __construct(){...}

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

}...}


//registryfunction &is_loaded($class = ''){ static $_is_loaded = array();

if ($class !== '') { $_is_loaded[strtolower($class)] = $class; }

return $_is_loaded;}


function &load_class($class, $directory = 'libraries', $prefix = '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 files// 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


Date post:	05-Dec-2014
Category:	Technology
Upload:	calvin-froedge
View:	2,012 times
Download:	0 times

Ciconf 2012 - Better than Ad-hoc

Technology