The document provides an overview of best practices for professional software design, including writing tests first, applying SOLID principles, avoiding deep nesting and else blocks, using guard clauses, separating commands from queries, favoring composition over inheritance, and writing small, focused classes and methods to reduce complexity. The goal is to create loosely coupled, maintainable code through disciplined refactoring and a message passing architecture with minimal dependencies between objects.

1. Professional-grade
software design

2. whoami
Brian Fenton
@brianfenton
www.brianfenton.us
Mashery, an Intel Company

3. Overview
Testing
SOLID
Object
calisthenics
Smells
Patterns
Resources

4. Professional
Jeff Hebert, HeroMachine.com

5. Tests!

6. If you don’t have tests, you’re
REWRITING, not refactoring

7. Tests first
Testing after you write the class won’t
improve your design
More likely to just test the
implementation (low value, brittle tests)

8. Unit testing forces you to
feel the pain of bad design
up front

9. Some smells exposed by
tests
Lots of dependencies
Class/method does too much
Requires lots of setup to do anything
Class is too coupled to its environment
Lots of protected/private methods
Likely another class worth of behavior
hidden inside

10. SOLID
S – Single Responsibility
O – Open/Closed
L – Liskov Substitution
I – Interface Segregation
D – Dependency Inversion
Because no one can pronounce SRPOCPLSPISPDIP

11. Single Responsibility Principle

12. <?php
class Person extends Model {
public $name;
public $birthDate;
protected $preferences;
public function getPreferences() {}
public function save() {}
}

13. <?php
class Person extends Model {
public $name;
public $birthDate;
protected $preferences;
public function getPreferences() {}
}
class DataStore
public function save(Model $model) {}
}

14. Open/Closed Principle
Open for extension
Closed for modification

15. The OCP litmus test
Can you add/change a feature by only adding new
classes?
Also allowed to update
Controllers
Configuration
Templates

16. Liskov Substitution
Principle
“objects in a program should be
replaceable with instances of their
subtypes without altering the correctness
of that program.”

17. abstract class Shape{
public function getHeight();
public function setHeight($height);
public function getLength();
public function setLength($length);
}

18. class Square extends Shape{
protected $size;
public function getHeight() {
return $this->size;
}
public function setHeight($height) {
$this->size = $height;
}
public function getLength() {
return $this->size;
}
public function setLength($length) {
$this->size = $length;
}
}

19. class Rectangle extends Shape{
protected $height;
protected $length;
public function getHeight() {
return $this->height;
}
public function setHeight($height) {
$this->height= $height;
}
public function getLength() {
return $this->length;
}
public function setLength($length) {
$this->length= $length;
}
}

20. Interface Segregation Principle

21. Dependency Inversion
Principle
“Higher level modules should not depend
on lower level modules”

22. TL;DR
mysqli_query() BAD
DataStore->query() GOOD

23. Naming
Care about your names
(class/method/variable)
If it’s hard to name something, it means
you can’t describe it succinctly
If you can’t describe what it does, it
does too much or you don’t understand
what it does

24. Good Naming
Don’t abbreviate
Don’t be afraid to be verbose

25. Suspect Names
Classes
Manager
Handler
Methods
Process
“And”

26. Comments
Use inline comments sparingly
Do use docblocks though

27. TODOs
Tend to rot and never get fixed
If you use a TODO, add a ticket number

28. A well-named method that
communicates intent is far
more valuable than a comment

29. Methods
You can (almost) always make a
method smaller
Pay attention to your execution path
Check your CRAP index with phpmd or
codesniffer
You can (almost) always add more
methods

30. Cognitive load
Declare variables as close to when they
will be used as possible
If you can pass data from method to
method directly, no need for a variable

31. Source order
Declare methods in the order they’re
called
Public to private

32. Avoid “magic” values
DRY
Single source of truth
Self-documenting

33. Which of these is easier to
understand?
json_last_error() == 5;
json_last_error() == JSON_ERROR_UTF8;
$length > 1024
$length > self::MAX_LENGTH
$limit = 0
$limit = self::RATE_UNLIMITED

34. Not what I mean!
unsigned three = 1;
unsigned five = 5;
unsigned seven = 7;
https://github.com/torvalds/linux/blob/d158fc7f36a25e19791d
25a55da5623399a2644f/fs/ext4/resize.c#L698-700

35. “2 is a code smell”
- Alex Miller

36. Dependency Injection
Pass external dependencies into objects
Constructor injection
Setter injection
Potential smell: too many dependencies
Ask for things, don’t look for them

37. Object Calisthenics
(briefly)

38. No more than one level of
indentation per method

39. public function processData($data) {
$newData = array();
$count = 1;
foreach ($data as $row) {
if (!$row) {
continue;
}
if ($count === 1) {
$newData[] = implode(',', array_keys($row));
} else {
$newData[] = implode(',', $row);
}
$count++;
}
return $newData;
}

40. …
foreach ($data as $row) {
// skip empty rows
if (!$row) {
continue;
}
if ($count === 1) {
$newData[] = implode(',', array_keys($row));
} else {
$newData[] = implode(',', $row);
}
$count++;
}
…

41. public function processData($data) {
$newData = array();
$count = 1;
$data = $this->filterEmptyRows($data);
foreach ($data as $row) {
if ($count === 1) {
$newData[] = implode(',', array_keys($row));
} else {
$newData[] = implode(',', $row);
}
$count++;
}
return $newData;
}
public function filterEmptyRows($rows) {
return array_filter($rows);
}

42. public function processData($data) {
$newData = array();
$count = 1;
$data = $this->filterEmptyRows($data);
foreach ($data as $row) {
$newData[] = $this->processRow($row, $count);
$count++;
}
return $newData;
}
public function processRow($row, $count) {
if ($count === 1) {
return implode(',', array_keys($row));
} else {
return implode(',', $row);
}
}

43. public function processData($data) {
$newData = array();
$headersOnly = true;
$data = $this->filterEmptyRows($data);
foreach ($data as $row) {
$newData[] = $this->processRow($row, $headersOnly);
$headersOnly = false;
}
return $newData;
}
public function processRow($row, $headersOnly) {
if ($headersOnly === true) {
return implode(',', array_keys($row));
} else {
return implode(',', $row);
}
}

44. Interlude… which is
clearer?
$this->setActive(true);
$this->setActive(false);
OR
$this->activate();
$this->deactivate();

45. public function processRow($row,
$headersOnly) {
if ($headersOnly === true) {
return $this->getHeaderRow($row);
} else {
return implode(',', $row);
}
}
public function getHeaderRow($row) {
return implode(',', array_keys($row));
}

46. public function processRow($row,
$headersOnly) {
if ($headersOnly === true) {
return $this->getHeaderRow($row);
} else {
return $this->toCsv($row);
}
}
public function toCsv($row) {
return implode(',', $row);
}

47. public function processData($data) {
$newData = array();
$data = $this->filterEmptyRows($data);
$firstRow= array_pop($data);
$newData[] = $this->getHeaderRow($firstRow);
foreach ($data as $row) {
$newData[] = $this->toCsv($row);
}
return $newData;
}

48. public function transformToCsv($data) {
$data = $this->filterEmptyRows($data);
$firstRow= array_pop($data);
$csv = array();
$csv[] = $this->getHeaderRow($firstRow);
foreach ($data as $row) {
$csv[] = $this->toCsv($row);
}
return $csv;
}

49. public function processData($data) {
$newData = array();
$count = 1;
foreach ($data as $row) {
if (!$row) {
continue;
}
if ($count === 1) {
$newData[] = implode(',', array_keys($row));
} else {
$newData[] = implode(',', $row);
}
$count++;
}
return $newData;
}

50. Don’t use else

51. public function addThreeInts($first, $second, $third) {
if (is_int($first)) {
if (is_int($second)) {
if (is_int($third)) {
$sum = $first + $second + $third;
} else {
return null;
}
} else {
return null;
}
} else {
return null;
}
return $sum;
}

52. public function addThreeInts($first, $second, $third) {
if (!is_int($first)) {
return null;
}
if (!is_int($second)) {
return null;
}
if (!is_int($third)) {
return null;
}
return $first + $second + $third;
}

53. Command-Query
Separation
Complete separation between questions
and commands
“Asking a question shouldn’t change the
answer”

54. public function getUser($id) {
$user = $this->dataStore->fetchUser($id);
if (!$user) {
$user = new User(array($id));
}
return $user;
}

55. public function getUser($id) {
return ($this->dataStore->fetchUser($id) ?: null;
}

56. The final secret…

57. OOP is all about message
passing and behaviors
It’s not about inheritance
It’s not about code reuse
Favor composition over inheritance
Treat objects like APIs

58. User
Event
Listener
Mailer
"Send
Notification"
w/User data
So decouple!
Such architecture
So amaze
Wow
Much message

59. Summary
Write small objects
Write tiny methods
Strive for good names
Seek loose coupling
Focus on message passing
Treat objects like APIs
Write tests (first)
Refactor w/discipline
Limit nesting/no else
Use guard clauses
Avoid magic (anything)
Use CQS
Avoid in-line comments
Reduce cognitive load

60. Resources - Presentations
The Clean Code Talks -- Inheritance,
Polymorphism, & Testing
Object Calisthenics

61. Resources – Books
Code Complete: A Practical Handbook of
Software Construction, Second Edition
Growing Object-Oriented Software, Guided
by Tests
Refactoring: Improving the Design of Existing
Code

62. Questions?
https://joind.in/10562