Best practices for crafting high quality PHP apps (php[world] 2019)

@asgrim
Please clone & composer install:
https://github.com/asgrim/quality-tutorial
WiFi: php2019 / php2019
Best practices for crafting high quality PHP apps

@asgrim
Best practices for crafting high
quality PHP apps
James Titcumb
php[world] 2019

$ whoami
James Titcumb
www.jamestitcumb.com
www.roave.com
@asgrim

@asgrim

@asgrim
What is “quality”?

@asgrim
photo: Rob Allen https://flic.kr/p/qmGpsq

@asgrim
"The best code is no code at all”
-- Jeff Atwood
source: https://blog.codinghorror.com/the-best-code-is-no-code-at-all/

@asgrim
Prototyping & short-lived apps/sites

@asgrim
Products
Long-lived projects. Open source software.

@asgrim
What is quality in applications?

@asgrim
What about time/cost…?

@asgrim
“A freelancer at $25 an hour for 100 hours still
costs more than a freelancer at $150 an hour that
takes 10 hours to do the same task”
-- Brandon Savage
source: http://www.brandonsavage.net/earning-more-money-as-a-php-freelancer/

@asgrim
This talk...
● Planning
● Development
● Testing
● Continuous integration
● Code reviews
● Deployments

@asgrim
Planning is communication

@asgrim
Use business terminology

@asgrim
Build a model of the business

@asgrim
Event Storming
Practical Exercise

@asgrim
Event Storming - Practical Exercise
● Booking a hotel room
● Customer must select dates
● Rooms must be paid for when booking
● Stripe is the chosen payment provider
● Payment must only be taken once room is reserved
● Room availability is checked & reserved via 3rd party API
● All rooms & dates cost the same (e.g. $100 per night)
● Notify the customer (e.g. email) on a successful reservation
● Customer can cancel a booking
● On cancellation, full refund if more than 48 hours before the stay

@asgrim
The model must be fluid.

@asgrim
Feature Planning
Practical Exercise

@asgrim
Feature Planning
Feature: Booking a room for a hotel
Scenario: Making a successful booking
Given ...
When ...
Then ...
Scenario: Cancelling an existing booking
Given ...
When ...
Then ...
Scenario: If a room is booked by the time payment is made,
do not charge the card or reserve the room
Given ...
When ...
Then ...

@asgrim
“There are only two hard things in Computer
Science: cache invalidation and naming things.”
-- Phil Karlton
source: https://martinfowler.com/bliki/TwoHardThings.html

@asgrim
SimpleBeanFactoryAwareAspectInstanceFactory

@asgrim
“Give awkward names to awkward concepts”
-- Eric Evans
source: https://skillsmatter.com/conferences/8231-ddd-exchange-2017

@asgrim
SOLID Violation Example
interface Thing {
public function doStuff() : void;
}
final class ImplementationOfThing implements Thing {
public function doStuff() : void { ... }
public function moreStuff() : void;
}
class ConsumerOfThing {
/** @var Thing */
private $thing;
public function woo() {
$this->thing->moreStuff();
}
}

@asgrim
Object Calisthenics - Practical
● One level of indentation in a method
● Avoid “else” keyword
● Wrap primitive types (e.g. strings, int)
● First class collections (instead of Thing[])
● One object operator (Law of Demeter)
● Avoid abbreviations (naming!)
● Keep classes small
● Avoid more than 2 instance variables
● No getters/setters

@asgrim
Avoid early abstraction

@asgrim
“Code for your use-case,
not for your re-use-case”
-- Marco Pivetta
source: https://ocramius.github.io/extremely-defensive-php/#/39

@asgrim
A public method is like a child:
once you've written it,
you are going to maintain it
for the rest of its life!
-- Stefan Priebsch

@asgrim
Strict type declarations.
Use declare(strict_types=1); by default

@asgrim
Immutable value objects
declare(strict_types=1);
use AssertAssertion; // beberlei/assert library !
final class PostalCode
{
private const VALIDATION_EXPRESSION = '(GIR 0AA)|((([A-Z-[QVX]][0-9][0-...
/** @var string */
private $value;
public function __construct(string $value) {
$this->assertValidPostalCode($value);
$this->value = $value;
}
private function assertValidPostalCode(string $value) : string {
Assertion::regex($value, self::VALIDATION_EXPRESSION);
}
public function __toString() : string {
return $this->value;
}
}

@asgrim
Value objects are valid!
declare(strict_types=1);
final class Thing {
public function assignPostalCode(PostalCode $postalCode) : void
{
// ... we can trust $postalCode is a valid postal code
}
}
// 12345 is not valid - EXCEPTION!
$myThing->assignPostalCode(new PostalCode('12345'));
// assignPostalCode is happy
$myThing->assignPostalCode(new PostalCode('PO1 1AA'));
// With STRICT types, this will also FAIL
$myThing->assignPostalCode(new PostalCode(12345));

@asgrim
Types & Value Objects
Practical

@asgrim
Static Analysis with phpstan / Psalm
Practical

@asgrim
Implement a Domain
Practical

@asgrim
Testing is NOT a separate line item

@asgrim
Testing should be an assumption

@asgrim
You’re already testing.

@asgrim
Still need convincing?

@asgrim
Reduce complexity
public function process(Stuff a, string b, int c) : MoreStuff
{
// lots of complicated code

@asgrim
Reduce complexity
public function meaningfulThing(Stuff a, string b, int c) : More
{
// call nicer, meaningful methods below
}
private function throwStuffIntoFire(Stuff a) : Fire
{
// smaller, meaningful chunk of code
}
private function combineStringWithFire(Fire a, string b) : string
{
// simple, lovely code!
}
private function postFlowersToSpain(int c) : void

@asgrim
More complexity = more tests

@asgrim
Testing Legacy Code
Yes it’s possible… but harder

@asgrim
Line coverage
<?php
function foo(bool $a, bool $b) {
if ($a) {
echo "A";
}
if ($b) {
echo "B";
}
}
// generate coverage using calls:
foo(true, false);
foo(false, true);

@asgrim
Branch coverage
<?php
if ($a) {
echo "A";
}
if ($b) {
echo "B";
}
}
foo(true, false);
foo(false, true);

@asgrim
Branch coverage
<?php
if ($a) {
echo "A";
}
if ($b) {
echo "B";
}
}
foo(true, false);
foo(false, true);
foo(false, false); // NEW TEST!!!

@asgrim
Branch coverage
<?php
if ($a) {
echo "A";
}
if ($b) {
echo "B";
}
}
foo(true, false);
foo(false, true);
foo(false, false); // NEW TEST!!!
foo(true, true); // NEW TEST!!!

@asgrim
Branch vs Line Coverage

@asgrim
Prevent coverage leaking

@asgrim
Prevent coverage leaking
<?php
namespace Foo;
/**
* @covers FooBar
*/
final class BarTest extends TestCase
{
// write some tests!
}

@asgrim
Are the tests testing?

@asgrim
Example of a test not testing…
public function testPurchaseTickets()
{
$event = Event::create(uniq('event', true)
$customer = Customer::create(uniq('name', true));
$shop->purchaseTicket(1, $event, [$customer]);
}
@asgrim

@asgrim
Assert you’re asserting
public function testPurchaseTickets()
{
$event = Event::create(uniq('event', true)
$customer = Customer::create(uniq('name', true));
$receipt = $shop->purchaseTicket(1, $event, [$customer]);
self::assertSame($event, $receipt->event());
$customersInReceipt = $receipt->customers();
self::assertCount(1, $customersInReceipt);
self::assertContains($customer, $customersInReceipt);
}
@asgrim

@asgrim
Test the tests are testing!

@asgrim
Mutation testing
function add(int $a, int $b) : int {
return $a + $b;
}
function testAdd() {
$result = add(2, 3);
// self::assertSame(5, $result);
}

@asgrim
Mutation testing
return $a - $b;
}
// self::assertSame(5, $result);
}

@asgrim
Mutation testing
return $a - $b;
}
self::assertSame(5, $result);
// /// test will now fail with mutation
}

@asgrim
What about other tests?

@asgrim
BAD! Do not do this.
Feature: Ability to print my boarding pass
Scenario: A checked in passenger can print their boarding pass
Given I have a flight booked
And I have checked in
When I visit the home page
And I click the ".manage-booking" button
And I enter "CJM23L" in the ".bref-ipt-fld" field
And I click the "Find Booking" button
Then I should see the ".booking-ref.print" button
When I click the ".booking-ref.print" button
Then I should see the print dialogue

@asgrim
Better Behaviour test
Policies:
- Boarding passes are only available when already checked in
- If customer cannot print boarding pass, they can collect at
The airport
- more business rules etc...
Given I have a flight booked for LHR-MIA on 24th May
And I have previously checked in for the flight
When I display my booking reference "CJM23L"
Then I should be able to print my boarding pass
And the boarding pass should display flight details correctly

@asgrim
Why is this important?

@asgrim
Automated tests
Application (and UI, API, etc.)
Domain / Business Logic
Infrastructure (DBAL, APIs, etc.)

@asgrim
Testing at domain layer
Application (UI, API, etc.)
Domain / Business Logic
Infrastructure (DB, APIs, etc.)
// Testing via the UI
public function iDisplayMyBookingReference(string $reference)
{
$page = $this->getSession()->getPage();
$page->click(".manage-booking");
$page->findField(".bref-ipt-fld")->setValue($reference);
$page->click("Find Booking");
}
// Using the domain layer directly in tests
public function iDisplayMyBookingReference(string $reference)
{
$this->booking = $this->retrieveBooking($reference);
}

@asgrim
Some UI testing is okay!!!
Policies:
- Boarding passes are only available when already checked in
- If customer cannot print boarding pass, they can collect at
The airport
- more business rules etc...
@ui
Given I have a flight booked for LHR-OTP on 24th May
And I have previously checked in for the flight
When I display my booking reference "CJM23L"
Then I should be able to print my boarding pass
And the boarding pass should display flight details correctly

@asgrim
Automate all the things!

@asgrim
Continuous Integration

@asgrim
Tests cost money to run
(manually)

@asgrim
What to look for in code review?

@asgrim
Code style.

@asgrim
Small, atomic changes.

@asgrim
Composer versions.

@asgrim
Structure & good practices.

@asgrim
Tests.

@asgrim
Documentation.

@asgrim
Security.

@asgrim
Insight.

@asgrim
It takes practice.
Some ideas:
https://asgrim.github.io/code-review-checklist/

@asgrim
Easy Deployment Example
Using Heroku (not sponsored)

@asgrim
“Move fast and break things”
-- a stupid Facebook mantra

@asgrim
“Move fast and break things with stable infra”
-- Facebook mantra since 2014

@asgrim
Continuous Delivery & Deployment

@asgrim
Better quality = Higher confidence

@asgrim
Better quality = Higher confidence = Happy customers

Any questions?
https://joind.in/talk/f74a3
James Titcumb
@asgrim

@asgrim
Resources
● Event Storming - Alberto Brandolini
○ http://ziobrando.blogspot.co.uk/2013/11/introducing-event-storming.html
● “Good Design is Imperfect Design” - Eric Evans
○ https://skillsmatter.com/skillscasts/9171-good-design-is-imperfect-design
● “Writing code that lasts” - Rafael Dohms
○ https://www.youtube.com/watch?v=I0y5jU61pS4
● Object Calisthenics - William Durand
○ https://williamdurand.fr/2013/06/03/object-calisthenics/
● “Driving Design through Examples” - Ciaran McNulty
○ https://www.youtube.com/watch?v=83GbyDpJDI4
● Code Review Checklist
○ https://asgrim.github.io/code-review-checklist/

Best practices for crafting high quality PHP apps (php[world] 2019)

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Best practices for crafting high quality PHP apps (php[world] 2019)

Similar a Best practices for crafting high quality PHP apps (php[world] 2019) (20)

Más de James Titcumb

Más de James Titcumb (18)

Último

Último (20)

Best practices for crafting high quality PHP apps (php[world] 2019)