PHP For Grown Ups

My first User Group talk filled to the brim with tips on writing maintainable, reliable and (re)usable PHP applications.

Transcript

1. PHP FOR GROWN-UPS
2. WHY TALK ABOUT THIS?
3. PHP HAS A BAD RAP... (WHICH IT PARTLY DESERVES)
4. BUT YOU CAN USE IT TO BUILD PRETTY SOLID STUFF (IF YOU KNOW HOW)
5. SO LET’S TALK ABOUT THE HOW
6. (BUT FIRST, A COUPLE SMALL DISCLAIMERS...)
7. NONE OF THESE IDEAS ARE NEW (IN FACT, MOST ARE PRETTY OLD)
8. ALL OF THIS CAN BE FOUND IN BOOKS (NONE OF WHICH SPECIFIC TO PHP)
9. GOOD CODE
10. MAINTAINABLE RELIABLE (RE)USABLE
11. MAINTAINABLE CODE (ALMOST) ALL CODE CAN AND WILL CHANGE
12. UNDERSTANDABLE DECOUPLED CONSISTENTLY ABSTRACTED
13. “The ratio of time spent reading code versus writing is well over 10 to 1” -- Uncle Bob
14. NAMING (CLASSES AND VARIABLES)
15. DESCRIPTIVE AND EXPRESSIVE
16. $light->setStatus(true);
17. $light->turnOn();
18. NAMESPACES
19. EXTRACT METHOD // before: if (is_numeric($amount) && $amount > 0) // after: if ($this->isValidAmount($amount))
20. private function isValidAmount($amount) { return is_numeric($amount) && $amount > 0; }
21. NAMES WILL SOMETIMES LIE TO YOU
22. // neither of these is actually a locale $this->locale = $locale->locale;
23. COMMENT ALL THE THINGS (WELL, NOT ALL THE THINGS...)
24. CODE SAYS WHAT COMMENTS SAY WHY
25. // set the patient’s clinic $patient->setClinic($clinic); // ORLY?
26. // to register a patient, set the patient’s clinic $patient->setClinic($clinic);
27. GOOD NAMING AND GOOD ABSTRACTIONS BEAT GOOD COMMENTS
28. $clinic->registerPatient($patient);
29. PRINCIPLE OF LEAST ASTONISHMENT (MINIMIZE THE NUMBER OF WTFS PER MINUTE)
30. PHPDOC ALL THE THINGS CLASSES, VARIABLES, METHODS, ARGUMENTS
31. /** * If what this method does can not be made obvious from * its name, explain it here. * * @param string $firstname * @return void */ public function changeFirstName($firstName) { // code }
32. WHY BOTHER IF PHP DOES NOT ENFORCE THIS? COMMUNICATES INTENT WORKS GREAT WITH IDES
33. “Shy code - modules that don’t reveal anything unnecessary to other modules and that don’t rely on other modules’ implementations” - The Pragmatic Programmer
34. WHY DECOUPLING? ISOLATES CHANGES MAKES YOUR CODE MORE FLEXIBLE ENCOURAGES ABSTRACTION
35. ”Modules that don’t reveal anything unnecessary to other modules” ENCAPSULATION
36. $totalPrice = 0; foreach ($order->getItems() as $item) { /** @var OrderItem $item */ $amount = $item->getAmount(); $price = $item->getPrice(); $totalPrice += $amount * $price; } $totalPrice += $order->getShippingCosts();
37. $totalPrice = $order->getTotalPrice();
38. ”Tell, don’t ask”
39. $discountedItems = array(); foreach ($order->getItems() as $item) { /** @var OrderItem $item */ $oldPrice = $item->getPrice(); $newPrice = $oldPrice - ($oldPrice * ($discountPercentage / 100)) $item->setPrice($discountPercentage); $discountedItems[] = $item; } $order->setItems($items);
40. $order->applyDiscount($discountPercentage);
41. “[...] modules that don’t rely on other modules’ implementations”
42. FLAVORS OF COUPLING INTERNAL DEPENDENCIES EXTERNAL PACKAGES DATABASES/ORMS FRAMEWORKS
43. EVEN PROGRAMMING LANGUAGES
44. DEPENDENCY INJECTION
45. Before: class EmployeeService { /** * @param integer $employeeId * @return void */ public function delete($id) { $employeeStore = new EmployeeStore(); $employeeStore->deleteById($id); } }
46. After: class EmployeeService { /* * @var EmployeeStore */ private $employeeStore /** * @param mixed $employeeStore * @return void */ public function __construct($employeeStore) { $this->employeeStore = $employeeStore; } // rest of class here... }
47. /** * @param integer $id * @return void */ public function deleteById($id) { $this->employeeStore->deleteById($id); }
48. public function __construct($employeeStore)
49. public function __construct(EmployeeStore $employeeStore)
50. interface EmployeeStoreInterface { /** * @param integer $id */ public function deleteById($id); }
51. class PdoEmployeeStore implements EmployeeStoreInterface { /** * @param integer $id */ public function deleteById($id) { // PDO implementation here } }
52. public function __construct(EmployeeStoreInterface $employeeStore)
53. TREAT INTERFACES AS THE REAL THING
54. “That seems like an hell of a lot of work...”
55. DI CONTAINER ”IF I AM ASKING FOR AN EMPLOYEESTORE, GIVE ME AN INSTANCE OF THIS CLASS”
56. SYMFONY DEPENDENCYINJECTION LARAVEL IOC CONTAINER ORNO DI PIMPLE
57. “Mathematics is the art of giving the same name to different things.” ― Henri Poincaré
58. /** * @param string $searchTerm * @param string $productCategory * @param string $make * @param string $color */ public function search($searchTerm, $productCategory, $make, $color) { switch ($productType) { // search products } }
59. /** * @param SearchTerm $searchTerm * @param ProductCategory $productCategory * @param Make $make * @param Color $color */ public function search( SearchTerm $searchTerm, ProductCategory $productCategory, Make $make, Color $color ) { switch($productType->getTypeId()) // search products ) }
60. VALUE OBJECTS class SearchTerm { const MAX_TERM_LENGTH = 30; /** * @var string */ private $searchTerm; /** * @param string $term * @throws InvalidTermException */ public function __construct($term) { if (strlen($term) >= self::MAX_TERM_LENGTH) { throw new InvalidTermException($term); } } }
61. ”But isn’t this coupling?”
62. “Figuring out if two people are married is easy. Figuring out if they should be is hard.” - Michael Feathers
63. /** * @param SearchQuery $query * @return SearchResults */ public function search(SearchQuery $query) { /** @var SearchWorker $worker */ $worker = $this->getWorkerForQuery($query); /** @var SearchResults $results */ $results = $worker->process($query); return $results; }
64. ABSTRACTION TOOL NAMESPACES
65. ABSTRACTION LEVELS
66. LOW LEVEL OF ABSTRACTION $statement = $database->prepare( “INSERT INTO `fish`(‘name’, ‘species’, ‘gender’, ‘tankId’) VALUES(?, ?, ?, ?)” ); $statement->execute(array(‘Nemo’, $speciesId, ‘M’, $tankId));
67. HIGH LEVEL OF ABSTRACTION $command = new IntroduceFishCommand($fish, $tank); $this->commandBus->execute($command);
68. LAYERED ARCHITECTURE
69. HTTP LAYER FRAMEWORK LAYER SERVICE LAYER DOMAIN LAYER PRESENTATION LAYER
70. ”You gotta keep ‘em separated”
71. RELIABLE CODE ”YOU ARE NOT PHPREPARED”
72. KEEP IT UNDERSTANDABLE CODE DEFENSIVELY KEEP IT TESTABLE USE YOUR LANGUAGE FEATURES
73. In order to prevent defects in code, you first need to understand it
74. ”Rely only on reliable things” - The Pragmatic Programmer
75. Not a reliable thing THE PHP TYPE SYSTEM
76. if (! $amount) { // do something } // $amount can actually be 0, “0”, “”, null or false for this to be true
77. if ($amount == 0) { // do something } // you would think that explicitly checking for 0 would improve things...
78. Computer says no...
79. if ($amount === 0) { // do something } // this will only evaluate as true when $amount is actually the number 0
80. CRANK YOUR ERROR REPORTING UP KNOW WHY YOUR CODE WORKS BE AWARE OF FAILURE SCENARIOS CATCH AND THROW EXCEPTIONS
81. ”Test your software, or your users will” - The Pragmatic Programmer
82. TEST-DRIVEN DEVELOPMENT
83. PHPUNIT PHPSPEC CODECEPTION BEHAT
84. TDD IS NOT JUST UNIT TESTING
85. ACCEPTANCE FUNCTIONAL INTEGRATION UNIT
86. MORE CONFIDENCE BETTER DESIGN FEWER DEFECTS REGRESSION CATCHING TESTS AS DOCUMENTATION
87. TYPEHINTING VISIBILITY (PRIVATE BY DEFAULT) INTERFACES EXCEPTIONS ISSET, IS_NUMERIC, ETC.
88. USE PHPDOC WITH A GOOD IDE
89. DECOUPLED CODE GOOD ABSTRACTIONS NAMESPACES COMPOSER AUTOLOADING/IDES
90. COMPOSER OPEN SOURCE PRIVATE REPOSITORIES IN COMPOSER.JSON TORAN PROXY
91. // FILE: composer.json { "name": "behat/behat", "description": "Scenario-oriented BDD framework for PHP 5.3", “require”: {} }
92. // FILE: composer.json { "repositories": [ { "type": "vcs", "url": "http://github.com/user/repo" }, ], “require”: { “user/package”: “*” } }
93. AUTOLOADING NO MORE REQUIRE/INCLUDE JUST USE THE CLASS (OPTIONAL) USE STATEMENT
94. SOLID PRINCIPLES
95. SINGLE RESPONSIBILITY PRINCIPLE OPEN-CLOSED PRINCIPLE LISKOV SUBSTITUTION PRINCIPLE INTERFACE SEGREGATION PRINCIPLE DEPENDENCY INVERSION PRINCIPLE
96. SINGLE RESPONSIBILITY PRINCIPLE ”A class should have one, and only one, reason to change.”
97. ”Every class, or similar structure, should have only one job to do.” - Richard Carr
98. ASK YOURSELF “What responsibilities does this piece of code have?”
99. $user = new User($userName, $password, $firstName, $lastName, $email); $user->save(); // later on... $user->login($userName, $password);
100. CONTAIN LOGIN CREDENTIALS CONTAIN PERSONAL INFORMATION STORE TO DATABASE ACCESS MANAGEMENT
101. USER CLASS CUSTOMER CLASS USERSTORE / CUSTOMERSTORE CLASSES AUTHENTICATIONMANAGER CLASS
102. $userAccount = new UserAccount($userName, $password); $authenticationManager->register($userAccount); $customer = new Customer($firstName, $lastName, $email); $customer->linkUserAccount($userAccount); $customerService->register($customer); $authenticationService->login($userName, $password)
103. OPEN-CLOSED PRINCIPLE “A class should be open for extension, but closed for modification”
104. public function ship(Product $product, $shippingMethod) { switch ($shippingmethod) { case shipping::shipping_default: $this->defaultshipping($product); break; case shipping::shipping_priority: $this->priorityshipping($product); break; } }
105. public function addShippingMethod(ShippingMethodInterface $method, $identifier) { $this->shippingMethods[$identifier] = $method; } public function ship(Product $product, $shippingMethodIdentifier) { $shippingMethod = $this->shippingMethods[$shippingMethodIdentifier]; $shippingMethod->ship($product); }
106. LISKOV SUBSTITUTION PRINCIPE ”Subclasses must be substitutable for their base classes.”
107. “Any implementation of an abstraction (interface) should be substitutable in any place that the abstraction is accepted” - Jeffrey Way
108. interface VehicleInterface { public function driveTo(Destination $destination); }
109. class Boat implements VehicleInterface { public function driveTo(Destination $destination) { // start driving } }
110. class Car implements VehicleInterface { public function driveTo(Destination $destination) { // start driving } public function swapTires(TyreTypeInterface $tyreType) { // swap tyres } }
111. /** @var VehicleInterface $vehicle */ $vehicle->swapTyres($tyreType); // Car: works // Boat: Method ‘swapTires’ not found in class Boat
112. INTERFACE SEGREGATION PRINCIPLE ”Never force classes to implement methods that they do not use”
113. interface VehicleInterface { public function driveTo(Destination $destination); public function swapTires(TyreTypeInterface $tyreType); }
114. class Boat implements VehicleInterface { public function driveTo(Destination $destination) { // start driving } public function swapTires(TyreTypeInterface $tyreType) { throw new BoatHasNoWheelsException(); } }
115. interface VehicleInterface { public function driveTo(Destination $destination); } interface WheeledVehicleInterface { public function swapTires(TyreTypeInterface $tyreType); }
116. class Car implements VehicleInterface, WheeledVehicleInterface
117. class Boat implements VehicleInterface, BoatInterface
118. DEPENDENCY INVERSION PRINCIPE ”Depend on abstractions, not on concretions.”
119. class StoreHouse { private $supplier; public function __construct(FooBarInc $supplier) { $this->supplier = $supplier; } }
120. class StoreHouse { private $supplier; public function __construct(SupplierInterface $supplier) { $this->supplier = $supplier; } }
121. class FooBarIncSupplier implements SupplierInterface { public function order(Product $product) { $orderId = $this->fooBarInc->createProductOrder(); $this->fooBarInc->addProductToOrder($orderId); } }
122. QUESTIONS?
123. READING LIST Patterns of Enterprise Application Architecture - Martin Fowler Clean Code - Robert C. Martin Growing Object-Oriented Software, Guided By Tests (the GOOS book) - Steve Freeman & Nat Pryce The Pragmatic Programmer - Dave Thomas & Andy Hunt
124. VIDEOS Models and Service Layers; Hemoglobin and Hobgoblins - Ross Tuck (https://www.youtube.com/watch?v=3uV3ngl1Z8g) Unbreakable Domain Models - Mathias Verraes (https:// www.youtube.com/watch?v=ZJ63ltuwMaE) The Framework As An Implementation Detail (https:// www.youtube.com/watch?v=0L_9NutiJlc)
125. PODCASTS Elephant in the Room (http://elephantintheroom.io)