The document discusses domain-driven design (DDD) and the importance of developing a ubiquitous language between domain experts and developers. It emphasizes focusing modeling efforts on building a clear domain model specific to the client's needs, and using this shared language to facilitate conversations without misinterpretations and improve understanding. Developing the domain model involves techniques like knowledge crunching, domain-oriented patterns and architectures, and isolating the domain from other concerns. The overall goal is not just writing code but understanding the problem domain.

1. Domain Driven Design

2. Ubiquitous Language
UbiquitousLanguage@Fowler's blog

3. Ubiquitous Language
That’s all there is to it

4. Ubiquitous Language
That’s all there is to it
Questions?

5. Client
(Domain expert)
Project Manager Developer
We need to add a new
security policy to our
accounts. Our customers
can’t have more than two
active offers per billing term.
We need to restrict
promotions. A user cannot
have more than two
promotions per month.
public function validate(User $user)
{
// … other crazy validations
if (count ($user->getPromotions()) > 2)
throw new ValidationException(
“User can’t have more than 2
promotions per month”
);
// … continue with crazy validations
}

6. Favor model language
over translations

7. Client
(Domain expert)
Project Manager Developer
We need to add a new
security policy to our
accounts. Our customers
can’t have more than two
active offers per billing term.
public function validate(Account $account)
{
// … other crazy validations
if (! $account->satisfies(
new ActiveOffersPerBillingTermSecurityPolicy
))
throw new ValidationException(
“Account did not satisfy the active offers
security policy”
);
// … continue with crazy validations
}

8. ActiveOffersPerBillingTerm
SecurityPolicy
… really?
TOO MUCH CODE!
I WON’T TYPE THAT!!!11

9. Semantics

10. Semantics
ActiveOffersPerBillingTermSecurityPolicy means something
in the MODEL LANGUAGE
count($user->getPromotions()) > 2
does not convey this knowledge

11. Semantics
ActiveOffersPerBillingTermSecurityPolicy means something
in the MODEL LANGUAGE
count($user->getPromotions()) > 2
does not convey this knowledge
=> MAKE IMPLICIT BUSINESS RULES EXPLICIT

12. Favor model language
over translations
When a domain expert (client) feels something’s wrong with the model
language, you’ll know something’s wrong with the domain model.

13. Client
(Domain expert)
Project Manager Developer
When we talk about a billing
term, we need to consider if
the customer is billed on a
monthly or yearly basis.
| class ActiveOffersPerBillingTermSecurityPolicy
| {
| protected $maxOffers = 2;
|
| public function isSatisfiedBy(Account $account)
| {
| return count(
- | $account->getMonthlyOffers()
+ | $account->getOffersForBillingTerm()
| ) < $this->maxOffers;
| }

14. Domain Knowledge

15. Domain Knowledge
Focus your efforts in building a clear domain,
specific to your client’s needs

16. Knowledge crunching

17. Client
(Domain expert)
class LongOverdueCustomerContactCommand
{
public function execute()
{
$customers = Customer::where(
‘account.balance’, ‘<’, 0
)->get();
foreach ($customers as $customer)
$this->sendRefinanceEmail($customer);
}
}
Project Manager Developer
We need to contact long
overdue customers to
refinance their debt.

18. Client
(Domain expert)
class LongOverdueCustomerContactCommand
{
public function execute()
{
$customers = Customer::where(
‘account.balance’, ‘<’, 0
)->get();
foreach ($customers as $customer)
$this->sendRefinanceEmail($customer);
}
}
Project Manager Developer
We need to contact long
overdue customers to
refinance their debt.

19. Client
(Domain expert)
Project Manager Developer
We need to contact long
overdue customers to
refinance their debt.
What is the difference
between a regular customer,
an overdue customer and a
long overdue customer?

20. Client
(Domain expert)
class CustomerRepository
{
public function findOverdue()
{
return Customer::where(‘account.balance’, ‘<’, 0)
->get();
}
public function findLongOverdue()
{
// Write more complex query logic for this one...
}
}
Project Manager Developer
Overdue is straightforward,
customers in debt right now.
Long overdue customers are
the ones that have been
overdue over the last 3
billing terms, at the end of
each billing term.

21. Knowledge crunching
Knowledge crunching deepens the domain
model, and brings better understanding

22. But… How?

23. Domain-oriented
Design Patterns

24. class AccountsController
{
public function index()
{
$accounts = Account::all();
return View::make(‘accounts.index’, [
‘accounts’ => $accounts
]);
}
}

25. class AccountsController
{
public function index()
{
$accounts = Account::all();
return View::make(‘accounts.index’, [
‘accounts’ => $accounts
]);
}
}

26. EvansClassification@Fowler's blog

27. Entities

28. Entities
Objects with an identity
Lifespan
Unique criteria

29. ValueObjects

30. ValueObjects
Defined by their attributes

31. Aggregates

32. Aggregates
Cluster of domain objects
Transactional coherence

33. Services

34. Services
Domain coordinators
Define actions

35. Repositories

36. Repositories
Data access abstraction

37. Factories

38. Factories
Object creation

39. Domain Events

40. Domain Events
Objects that represent significant domain
events

41. Domain-oriented
Architecture

42. Layered Architecture

43. Layered Architecture

44. Hexagonal Architecture

45. Hexagonal Architecture

46. Domain-oriented
Architecture
Isolate your domain model from
specific application needs:
UI - Persistence - External Services -
Application workflow - etc...

47. So… What’s the point?

48. It’s not about writing
code

49. It’s not about writing
code
That’s the easy part… right?

50. It’s not about writing
code
It’s about understanding what needs to be
solved before starting to code

51. Creating a language which
makes conversations
between domain experts and
developers possible without
misinterpretations

52. Creating a language which
makes conversations
between domain experts and
developers possible without
(so many) misinterpretations

53. ● Eric Evans, “Domain-Driven Design: Tackling Complexity in the Heart of Software”
● Vaughn Vernon, “Implementing Domain-Driven Design”
● Martin Fowler, “Patterns of Enterprise Application Architecture”
● dddcommunity.org | Domain Driven Design Community
● -http://domainlanguage.com/ddd/reference/DDD_Reference_2011-01-31.pdf
● -http://www.lmgtfy.com/?q=Domain+Driven+Design