9. - Repeatable solutions to common design problems
- Standardized names
Monday, August 13, 2012
10. - Repeatable solutions to common design problems
- Standardized names
- Essential for framework and library sustainability
Monday, August 13, 2012
11. - Repeatable solutions to common design problems
- Standardized names
- Essential for framework and library sustainability
- Rules can be bent
Monday, August 13, 2012
12. - Repeatable solutions to common design problems
- Standardized names
- Essential for framework and library sustainability
- Rules can be bent
- The result of good initial design or necessary refactoring
Monday, August 13, 2012
13. - Repeatable solutions to common design problems
- Standardized names
- Essential for framework and library sustainability
- Rules can be bent
- The result of good initial design or necessary refactoring
- Will change the way you think about programming
Monday, August 13, 2012
14. - Repeatable solutions to common design problems
- Standardized names
- Essential for framework and library sustainability
- Rules can be bent
- The result of good initial design or necessary refactoring
- Will change the way you think about programming
- Will lead the people to the promised land
Monday, August 13, 2012
16. Classical Patterns
- First real work done in the 1980s
Monday, August 13, 2012
17. Classical Patterns
- First real work done in the 1980s
- GOF released in 1994 (“Design Patterns, Elements of
Reusable Object Oriented Software”)
Monday, August 13, 2012
18. Classical Patterns
- First real work done in the 1980s
- GOF released in 1994 (“Design Patterns, Elements of
Reusable Object Oriented Software”)
- Much writing and evolution since
Monday, August 13, 2012
19. Classical Patterns
- First real work done in the 1980s
- GOF released in 1994 (“Design Patterns, Elements of
Reusable Object Oriented Software”)
- Much writing and evolution since
- Important, but not sacred
Monday, August 13, 2012
22. Quick Overview
- Creational patterns deal with how objects are created
Monday, August 13, 2012
23. Quick Overview
- Creational patterns deal with how objects are created
- Structural patterns deal with how objects are composed
Monday, August 13, 2012
24. Quick Overview
- Creational patterns deal with how objects are created
- Structural patterns deal with how objects are composed
- Behavior patterns deal with how objects are utilized
Monday, August 13, 2012
26. abstract class AbstractFactory()
{
protected function shared(){...//shared}
abstract public function doSomething(){}
}
class ConcreteFactory extends AbstractFactory(){
public function doSomething(){..//unique}
}
$factory = new ConcreteFactory();
Monday, August 13, 2012
27. 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’));
Monday, August 13, 2012
28. 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();
Monday, August 13, 2012
29. 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
30. 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’);
Monday, August 13, 2012
31. 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())
Monday, August 13, 2012
32. 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
Monday, August 13, 2012
34. 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);
Monday, August 13, 2012
35. 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);
Monday, August 13, 2012
36. 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);
Monday, August 13, 2012
37. class Facade
{
public static function simpleMethod(){
$foo = HiddenByFacadeA::foo();
$baz = HiddenByFacadeB::bar($foo);
return HiddenByFacadeB::doh($baz);
}
}
class HiddenByFacadeA{...}
class HiddenByFacadeB{...}
$simple = Facade::simpleMethod();
Monday, August 13, 2012
38. 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();
Monday, August 13, 2012
39. 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
41. 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
42. 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();
Monday, August 13, 2012
43. class Invoker extends Observer {...}
interface Command(){...}
class CommandA implements Command(){...}
$executeLater = Invoker::schedule(
“condition”,
“someMethod”,
new CommandA(array(‘foo’ => ‘bar’))
);
Monday, August 13, 2012
44. 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]”)
Monday, August 13, 2012
45. 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();
}
Monday, August 13, 2012
46. class CareTaker{...}
trait Memento
{
public function recordState(){
CareTaker::recordState(__CLASS__, serialize($this));
}
public function restoreState(){...}
}
class Foo
{
use Memento; ...
}
Monday, August 13, 2012
47. interface Strategy{...}
class ConcreteStrategy implements Strategy {...}
class Context
{
public $strategy = false;
public function __construct($strategy){...}
public function applyStrategy(){...}
}
$context = new Context( new ConcreteStrategy() );
Monday, August 13, 2012
48. abstract class AbstractTemplate
{
...//shared implementation, enforced methods
}
class ConcreteTemplateA extends AbstractTemplate
{
..//concrete (custom) implementation
}
$template = new ConcreteTemplateA( );
Monday, August 13, 2012
50. Patterns on the Web
- Once upon a time, nobody was thinking about software
design patterns in web apps
Monday, August 13, 2012
51. Patterns on the Web
- Once upon a time, nobody was thinking about software
design patterns in web apps
- Desktop and mobile computing now often dependent
on remote (web) services
Monday, August 13, 2012
52. Patterns on the Web
- Once upon a time, nobody was thinking about software
design patterns in web apps
- Desktop and mobile computing now often dependent
on remote (web) services
- Now web apps / server apps can be wayyy complicated
Monday, August 13, 2012
53. Patterns on the Web
- Once upon a time, nobody was thinking about software
design patterns in web apps
- Desktop and mobile computing now often dependent
on remote (web) services
- Now web apps / server apps can be wayyy complicated
- Patterns help us apply systematic rigor to the complexity
Monday, August 13, 2012
55. class Blog extends CI_Controller
{
public function __construct(){...}
public function index(){
...
$this->load->view(‘blog/index’);
}
}
class BlogModel extends CI_Model
{
public function __construct(){...}
public function posts(){...}
}
Monday, August 13, 2012
57. class CI_Controller {
private static $instance;
public function __construct(){...}
public static function &get_instance(){...}
}
function &get_instance()
{
return CI_Controller::get_instance();
}
Monday, August 13, 2012
58. 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’);
}...
}
Monday, August 13, 2012
59. //registry
function &is_loaded($class = '')
{
static $_is_loaded = array();
if ($class !== '')
{
$_is_loaded[strtolower($class)] = $class;
}
return $_is_loaded;
}
Monday, August 13, 2012
60. 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];
}
Monday, August 13, 2012
61. //Index.php (FrontController)
// Load CI core files
// Set some constants
// Pass on the request
Monday, August 13, 2012
62. 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);
Monday, August 13, 2012
63. 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
Monday, August 13, 2012
64. 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
Monday, August 13, 2012
65. Me
@calvinfroedge
http://www.calvinfroedge.com
github.com/calvinfroedge
Monday, August 13, 2012