Programmation STUPID vs SOLID

PROGRAMMATION STUPID VS SOLID

QUI SUIS-JE ?

Arnaud Langlade / @_aRn0D

Développeur Symfony chez Clever Age

Sylius core team member / @Sylius

www.clever-age.com / @CleverAge

STUPID, KÉZAKO ?SingletonTight couplingUntestabilityPremature OptimizationIndescriptive NamingDuplication

INSTANCES UNIQUES (SINGLETON)

class MyClass public function __contruct() $this>connexion = Connexion::getInstance([ 'dsn' => 'mysql:host=localhost;dbname=my_db' ])

Un singleton ne facilite pas la configuration des objetsLes singletons introduisent des couplages forts entre les objetsPas vue globale sur l'application (les dépendences sont cachées)

COUPLAGE FORT (TIGHT COUPLING)

class MyClass public function __construct() $this>connexion = new MyConnexion();

class MyClass public function __construct(Connexion $connexion) $this>connexion = $connexion;

Difficulté dans la mise en place des testsImpossible de créer des mocksDépendence forte entre composants

NON TESTABILITÉ (UNTESTABILITY)

Eviter les bogues et les régressionsFaciliter la refactorisationAttention: Un code fortement couplé sera difficilementtestable

OPTIMISATIONS PRÉMATURÉES (PREMATURE OPTIMIZATION)

De simples applications peuvent se transformer en usine à gazRend difficile :

la lecture et compréhension du codela maintenance de votre application

NOMMAGE INDÉCHIFFRABLE (INDESCRIPTIVE NAMING)

class Quadrilateral public function getOutline($a, $b) return ($a + $b) * 2;

class Quadrilateral public function getPerimeter($with, $height) return ($with + $height) * 2;

Gain de temps lors de : la relecture, la maintenance et l’évolutionEviter les abréviations ou d'acronymes est fortement conseillé

DUPLICATIONS (DUPLICATION)

Une modification de code entraîne :

la répercuter le changement à plusieurs endroitsla maintenance de l'application plus difficile

Des outils automatisent la détection des duplications

PHP Copy Paste Detector (PHPC)SonarSource

SOLID, KÉZAKO ?Michael Feathers et Robert C. Martin (aka Uncle Bob)

Single Responsibility PrincipleOpen/Closed PrincipleLiskov Substitution PrincipleInterface Segregation PrincipleDependency Inversion Principle

PRINCIPE DE RESPONSABILITÉ UNIQUE (SINGLE RESPONSIBILITY PRINCIPLE)

Une classe doit remplir un rôle précis


class DataImporter public function import($file) $this>writeData( $this>loadFile($file) );

private function loadData($file) ... private function writeData(array $data) ...


class DataImporter public function __construct(Loader $loader, Writer $writer) $this>loader = $loader; $this>writer = $writer;

public function import($file) foreach($this>loader>load($file) as $item) $this>writer>write();


La classe est facilement testableFacilite l’évolution des implémentations existantesFacilite l'ajouter de nouvelles implémentations

PRINCIPE OUVERT / FERMÉ (OPEN/CLOSED PRINCIPLE)

Ce principe consiste à rendre les modules ouverts à l'extension et fermés auxmodifications


$importer = DataImporter(new CsvLoader(), new MysqlWriter());$importer = DataImporter(new XMLLoader(), new MongoWriter());


class UserControler public function createUser() // Event pre_create

// Enregistrement de l'utilisateur

// Event post_create

PRINCIPE DE SUBSTITUTION DE LISKOV (LISKOV SUBSTITUTION PRINCIPLE)

Si la classe T a une dépendance de type S alors on doit pouvoir remplacercette dépendance par tous types dérivés de S.

Formulé par Barbara Liskov et Jeannette Wing


class CsvLoader implements LoaderInterface public function load(File $file) // ...

class XmlLoader implements LoaderInterface public function load(File $file) // ...

class DataImporter public function load(LoaderInterface $loader, /* ... */) // ...


Implique de conserver de la classe parente (surtout en PHP) :

les mêmes signatures des méthodesla nature des valeurs de retour des méthodes

Diminution du couplage.

PRINCIPE DE SÉGRÉGATION D'INTERFACES (INTERFACE SEGREGATION PRINCIPLE)

Principe de responsabilité unique pour les interfaces

PRINCIPE D'INVERSION DE DÉPENDANCE (DEPENDENCY INVERSION PRINCIPLE)

Il faut dépendre des abstractions, pas des implémentations

PRINCIPE D'INJECTION/INVERSION DE DÉPENDANCE (DEPENDENCY INVERSION PRINCIPLE)

class DataImporter public function __construct() $this>loader = new CsvLoader(); $this>writer = new MysqlWriter();

class DataImporter public function __construct(CsvLoader $loader, MysqlGateway $writer) $this>loader = $loader; $this>writer = $writer;

PRINCIPE D'INVERSION DE DÉPENDANCE (DEPENDENCY INVERSION PRINCIPLE)

class DataImporter public function __construct(LoaderInterface $loader, WriterInterface $writer) $this>loader = $loader; $this>writer = $writer;

PRINCIPE D'INJECTION DE DÉPENDANCE (DEPENDENCY INVERSION PRINCIPLE)

Une nette diminution du couplageUne meilleure encapsulation

MERCI! QUESTIONS ?

Arnaud Langlade

Twiter @_aRn0D

Sylius : www.sylius.org

Internet

Programmation STUPID vs SOLID