Software development is hard! SOLID coding principles can help you develop better code. Come learn what the SOLID principles are and practical examples on how to use each strategy when developing in PHP. Leave with the tools needed to architect code that follows established design patterns that lead to better code.

1. Developing SOLID Code
Mark Niebergall
https://www.slideshare.net/MarkNiebergall/developing-solid-code

2. Objective
• Understand SOLID principles
• Improve code architecture

3. Overview
• SOLID Principles
• Practical Examples
• Clean Architecture Bene
fi
ts

4. SOLID Principles
• 5 Principle of OOP
• Promote clean code architecture
• Basis of stable code

5. • S - Single-Responsibility
• O - Open/Closed
• L - Liskov Substitution
• I - Interface Segregation
• D - Dependency Inversion
SOLID Principles

6. SOLID Principles
• S - Single-Responsibility

7. SOLID Principles
class Square
{
public float $length;
public function calculateArea(): float
{
return $this->length * $this->length;
}
public function calculateCircleArea(float $radius): float
{
return pi() * pow($radius, 2);
}
}

8. SOLID Principles
abstract class Shape
{
abstract public function calculateArea(): float;
}
class Circle extends Shape
{
public float $radius;
public function calculateArea(): float
{
return pi() * pow($this->radius, 2);
}
}

9. SOLID Principles
• S - Single-Responsibility
- Do 1 thing
- Do that thing well

10. SOLID Principles
• S - Single-Responsibility
- Decoupled code
- Easier to test

11. SOLID Principles
• S - Single-Responsibility
- Entity
- Service
- Factory
- Validator
- Handler
- Middleware
- Action
- Controller
- Response

12. SOLID Principles
• S - Single-Responsibility
- Worker
- Queue
- Cmd
- Adapter
- Client

13. SOLID Principles
• S - Single-Responsibility
- Abstract
- Interface
- Trait
- Enum

14. SOLID Principles
• O - Open/Closed

15. SOLID Principles
class Pet
{
public function walk(): void
{
$this->putOnLeash();
$this->walkOutside();
}
public function feed($food): void
{
$this->pourFoodInDish($food);
}
}

16. SOLID Principles
abstract class PetAbstract
{
public function __construct(protected string $name)
{
}
public function getName(): string
{
return $this->name;
}
abstract public function feed(Food $food): void;
}
class Snake extends PetAbstract
{
public function feed(Food $food): void
{
// place food in habitat
}
}

17. SOLID Principles
• O - Open/Closed
- Open for extension
- Closed for modi
fi
cation

18. SOLID Principles
• O - Open/Closed
- Extend class instead of altering

19. SOLID Principles
• L - Liskov Substitution

20. SOLID Principles
class Duck
{
public function fly(): bool
{
// ducks can fly!
return true;
}
}
class RubberDuck extends Duck
{
public function fly(): bool
{
// rubber ducks can't fly
return false;
}
}

21. SOLID Principles
• L - Liskov Substitution
- Replaceable by subtypes
- Do not alter parent class

22. SOLID Principles
• L - Liskov Substitution
- Covariance for return types

23. SOLID Principles
• I - Interface Segregation

24. SOLID Principles
interface EmployeeInterface
{
public function checkEmail(): bool;
public function createPullRequest(): PullRequest;
public function attendMeeting(Meeting $meeting): void;
}

25. SOLID Principles
• I - Interface Segregation
- Many client-speci
fi
c interfaces are better than one
general-purpose interface
- Keep interfaces simple

26. SOLID Principles
• I - Interface Segregation
- Remember the S for Single-Responsibility

27. SOLID Principles
• I - Interface Segregation
- Most PHPFIG PSRs are interfaces
‣ HTTP Handlers, Client
‣ Cache
‣ Factories
‣ Logging

28. SOLID Principles
• D - Dependency Inversion

29. SOLID Principles
class UserService
{
protected HotmailEmailClient $hotmailEmailClient;
public function setHotmailEmailClient(HotmailEmailClient $hotmailEmailClient): void
{
$this->hotmailEmailClient = $hotmailEmailClient;
}
public function emailUser(User $user): bool
{
$emailMessage = new EmailMessage();
$emailMessage->setEmailAddress($user->getEmailAddress());
return $this->hotmailEmailClient->sendEmail($emailMessage);
}
}

30. SOLID Principles
class ContactService
{
protected EmailClientInterface $emailClient;
public function setEmailClient(EmailClientInterface $emailClient): void
{
$this->emailClient = $emailClient;
}
public function sendEmail(
Contact $contact,
EmailMessageInterface $emailMessage
): bool {
$emailMessage->setEmailAddress($contact->getEmailAddress());
return $this->emailClient->sendEmail($emailMessage);
}
}

31. SOLID Principles
• D - Dependency Inversion
- Use interfaces, abstracts rather than concrete classes

32. SOLID Principles
• D - Dependency Inversion
- Law of Demeter
‣ No reaching through to object’s objects

33. SOLID Principles
• D - Dependency Inversion
- Promotes code reuse
- Promotes code compatibility

34. Practical Examples

35. Practical Examples
class UserEntity implements HydratorInterface, ToArrayInterface
{
protected int $id;
protected string $username;
protected bool $isActive;
public function hydrate(array $data)
{
$this->setId($data['id']);
$this->setUsername($data['username']);
$this->setIsActive($data['is_active']);
}
public function toArray(): array
{
return [
'id' => $this->getId(),
'username' => $this->getUsername(),
'is_active' => $this->getIsActive(),
];
}

36. Practical Examples
class AuditRequestMiddleware implements MiddlewareInterface
{
public function __construct(protected AuditService $auditService)
{
}
public function process(
ServerRequestInterface $request,
RequestHandlerInterface $handler
): ResponseInterface {
$response = $handler->handle($request);
$this->auditService->auditRequest($request, $response);
return $response;
}
}

37. • Other ideas?
Practical Examples

38. Clean Architecture Bene
fi
ts

39. Clean Architecture Bene
fi
ts
• Promotes other best practices
- DDD: Domain Driven Design
- DRY: Don’t Repeat Yourself
- KISS: Keep It Simple, Stupid
- YANGI: You Ain’t Gonna Need It
- OOP: Object Oriented Programming

40. Clean Architecture Bene
fi
ts
• Promotes code reuse
- Write fewer tests!
- Lower maintenance

41. Clean Architecture Bene
fi
ts
• Introduce fewer bugs
- Code stabilization
- Less brittle code

42. Clean Architecture Bene
fi
ts
• Decoupled Code
- Easier architecture to unit test
- Easier to read
- Easier to use
- Easier to upgrade packages
- Easier to swap out third-party providers

43. Clean Architecture Bene
fi
ts
• More features, less debugging
- Improve team velocity
- More time delivering value
- Less time debugging unstructured code and data

44. Clean Architecture Bene
fi
ts
• Improved Scalability
- Add new tables, columns
- Already setup to expand domains

45. Clean Architecture Bene
fi
ts
• Con
fi
dence in authored code
- Reduce unknowns
- Testable code

46. Clean Architecture Bene
fi
ts
• Other?

47. Review
• S - Single-Responsibility
• O - Open/Closed
• L - Liskov Substitution
• I - Interface Segregation
• D - Dependency Inversion

48. SOLID Principles
• Questions?
• Discussion points?

49. Mark Niebergall @mbniebergall
• PHP since 2005
• Masters degree in MIS
• Senior Software Engineer
• Vulnerability Management project (security scans)
• Utah PHP Co-Organizer
• CSSLP, SSCP Certi
fi
ed and SME
• Endurance sports, outdoors

50. References
• https://www.hashbangcode.com/article/solid-principles-
php
• https://levelup.gitconnected.com/solid-principles-
simpli
fi
ed-php-examples-based-dc6b4f8861f6
• https://www.digitalocean.com/community/
conceptual_articles/s-o-l-i-d-the-
fi
rst-
fi
ve-principles-of-
object-oriented-design