ExpensePair.new(...)

final ExpensePair firstPair = new ExpensePair(expenses.get(0), expenses.get(1));

final Expense firstExpense = expenses.get(0);
final ExpensePair firstPair = new ExpensePair(firstExpense, expenses.get(1));

final Expense firstExpense = expenses.get(0);
final Expense second = expenses.get(1);
final ExpensePair firstPair = new ExpensePair(firstExpense, second);

public ExpensePair find2ExpensesSumming2020() {
   for (ExpensePair pair : getAllPairs()) {
      if (pair.sumIs2020()) {
         return pair;
      }
   }
   throw new RuntimeException("Can't find a pair summing to 2020");
}

return getAllPairs()
 .stream()
 .filter(ExpensePair::pair.sumIs2020)
 .findAny()
 .orElseThrow(() => new RuntimeException("Can't find a pair summing to 2020"))

private List<ExpensePair> getAllPairs() {
   final List<ExpensePair> result = new LinkedList<>();
   for (Expense first : expenses) {
      final List<ExpensePair> permutationsForOneExpense = permutationsFor(first);
      result.addAll(permutationsForOneExpense);
   }
   return result;
}

result.addAll(permutationsFor(first));

result.addAll(this.permutationsFor(first));

final List<ExpensePair> permutationsForOneExpense = permutationsFor(first);
result.addAll(permutationsForOneExpense);

Why?
- Exposes the intent hides implementation, telling an object to do something for you instead of asking for its internal representation.
- Reduces the amount of knowledge you should have to enable a behavior.
- This doesn’t apply to LINQ (Language Integrated Query) and fluent interfaces.

1. tell, don't ask
2. only touch close collaborators

you should not chain method calls

only talk to your immediate friends

• don't chain method calls
• only touch close collaborators

make the change easy (then make the easy change in red/green)

• tests as documentation
• Model: tests must clearly express required functionality
• Model: naming tests
• Model: Grouping tests

1. Object Calisthenics
2. remove duplication
3. tests clearly express required functionality

1. multiplication, ignoring finding those that sum to 2020
2. find those that sum to 2020, ignoring multiplication

make the change easy then make the easy change

make the change easy then make the easy change

• Pattern: Fake it
• Pattern: obvious implementation

getAllTriples() {
   return getAllPermutations(getAllPairs());
}


getAllPairs() {
   return getAllPermutations(getAllSingles());
}

getAllTriples() {
   return getAllPermutations(3);
}