Be pragmatic, be SOLID. Presented at: * Wrocław Symfony Group (22.01.2015) * 4developers (20.04.2015)

1. Be pragmatic,
be SOLID

2. Krzysztof Menżyk
practises TDD
believes that software is a craft
loves domain modelling
obsessed with brewing
plays squash
 kmenzyk
 krzysztof@menzyk.net

3. Do you consider yourself
a professional software developer?

4. New client
Greenfield project
Starting from scratch

7. What went wrong?

8. The code started to rot

9. The design is hard to change
Rigidity

10. The design is easy to break
Fragility

11. Immobility
The design is hard to reuse

12. It is easy to do the wrong thing,
but hard to do the right thing
Viscosity

13. Your software is bound to change

14. Design stamina hypothesis
time
cumulative
functionality
design payoff line
no design
good design
by Martin Fowler

16. What is
Object Oriented Design
then?

17. Design Principles and
Design Patterns
Robert C. Martin

18. Single Responsibility
Open Closed
Liskov Substitution
Interface Segregation
Dependency Inversion

19. Single
Responsibility
Principle
A class should have
only one reason to change

20. Gather together those things that
change for the same reason
Separate those things that change
for different reasons

21. class Employee
{
public static function hire($name, $forPosition, Money $withSalary)
{
// ...
}
public function promote($toNewPosition, Money $withNewSalary)
{
// ...
}
public function asJson()
{
// ...
}
public function save()
{
// ...
}
public function delete()
{
// ...
}
}

22. Try to describe what the class does

23. class Employee
{
public static function hire($name, $forPosition, Money $withSalary)
{
// ...
}
public function promote($toNewPosition, Money $withNewSalary)
{
// ...
}
public function asJson()
{
// ...
}
public function save()
{
// ...
}
public function delete()
{
// ...
}
}

24. class Employee
{
public static function hire($name, $forPosition, Money $withSalary)
{
// ...
}
public function promote($toNewPosition, Money $withNewSalary)
{
// ...
}
public function asJson()
{
// ...
}
public function save()
{
// ...
}
public function delete()
{
// ...
}
}

25. class Employee
{
public static function hire($name, $forPosition, Money $withSalary)
{
// ...
}
public function promote($toNewPosition, Money $withNewSalary)
{
// ...
}
public function asJson()
{
// ...
}
public function save()
{
// ...
}
public function delete()
{
// ...
}
}

27. class Employee
{
public static function hire($name, $forPosition, Money $withSalary)
{
// ...
}
public function promote($toNewPosition, Money $withNewSalary)
{
// ...
}
public function asJson()
{
// ...
}
public function save()
{
// ...
}
public function delete()
{
// ...
}
}
violation

28. class Employee
{
public static function hire($name, $forPosition, Money $withSalary)
{
// ...
}
public function promote($toNewPosition, Money $withNewSalary)
{
// ...
}
}
class EmployeeSerializer
{
public function toJson(Employee $employee)
{
// ...
}
}
class EmployeeRepository
{
public function save(Employee $employee)
{
// ...
}
public function delete(Employee $employee)
{
// ...
}
}
the right
way

29. What about applying SRP
to class methods?

30. What about applying SRP
to test methods?

31. /** @test */
public function test_employee()
{
$employee = Employee::hire('John Doe', 'Junior Developer', $this->fiveHundredEuros);
$this->assertEquals($this->fiveHundredEuros, $employee->getSalary());
$employee->promote('Senior Developer', $this->sixHundredEuros);
$this->assertEquals($this->sixHundredEuros, $employee->getSalary());
$employee->promote('Technical Leader', $this->fiveHundredEuros);
$this->assertEquals($this->sixHundredEuros, $employee->getSalary());
}

32. /** @test */
public function it_hires_with_salary()
{
$employee = Employee::hire('John Doe', 'Junior Developer', $this->fiveHundredEuros);
$this->assertEquals($this->fiveHundredEuros, $employee->getSalary());
}
/** @test */
public function it_promotes_with_new_salary()
{
$employee = Employee::hire('John Doe', 'Junior Developer', $this->fiveHundredEuros);
$employee->promote('Senior Developer', $this->sixHundredEuros);
$this->assertEquals($this->sixHundredEuros, $employee->getSalary());
}
/** @test */
public function it_does_not_promote_if_new_salary_is_not_bumped()
{
$employee = Employee::hire('John Doe', 'Senior Developer', $this->sixHundredEuros);
$employee->promote('Technical Leader', $this->fiveHundredEuros);
$this->assertEquals($this->sixHundredEuros, $employee->getSalary());
}
the right
way

33. One test covers one behaviour

34. Open
Closed
Principle
Software entities should be open for
extension, but closed for modification

35. Write once, change never!

36. Wait! What?

37. class Shortener
{
public function shorten(Url $longUrl)
{
if (!$this->hasHttpScheme($longUrl)) {
throw new InvalidUrl('Url has no "http" scheme');
}
// do stuff to shorten valid url
return $shortenedUrl;
}
private function hasHttpScheme(Url $longUrl)
{
// ...
}
}
/** @test */
public function it_does_not_shorten_url_without_http()
{
$urlToFtp = // ...
$this->setExpectedException(InvalidUrl::class, 'Url has no "http" scheme');
$this->shortener->shorten($urlToFtp);
}

38. class Shortener
{
public function shorten(Url $longUrl)
{
if (!$this->hasHttpScheme($longUrl)) {
throw new InvalidUrl('Url has no "http" scheme');
}
if (!$this->hasPlDomain($longUrl)) {
throw new InvalidUrl('Url has no .pl domain');
}
// do stuff to shorten valid url
return $shortenedUrl;
}
private function hasHttpScheme(Url $longUrl)
{
// ...
}
private function hasPlDomain(Url $longUrl)
{
// ...
}
}

39. /** @test */
public function it_shortens_only_urls_with_pl_domains()
{
$urlWithEuDomain = // ...
$this->setExpectedException(InvalidUrl::class, 'Url has no .pl domain');
$this->shortener->shorten($urlWithEuDomain);
}

40. /** @test */
public function it_shortens_only_urls_with_pl_domains()
{
$urlWithEuDomainButWithHttpScheme = // ...
$this->setExpectedException(InvalidUrl::class, 'Url has no .pl domain');
$this->shortener->shorten($urlWithEuDomainButWithHttpScheme);
}

41. /** @test */
public function it_shortens_urls()
{
$validUrl = // make sure the url satisfies all "ifs"
$shortenedUrl = $this->shortener->shorten($validUrl);
// assert
}

42. Testing seems hard?

43. class Shortener
{
public function shorten(Url $longUrl)
{
if (!$this->hasHttpScheme($longUrl)) {
throw new InvalidUrl('Url has no "http" scheme');
}
if (!$this->hasPlDomain($longUrl)) {
throw new InvalidUrl('Url has no .pl domain');
}
// do stuff to shorten valid url
return $shortenedUrl;
}
private function hasHttpScheme(Url $longUrl)
{
// ...
}
private function hasPlDomain(Url $longUrl)
{
// ...
}
} violation

44. Abstraction is the key

45. interface Rule
{
/**
* @param Url $url
*
* @return bool
*/
public function isSatisfiedBy(Url $url);
}

46. class Shortener
{
public function addRule(Rule $rule)
{
// ...
}
public function shorten(Url $longUrl)
{
if (!$this->satisfiesAllRules($longUrl)) {
throw new InvalidUrl();
}
// do stuff to shorten valid url
return $shortenedUrl;
}
private function satisfiesAllRules(Url $longUrl)
{
// ...
}
}
the right
way

47. class HasHttp implements Rule
{
public function isSatisfiedBy(Url $url)
{
// ...
}
}
class HasPlDomain implements Rule
{
public function isSatisfiedBy(Url $url)
{
// ...
}
}

48. ”There is a deep synergy between
testability and good design”
– Michael Feathers

49. Liskov
Substitution
Principle
Subtypes must be substitutable
for their base types

50. class Tweets
{
protected $tweets = [];
public function add(Tweet $tweet)
{
$this->tweets[$tweet->id()] = $tweet;
}
public function get($tweetId)
{
if (!isset($this->tweets[$tweetId])) {
throw new TweetDoesNotExist();
}
return $this->tweets[$tweetId];
}
}

51. class BoundedTweets extends Tweets
{
const MAX = 10;
public function add(Tweet $tweet)
{
if (count($this->tweets) > self::MAX) {
throw new OverflowException();
}
parent::add($tweet);
}
}

52. function letsTweet(Tweets $tweets)
{
// ...
// $tweets has already 10 tweets
$tweets->add(new Tweet('Ooooops'));
}

53. function letsTweet(Tweets $tweets)
{
// ...
try {
$tweets->add(new Tweet('Ooooops'));
} catch (OverflowException $e) {
// What to do?
}
}
violation

54. Design by contract

55. Design by contract
(because public API is not enough)

56. What does it expect?
What does it guarantee?
What does it maintain?

57. class Tweets
{
public function add(Tweet $tweet)
{
// ...
}
/**
* @param $tweetId
*
* @return Tweet
*
* @throws TweetDoesNotExist If a tweet with the given id
* has not been added yet
*/
public function get($tweetId)
{
// ...
}
}

58. interface Tweets
{
public function add(Tweet $tweet);
/**
* @param $tweetId
*
* @return Tweet
*
* @throws TweetDoesNotExist If a tweet with the given id
* has not been added yet
*/
public function get($tweetId);
}
class InMemoryTweets implements Tweets
{
// ...
}

59. public function retweet($tweetId)
{
try {
$tweet = $this->tweets->get($tweetId);
} catch (TweetDoesNotExist $e) {
return;
}
// ...
}

60. class DoctrineORMTweets extends EntityRepository implements Tweets
{
public function add(Tweet $tweet)
{
$this->_em->persist($tweet);
$this->_em->flush();
}
public function get($tweetId)
{
return $this->find($tweetId);
}
}

61. class EntityRepository implements ObjectRepository, Selectable
{
/**
* Finds an entity by its primary key / identifier.
*
* @param mixed $id The identifier.
* @param int $lockMode The lock mode.
* @param int|null $lockVersion The lock version.
*
* @return object|null The entity instance
* or NULL if the entity can not be found.
*/
public function find($id, $lockMode = LockMode::NONE, $lockVersion = null)
{
// ...
}
// ...
}

62. function retweet($tweetId)
{
if ($this->tweets instanceof DoctrineORMTweets) {
$tweet = $this->tweets->get($tweetId);
if (null === $tweet) {
return;
}
} else {
try {
$tweet = $this->tweets->get($tweetId);
} catch (TweetDoesNotExist $e) {
return;
}
}
// ...
} violation

63. Violations of LSP are
latent violations of OCP

64. class DoctrineORMTweets extends EntityRepository implements Tweets
{
// ...
public function get($tweetId)
{
$tweet = $this->find($tweetId);
if (null === $tweet) {
throw new TweetDoesNotExist();
}
return $tweet;
}
}
the right
way

65. LSP violations are difficult
to detect until it is too late

66. Ensure the expected behaviour of
your base class is preserved in
derived classes

67. Dependency
Inversion
Principle
High-level modules should not depend on low-level
modules, both should depend on abstractions
Abstractions should not depend on details.
Details should depend on abstractions

68. class PayForOrder
{
public function __construct(PayPalApi $payPalApi)
{
$this->payPalApi = $payPalApi;
}
public function function pay(Order $order)
{
// ...
$token = $this->payPalApi->createMethodToken($order->creditCard());
$this->payPalApi->createTransaction($token, $order->amount());
// ...
}
}

69. PayForOrder
PayPalApi
Business Layer
Integration Layer

70. High-level module
Low-level module
PayForOrder
PayPalApi

71. Abstraction is the key

72. PaymentProvider
PayPalApi
PayForOrder

73. class PayForOrder
{
public function __construct(PaymentProvider $paymentProvider)
{
$this->paymentProvider = $paymentProvider;
}
public function function pay(Order $order)
{
// ...
$token = $this->paymentProvider->createMethodToken($order->creditCard());
$this->paymentProvider->createTransaction($token, $order->amount());
// ...
}
}

74. class PayForOrder
{
public function __construct(PaymentProvider $paymentProvider)
{
$this->paymentProvider = $paymentProvider;
}
public function function pay(Order $order)
{
// ...
$token = $this->paymentProvider->createMethodToken($order->creditCard());
$this->paymentProvider->createTransaction($token, $order->amount());
// ...
}
}
Abstractions should not depend on details.
Details should depend on abstractions

75. Define the interface
from the usage point of view

76. class PayForOrder
{
public function __construct(PaymentProvider $paymentProvider)
{
$this->paymentProvider = $paymentProvider;
}
public function function pay(Order $order)
{
// ...
$token = $this->paymentProvider->charge(
$order->creditCard(),
$order->amount()
);
// ...
}
}
the right
way

77. Concrete things change alot
Abstract things change much
less frequently

78. PaymentProvider
PayPalProvider
PayForOrder
PayPalApi
3rd party

79. class PayPalProvider extends PayPalApi implements PaymentProvider
{
public function charge(CreditCard $creditCard, Money $forAmount)
{
$token = $this->createMethodToken($creditCard);
$this->createTransaction($token, $forAmount);
}
}

80. PaymentProvider
PayPalProvider
PayForOrder
PayPalApi
3rd party

81. class PayPalProvider implements PaymentProvider
{
public function __construct(PayPalApi $payPal)
{
$this->payPal = $payPal;
}
public function charge(CreditCard $creditCard, Money $forAmount)
{
$token = $this->payPal->createMethodToken($creditCard);
$this->payPal->createTransaction($token, $forAmount);
}
}

82. class TestPaymentProvider implements PaymentProvider
{
//...
}

83. Interface
Segregation
Principle
Clients should not be forced to depend on
methods they do not use

84. Many client specific interfaces are
better than one general purpose
interface

85. interface EventDispatcherInterface
{
public function dispatch($eventName, Event $event = null);
public function addListener($eventName, $listener, $priority = 0);
public function removeListener($eventName, $listener);
public function addSubscriber(EventSubscriberInterface $subscriber);
public function removeSubscriber(EventSubscriberInterface $subscriber);
public function getListeners($eventName = null);
public function hasListeners($eventName = null);
}

86. class HttpKernel implements HttpKernelInterface, TerminableInterface
{
public function terminate(Request $request, Response $response)
{
$this->dispatcher->dispatch(
KernelEvents::TERMINATE,
new PostResponseEvent($this, $request, $response)
);
}
private function handleRaw(Request $request, $type = self::MASTER_REQUEST)
{
// ...
$this->dispatcher->dispatch(KernelEvents::REQUEST, $event);
// ...
$this->dispatcher->dispatch(KernelEvents::CONTROLLER, $event);
// ...
}
private function filterResponse(Response $response, Request $request, $type)
{
// ...
$this->dispatcher->dispatch(KernelEvents::RESPONSE, $event);
// ...
}
// ...
}

87. class ImmutableEventDispatcher implements EventDispatcherInterface
{
public function dispatch($eventName, Event $event = null)
{
return $this->dispatcher->dispatch($eventName, $event);
}
public function addListener($eventName, $listener, $priority = 0)
{
throw new BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
}
public function removeListener($eventName, $listener)
{
throw new BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
}
public function addSubscriber(EventSubscriberInterface $subscriber)
{
throw new BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
}
public function removeSubscriber(EventSubscriberInterface $subscriber)
{
throw new BadMethodCallException('Unmodifiable event dispatchers must not be modified.');
}
// ...
}
violation

88. It serves too many different
types of clients

89. Design interfaces from
clients point of view

90. interface EventDispatcherInterface
{
public function dispatch($eventName, Event $event = null);
}
interface EventListenersInterface
{
public function addListener($eventName, $listener, $priority = 0);
public function removeListener($eventName, $listener);
}
interface EventSubscribersInterface
{
public function addSubscriber(EventSubscriberInterface $subscriber);
public function removeSubscriber(EventSubscriberInterface $subscriber);
}
interface DebugEventListenersInterface
{
public function getListeners($eventName = null);
public function hasListeners($eventName = null);
} the right
way

91. class EventDispatcher implements EventDispatcherInterface,
EventListenersInterface,
EventSubscribersInterface
{
// ...
}
class DebugEventDispatcher extends EventDispatcher
implements DebugEventListenersInterface
{
// ...
}

92. Design is all about dependencies

93. Think about the design!

94. Listen to your tests

95. ”Always leave the code a little better than
you found it.”

96. But...

97. Be pragmatic

98. "By not considering the future of
your code, you make your code
much more likely to be adaptable
in the future."

99. At the end of the day what
matters most is a business value

100. Know the rules well,
so you can break them effectively

102. Be pragmatic,
be SOLID
 kmenzyk
 krzysztof@menzyk.net
Thanks!

103. Worth reading
http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf
http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod
https://gilesey.wordpress.com/2013/09/01/single-responsibility-principle/
”Clean Code:A Handbook of Agile Software Craftsmanship” by Robert C. Martin
http://martinfowler.com/bliki/DesignStaminaHypothesis.html

104. Photo Credits
https://flic.kr/p/5bTy6C
http://www.bonkersworld.net/building-software/
https://flic.kr/p/jzCox
https://flic.kr/p/n37EXH
https://flic.kr/p/9mcfh9
https://flic.kr/p/7XmGXp
http://my.csdn.net/uploads/201205/13/1336911356_6234.jpg
http://bit.ly/1cMgkPA
https://flic.kr/p/qQTMa
http://bit.ly/1EhyGEc
https://flic.kr/p/5PyErP
http://fc08.deviantart.net/fs49/i/2009/173/c/7/The_Best_Life_Style_by_Alteran_X.jpg
https://flic.kr/p/4Sw9pP
https://flic.kr/p/8RjbTS