Domain-Driven Design: Tackling Complexity in the Heart of Software

Separating Commands and S
IDE
-E
FFECT
-F
REE
 F
UNCTIONS
This design already has 
INTENTION-REVEALING INTERFACES
. But the
distributePaymentPrincipal()
method does a dangerous thing: It calculates the shares for
distribution and also modifies the 
Loan
. Let's refactor to separate the query from the modifier.
Figure 10.17.
public void applyPrincipalPaymentShares(Map paymentShares) {
Map loanShares = getShares();
Iterator it = paymentShares.keySet().iterator();
while(it.hasNext()) {
Object lender = it.next();
Share paymentShare = (Share) paymentShares.get(lender);
Share loanShare = (Share) loanShares.get(lender);
double newLoanShareAmount = loanShare.getAmount() -
paymentShare.getAmount();
Share newLoanShare = new Share(lender, newLoanShareAmount);
loanShares.put(lender, newLoanShare);
}
}
public Map calculatePrincipalPaymentShares(double paymentAmount) {
Map paymentShares = new HashMap();
Map loanShares = getShares();
double total = getAmount();
Iterator it = loanShares.keySet().iterator();
while(it.hasNext()) {
Object lender = it.next();
Share loanShare = (Share) loanShares.get(lender);
double paymentShareAmount =
loanShare.getAmount() / total * paymentAmount;
Share paymentShare = new Share(lender, paymentShareAmount);
paymentShares.put(lender, paymentShare);
}
return paymentShares;
}
Client code now looks like this:

---

Map distribution =
aLoan.calculatePrincipalPaymentShares(paymentAmount);
aLoan.applyPrincipalPaymentShares(distribution);
Not too bad. The 
FUNCTIONS
have encapsulated a lot of complexity behind 
INTENTION-REVEALING
INTERFACES
. But the code does begin to multiply some when we add 
applyDrawdown()
,
calculateFeePaymentShares()
, and so on. Each extension complicates the code and weighs it
down. This might be a point where the granularity is too coarse. The conventional approach would
be to break the calculation methods down into subroutines. That could well be a good step along
the way, but we ultimately want to see the underlying conceptual boundaries and deepen the
model. The elements of a design with such a 
CONCEPT-CONTOURING
grain could be combined to
produce the needed variations.