Embracing change at BrnoPHP

Slide 1

Slide 1 text

EMBRACING CHANGE Jakub Zalas 14.11.2015 @jakub_zalas @jakzal

Slide 2

Slide 2 text

CHANGE DAMAGE Change?, SomeDriftwood, https://www.ﬂickr.com/photos/arthurjohnpicton/4383221264/

Slide 3

Slide 3 text

AGILE MANIFESTO Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.

Slide 4

Slide 4 text

We live in a world of changing requirements, and our job is to make sure that our software can survive those changes. If the design of our software degrades because the requirements have changed, we are not being agile.

Slide 5

Slide 5 text

No content

Slide 6

Slide 6 text

No content

Slide 7

Slide 7 text

KNOWLEDGE TIME

Slide 8

Slide 8 text

You have to ﬁnish things - that's what you learn from, you learn by ﬁnishing things. Neil Gaiman

Slide 9

Slide 9 text

HOW DOES CODE ROT? Rotten pumpkin, Andy Hay, https://www.ﬂickr.com/photos/andyhay/8196333166/

Slide 10

Slide 10 text

use Buzz\Browser; class LinkCrawler { private $browser; private $linkExtractor; private $linkRepository; public function __construct( Browser $browser, LinkExtractor $linkExtractor, LinkRepository $linkRepository ) { $this->browser = $browser; $this->linkExtractor = $linkExtractor; $this->linkRepository = $linkRepository; } // ... }

Slide 11

Slide 11 text

class LinkCrawler { // ... public function crawl($url) { $content = $this->browser->get( $url, ['content-type' => 'application/json'] ); $links = $this->linkExtractor->extract($content); $this->linkRepository->store($links); } }

Slide 12

Slide 12 text

New requirements: Load a ﬁle from the local ﬁlesystem if a local path was passed as an URL class LinkCrawler { // ... public function crawl($url) { $content = $this->browser->get( $url, ['content-type' => 'application/json'] ); $links = $this->linkExtractor->extract($content); $this->linkRepository->store($links); } }

Slide 13

Slide 13 text

New requirements: Load a ﬁle from the local ﬁlesystem if a local path was passed as an URL class LinkCrawler { public function crawl($url) { if (0 === strpos($url, 'http')) { $content = $this->browser->get( $url, ['content-type' => 'application/json'] ); } else { $content = file_get_contents($url); } $links = $this->linkExtractor->extract($content); $this->linkRepository->store($links); } }

Slide 14

Slide 14 text

New requirements: Log if verbose mode is enabled class LinkCrawler { public function crawl($url) { if ($this->verbose) { $this->logger(sprintf('Crawling "%s".', $url)); } if (0 === strpos($url, 'http')) { $content = $this->browser->get( $url, ['content-type' => 'application/json'] ); } else { $content = file_get_contents($url); } $links = $this->linkExtractor->extract($content); $this->linkRepository->store($links); } }

Slide 15

Slide 15 text

New requirements: Publish links to elastic search class LinkCrawler { public function crawl($url) { if ($this->verbose) { $this->logger(sprintf('Crawling "%s".', $url)); } if (0 === strpos($url, 'http')) { $content = $this->browser->get( $url, ['content-type' => 'application/json'] ); } else { $content = file_get_contents($url); } $links = $this->linkExtractor->extract($content); $this->linkRepository->store($links); $this->elasticSearch->publish($links); } }

Slide 16

Slide 16 text

Code rots when we don’t revise the design.

Slide 17

Slide 17 text

HOW TO DIAGNOSE PROBLEMS? Littmann Stethoscope, Mediative UK, https://www.ﬂickr.com/photos/107621760@N03/10668574215/

Slide 18

Slide 18 text

DESIGN SMELLS ✤ Rigidity ✤ Fragility ✤ Immobility ✤ Viscosity ✤ Needless complexity ✤ Needless repetition ✤ Opacity how pumpkins rot, Evil Erin, https://www.ﬂickr.com/photos/evilerin/4158920495/

Slide 19

Slide 19 text

SOLID PRINCIPLES ✤ Single Responsibility Principle ✤ Open/Closed Principle ✤ Liskov Substitution Principle ✤ Interface Segregation Principle ✤ Dependency Inversion Principle factory, Dean Hochman, https://www.ﬂickr.com/photos/deanhochman/16685305845/

Slide 20

Slide 20 text

PACKAGE DESIGN PRINCIPLES ✤ Reuse-release equivalence principle ✤ Common-reuse principle ✤ Common-closure principle ✤ Acyclic dependencies principle ✤ Stable-dependencies principle ✤ Stable-abstractions principle Packaging variations, Chris Carter, https://www.ﬂickr.com/photos/chris_carter_/4111436287/

Slide 21

Slide 21 text

COUPLING & COHESION

Slide 22

Slide 22 text

COHESION Cohesion describes how closely are elements in a module related. Pﬂaster/Pavement, Sivi Steys, https://www.ﬂickr.com/photos/38365223@N03/7913024500/

Slide 23

Slide 23 text

COUPLING Modules are coupled if changing one of them requires changing another one. Martin Fowler In Chains, Christian Weidinger, https://www.ﬂickr.com/photos/ch-weidinger/14756953490/ http://martinfowler.com/ieeeSoftware/coupling.pdf

Slide 24

Slide 24 text

COUPLING THROUGH A PROPERTY use Buzz\Browser; class Crawler { /** * @var Browser */ private $browser; }

Slide 25

Slide 25 text

COUPLING THROUGH A METHOD CALL class Crawler { private $c; public function crawl($url) { $this->c->getBrowser()->get($url); } }

Slide 26

Slide 26 text

COUPLING THROUGH A REFERENCE use Buzz\Browser; class Crawler { public function crawl($url, Browser $b) { $response = $b->get($url); } }

Slide 27

Slide 27 text

COUPLING THROUGH A REFERENCE use Buzz\Browser; class Crawler { /** * @return Browser */ public function crawl($url) { // ... return $browser; } }

Slide 28

Slide 28 text

COUPLING THROUGH AN IMPLEMENTATION / EXTENSION use Buzz\Browser; class Crawler extends Browser { public function crawl($url) { $this->get($url); } }

Slide 29

Slide 29 text

No content

Slide 30

Slide 30 text

HOW TO COPE WITH CHANGE? Swiss Army Knife, Basheer Tome, https://www.ﬂickr.com/photos/basheertome/3086908057/

Slide 31

Slide 31 text

Slide 32

Slide 32 text

OPEN/CLOSED PRINCIPLE Software modules should be open for extension but closed for modiﬁcation.

Slide 33

Slide 33 text

Slide 34

Slide 34 text

class LinkCrawler { private $contentProvider; private $linkExtractor; private $linkRepository; public function __construct( ContentProvider $contentProvider, LinkExtractor $linkExtractor, LinkRepository $linkRepository ) { $this->contentProvider = $contentProvider; $this->linkExtractor = $linkExtractor; $this->linkRepository = $linkRepository; } } New requirements: Load a ﬁle from the local ﬁlesystem if a local path was passed as an URL

Slide 35

Slide 35 text

class LinkCrawler { // ... public function crawl($url) { $content = $this->contentProvider->load($url); $links = $this->linkExtractor->extract($content); $this->linkRepository->store($links); } } New requirements: Load a ﬁle from the local ﬁlesystem if a local path was passed as an URL

Slide 36

Slide 36 text

New requirements: Load a ﬁle from the local ﬁlesystem if a local path was passed as an URL interface ContentProvider { /** * @param string $url * * @return string */ public function load($url); }

Slide 37

Slide 37 text

New requirements: Load a ﬁle from the local ﬁlesystem if a local path was passed as an URL class BuzzContentProvider implements ContentProvider { public function __construct(Browser $browser) { $this->browser = $browser; } public function load($url) { return $this->browser->get( $url, ['content-type' => 'application/json'] ); } }

Slide 38

Slide 38 text

New requirements: Load a ﬁle from the local ﬁlesystem if a local path was passed as an URL class FileContentProvider implements ContentProvider { public function load($url) { return file_get_contents($url); } }

Slide 39

Slide 39 text

Software modules should be open for extension but closed for modiﬁcation.

Slide 40

Slide 40 text

No content

Slide 41

Slide 41 text

WHAT HAPPENED? 1.We noticed a problem in the design 2. We diagnosed the problem by applying solid principles 3. We ﬁxed the design by applying a design pattern 4. We added a new feature easily

Slide 42

Slide 42 text

Slide 43

Slide 43 text

No content

Slide 44

Slide 44 text

DEPENDENCY INVERSION PRINCIPLE High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend upon details. Details should depend upon abstractions.

Slide 45

Slide 45 text

DEPENDENCY INVERSION PRINCIPLE High-level modules should not depend on low-level modules. Low-level High-level

Slide 46

Slide 46 text

DEPENDENCY INVERSION PRINCIPLE High-level modules should not depend on low-level modules. Both should depend on abstractions An abstraction!

Slide 47

Slide 47 text

DEPENDENCY INVERSION PRINCIPLE Both should depend on abstractions

Slide 48

Slide 48 text

DEPENDENCY INVERSION PRINCIPLE Abstractions should not depend upon details. A detail!

Slide 49

Slide 49 text

DEPENDENCY INVERSION PRINCIPLE Abstractions should not depend upon details. Details should depend upon abstractions.

Slide 50

Slide 50 text

Slide 51

Slide 51 text

class LinkCrawler { // ... public function crawl($url) { $content = $this->contentProvider->load($url); $links = $this->linkExtractor->extract($content); $this->linkRepository->store($links); } } New requirements: Add two more crawlers to extract images and meta attributes

Slide 52

Slide 52 text

interface ContentProvider { /** * @param string $url * * @return string */ public function load($url); }

Slide 53

Slide 53 text

class BuzzContentProvider implements ContentProvider { public function __construct(Browser $browser) { $this->browser = $browser; } public function load($url) { return $this->browser->get( $url, ['content-type' => 'application/json'] ); } }

Slide 54

Slide 54 text

No content

Slide 55

Slide 55 text

No content

Slide 56

Slide 56 text

use Guzzle\Client; class GuzzleContentProvider implements ContentProvider { private $guzzle; public function __construct(Client $guzzle) { $this->guzzle = $guzzle; } public function load($url) { $request = $this->guzzle->createRequest( 'GET', $url ); $response = $request->send(); return $response->getBody(); } }

Slide 57

Slide 57 text

WHAT HAPPENED? 1.We noticed a problem in the design 2. We diagnosed the problem by applying solid principles 3. We ﬁxed the design by applying a design pattern 4. We added a new feature easily

Slide 58

Slide 58 text

FRAMEWORKS Professional Framework, ronramstew, https://www.ﬂickr.com/photos/54996985@N00/5439941604/

Slide 59

Slide 59 text

class ProductController extends Controller { public function searchAction(Request $request) { $products = $this->get('doctrine') ->getRepository('Acme:Product'); ->search($request->query->get(‘keywords’); return $this->render( 'product/search.html.twig', ['products' => $products] ); } } Count dependencies

Slide 60

Slide 60 text

No content

Slide 61

Slide 61 text

interface ProductRepository { /** * @return Product[] */ public function search($keywords); }

Slide 62

Slide 62 text

class DoctrineProductRepository implements ProductRepository { private $em; public function __construct(EntityManager $em) { $this->em = $em; } /** * @return Product[] */ public function search($keywords) { return $this->em->createQueryBuilder() ->select('p') ->from(Product::class, 'p') ->where('p.title LIKE :keywords') ->setParameter('keywords', '%'.$keywords.'%') ->getQuery() ->getResult(); } }

Slide 63

Slide 63 text

class ProductController { private $productRepository; private $templating; public function __construct( ProductRepository $productRepository, EngineInterface $templating ) { $this->productRepository = $productRepository; $this->templating = $templating; } // ... }

Slide 64

Slide 64 text

class ProductController { // ... public function searchAction($keywords) { $products = $this->productRepository->search($keywords); return $this->templating->renderResponse( 'product/search.html.twig', ['products' => $products] ); } }

Slide 65

Slide 65 text

No content

Slide 66

Slide 66 text

No content

Slide 67

Slide 67 text

No content

Slide 68

Slide 68 text

LAYERED ARCHITECTURE

Slide 69

Slide 69 text

No content

Slide 70

Slide 70 text

HEXAGONAL ARCHITECTURE Application Data User-side Doctrine In memory UI Tests CLI

Slide 71

Slide 71 text

PACKAGE DESIGN Design Blog Sociale, SOCIALisBETTER, https://www.ﬂickr.com/photos/27620885@N02/2602771507/

Slide 72

Slide 72 text

THE REUSE/RELEASE EQUIVALENCE PRINCIPLE The granule of reuse is the granule of release.

Slide 73

Slide 73 text

THE COMMON REUSE PRINCIPLE The classes in a component are reused together. If you reuse one of the classes in a component, you reuse them all.

Slide 74

Slide 74 text

THE COMMON CLOSURE PRINCIPLE The classes in a component should be closed together against the same kinds of changes. A change that affects a component affects all the classes in that component and no other components.

Slide 75

Slide 75 text

THE ACYCLIC DEPENDENCIES PRINCIPLE Allow no cycles in the component dependency graph.

Slide 76

Slide 76 text

THE STABLE DEPENDENCIES PRINCIPLE Depend in the direction of stability.

Slide 77

Slide 77 text

THE STABLE ABSTRACTIONS PRINCIPLE A component should be as abstract as it is stable.

Slide 78

Slide 78 text

SUMMARY 1. Start simple 2. Don’t feel committed to the decisions made in the past. 3. Revise the design each time you make a change 4. Don’t complicate. Make your design change-proof only where it’s needed. 5. Constantly improve the design. No sprints for refactoring!

Slide 79

Slide 79 text

DEFER COMMITMENT!

Slide 80

Slide 80 text

Good code doesn't take more time to write. What takes a lot of time is the learning how to write good code.

Slide 81

Slide 81 text

@jakub_zalas @jakzal Thank you! Rate this talk! https://joind.in/16266