Juan Manuel Torres

@onema

Rober C. Martin

Barbara Liskov

Gang of Four

Bertrand Meyer

S

O

R

P

A class or module should have one, and only one, reason to change... Classes should have one responsibility—one reason to change. [4]

L

D

Single Responsibility Principle

High Level Architecture

I

While SPR is one of the simplest OO design principles, it is one of the most abused.

S

O

R

P

L

D

High Level Architecture

I

Why do we want to use SRP?

Easier to understand and update. Multipurpose classes prevents us from clearly understanding the original intention of the code.

S

O

R

P

L

D

High Level Architecture

I

Why do we want to use SRP?

Better system design. Collaboration with other small classes to achieve system behavior is better than doing it all in one or few classes.

S

O

R

P

L

D

High Level Architecture

I

Example 1

interface Modem
{
    public function dial(Phone $phone); 
    public function hangup();
    public function send(Message $msg); 
    public function receive();
}

Single or multiple responsibilities?

S

O

R

P

L

D

High Level Architecture

I

class Version 
{
    public function getMajorVersionNumber() {...} 
    public function getMinorVersionNumber() {...}
    public function getPatchVersionNumber() {...}
    public function getBuildNumber() {...}
}

Single or multiple responsibilities?

S

O

R

P

L

D

High Level Architecture

I

Example 2

O

Open Close Principle

L

Classes, modules, functions should be open for extension and close for modification.

C

P

D

S

Design & Extension

I

class Car {
    public function getType() {
        return 'car';
    }
}

O

L

C

P

D

S

Design & Extension

class Plane {
    public function getType() {
        return 'plane';
    }
}

Violation Example #1 

I

interface Vehicle {
    // ...
    public function getType();
    public function operateVehicle();
}

O

C

P

S

Design & Extension

L

I

D

$pilot = new Pilot();
$car = new Car();
$pilot->operate($car);

$plane = new Plane();
$pilot->operate($plane);

Pilot can conduct any type of vehicle without having to modify the pilot code.

O

C

P

S

Design & Extension

class Pilot {
    // ...
    public function operate(Vehicle $vehicle) {
        $vehicle->operateVehicle();
    }
}

L

I

D

L

Liskov Substitution Principle

S

If for each object o1  of type S there is an object o2  of type T such that for all programs P   defined in terms of T, the behavior of P is unchanged when o1  is substituted for o2,  then S is a subtype of T. [9]

S

P

O

D

Correctness

I

L

S

D

S

P

O

Correctness

I

L

S

S

P

O

D

Violation Example #1 

interface Bird {
    public function birdSound();
    public function fly();
}

Correctness

I

L

S

S

P

O

D

Violation Example #2

class Ostrich implements Bird {
    // ...
    public function fly($jetPack) {
        echo "Attach jetpack to Ostrich and FLY!";
    }
    // ...
}

Correctness

I

L

S

S

P

O

D

So what is the point?

Correctness

I

I

S

L

S

P

O

D

Interface Segregation Principle

Thin interfaces

I

S

L

S

P

O

D

This principle deals with disadvantages of fat interfaces

Thin interfaces

I

S

L

S

P

O

D

interface CDRadio {
    public function stopRadio();
    public function ejectCD();
}

interface SpeedControl {
    public function accelerate();
    public function brake();
    public function changeGear($gear);
    public function startEngine();
}

Thin interfaces

D

S

L

I

P

O

I

Dependency Inversion Principle

A. High level modules should not depend upon low level modules. Both should depend upon abstractions. [18]

Level of Abstraction

D

S

L

I

P

O

I

Level of Abstraction

Dependency Inversion Principle VS Dependency Injection

D

S

L

I

P

O

I

Level of Abstraction

class Car implements Vehicle {
    public function operateVehicle() {
        $speedControl = new CarSpeedControl();
        $speedControl->startEngine();
        $speedControl->accelerate();
        // ...
    }
}

D

S

L

I

P

O

I

Level of Abstraction

CarSpeedControl

Depends on

Car

D

S

L

I

P

O

I

Level of Abstraction

class Car implements Vehicle {
    public function __construct(SpeedControl $speedControl) {
        $this->speedControl = $speedControl;
    }    
    public function operateVehicle() {
        $this->speedControl->startEngine();
        $this->speedControl->accelerate();
        // ...
    }
}

$myCar = new Car(new CarSpeedControl());
$turboCar = new Car(new TurboSpeedControl());

S

L

O

I

EXAMPLE

D

use League\Flysystem\Filesystem;
use League\Flysystem\Adapter\Local;

$filesystem = new Filesystem(new Local(__DIR__.'/path/to/root'));

// Write Files
$filesystem->write('path/to/file.txt', 'contents');

// Update Files
$filesystem->update('path/to/file.txt', 'new contents');

// Write or Update Files
$filesystem->put('path/to/file.txt', 'contents');

// Read Files
$contents = $filesystem->read('path/to/file.txt');

// Check if a file exists
$exists = $filesystem->has('path/to/file.txt');

League\Flysystem

S

L

O

I

EXAMPLES

D

Is the

S.O.L.I.D.?

• Single Responsibility: Arguable, classes implement read and write methods... 
• Open Closed: Yes! it follows a strategy pattern where each adapter is neatly encapsulated in a class.
• Liskov substitution: Classes implement an interface, (even the main file system class).
• Interface Segregation: Arguable, see SRP
• Dependency Inversion: Yes! File system depends on the Adapter Interface, hence we can use different adapters. 

League\Flysystem