Accelerate development with simple design - ShareIT

© 2021 Thoughtworks
Accelerate development
with simple design
Matteo Vaccari
ShareIT online meetup, 2027/10/2021

View Slide

© 2021 Thoughtworks 2

View Slide

So…… what works?

View Slide


View Slide

🤔

View Slide

Kent Beck on Simple Design
6
https://martinfowler.com/bliki/BeckDesignRules.html

View Slide

Kent Beck on “good code”
There are a few things I look for:
● Once and only once [...]
● Lots of little pieces [...]
● Replacing objects [... In a really good system, every time the user says “I
want to do this radically new thing”, the developer says, “Oh, I’ll have to
make a new kind of X and plug it in.” When you can extend a system
solely by adding new objects without modifying any existing objects,
then you have a system that is flexible and cheap to maintain
● Replacing objects [...]
● Moving objects [...]
Kent Beck, Smalltalk Best Practice Patterns, 1997

View Slide

The problem
8

View Slide

@Test
void addItemToCart_returnOk_addGiftItem_withNoFraudAlert() {
Item previousItem = new Item("a tv");
Item addedItem = new Item("a book");
Item giftItem = new Item("gift", ItemFlag.GIFT);
Cart cart = new Cart().withItem(previousItem);
AddItemToCartCommand command = new AddItemToCartCommand(cart, addedItem);
when(inventoryService.checkAvailability(addedItem)).thenReturn(AVAILABLE);
when(fraudDetectionService.looksSuspicious(cart)).thenReturn(false);
when(giftItemService.getTodaysGiftItem()).thenReturn(giftItem);
AddItemToCartResult addItemToCartResult = cartService.addItem(command);
assertThat(addItemToCartResult).isEqualTo(AddItemToCartResult.ok());
ArgumentCaptor cartArgumentCaptor = ArgumentCaptor.forClass(Cart.class);
verify(cartRepository).update(cartArgumentCaptor.capture());
assertThat(cartArgumentCaptor.capture()).isEqualTo(cart
.withItem(previousItem)
.withItem(addedItem)
.withItem(giftItem)
);
verify(alertService, never()).signal(any());
}
9
In a codebase near you…

View Slide

public CartService(CartRepository cartRepository, InventoryService inventoryService, FraudDetectionService
fraudDetectionService, AlertService alertService, GiftItemService giftItemService) {
this.cartRepository = cartRepository;
this.inventoryService = inventoryService;
this.fraudDetectionService = fraudDetectionService;
this.alertService = alertService;
this.giftItemService = giftItemService;
}
public AddItemToCartResult addItem(AddItemToCartCommand command) {
if (inventoryService.checkAvailability(command.getItem()) == NOT_AVAILABLE) { // 󰍹
return AddItemToCartResult.itemNotAvailable();
}
Cart cart = command.getCart();
cart.addItem(command.getItem()); // 󰍽
Item todaysGiftItem = giftItemService.getTodaysGiftItem(); // 󰍼
if (!cart.containsGiftItem()) {
cart.addItem(todaysGiftItem);
}
if (fraudDetectionService.looksSuspicious(cart)) { // 󰍶
alertService.signal(new SuspiciousCartAlert(cart));
}
cartRepository.update(cart); // 󰍵
return AddItemToCartResult.ok();
}
10
And the culprit is…

View Slide

Searching for a solution
11

View Slide

Favor object composition over inheritance
– Gamma, Helm, Johnson, Vlissides, 1995
All modules should be open for extension,
and closed for modi ication
– Bertrand Meyer (more or less), 1988
Be able to extend a system solely by adding new
objects, without modifying any existing objects
– Kent Beck, 1998
Composition is the Essence of Programming
– Bartosz Milewski, 2014
Objects should be composable
– David West, 2004

View Slide


View Slide

New features should be coded in new code files,
with no modification to existing code files
– Paraphrasing Kent Beck

View Slide

The goal of the Open-Closed Principle
The aim of the OCP is to organize software around backplanes, that allow extension
simply by developing and connecting a new module, just like hardware backplanes or
cartridges.

View Slide

New features should be coded in new code files,
with no modification to existing code files
Consequences:
● If a feature must be removed, it can be removed by simply
removing its code files;
● If a feature must be changed, it can be changed by changing
only its code files.
● All the code that implements a given story/feature/business
rule can be found in specific files, dedicated to implement
just that story/feature/business rule

View Slide

My life with the Open-Closed Principle
17
2010 blog about the OCP kata
2010 XP Days Benelux
2012 London Code Dojo
2013 XP Manchester
2014 Github repository created
2014 XP2014 in Rome
…
2021 why is this kind of code still prevalent?
http://matteo.vaccari.name/blog/archives/293

View Slide

Unless we are ﬂuent, we will not
be able to do this at work!
18
18

View Slide

19
Most kata are solved in a single object
public class BowlingGame {
private int rolls[] = new int[21];
private int currentRoll = 0;
public void roll(int pins) {
rolls[currentRoll++] = pins;
}
public int score() {
int score = 0;
int frameIndex = 0;
for (int frame = 0; frame < 10; frame++) {
if (isStrike(frameIndex)) {
score += 10 + strikeBonus(frameIndex);
frameIndex++;
} else if (isSpare(frameIndex)) {
score += 10 + spareBonus(frameIndex);
frameIndex += 2;
} else {
score += sumOfBallsInFrame(frameIndex);
frameIndex += 2;
}
}
return score;
}
private boolean isStrike(int frameIndex) {
return rolls[frameIndex] == 10;
}
public class FizzBuzzGame {
public String say(int number) {
if (number % 3 == 0 && number % 5 == 0) {
return "FizzBuzz";
}
if (number % 3 == 0) {
return "Fizz";
}
if (number % 5 == 0) {
return "Buzz";
}
return String.valueOf(number);
}
}
The classic Bowling
Game kata, in the
version of Robert
Martin
Typical solution to
the Fizz Buzz kata
http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata

View Slide

What about upfront design?
20
Robert Martin starts his discussion of the Bowling Kata
with what would be his thinking before TDD
Then he discards the upfront design and proceeds to a
totally different solution in a single class
private int currentRoll = 0;
public void roll(int pins) {
rolls[currentRoll++] = pins;
}
int score = 0;
int frameIndex = 0;
frameIndex++;
frameIndex += 2;
} else {
frameIndex += 2;
}
}
return score;
}
This is an OK way to
do TDD.
The result is fine if no
new requirements
arive

View Slide

An OK solution if no new requirements arrive…
21
😂😂😂
https://www.slideshare.net/xpmatteo/20101125-ocpxpday

View Slide

If you try to
implement all these…
…You end up with IF spaghetti

View Slide

It seemed so simple…
This design is inflexible.
It is at the limit of what we can grasp
intuitively
You add one more IF and it becomes
very hard to read
Perhaps it’s not
int score = 0;
int frameIndex = 0;
frameIndex++;
frameIndex += 2;
} else {
frameIndex += 2;
}
}
return score;
}
}

View Slide

The original design
might have been
useful
private List frames;
int score = 0;
for (Frame frame : frames) {
score += frame.score();
}
return score;
}
}
Simple polymorphism takes
care of most planetary
Bowling requirements
😎

View Slide

}
if (inventoryService.checkAvailability(command.getItem()) == NOT_AVAILABLE) {
}
cart.addItem(command.getItem());
Item todaysGiftItem = giftItemService.getTodaysGiftItem();
}
if (fraudDetectionService.looksSuspicious(cart)) {
}
cartRepository.update(cart);
}
Developers don’t train
nearly enough, and
when they do, they
train to build
monolithic, inﬂexible
solutions
25
25

View Slide

Becoming ﬂuent at program composition
26

View Slide

An exercise to train programming by composition
27
1. Take any standard kata solution
2. Add a new test for a new
requirement
3. Can you make it pass by only
adding new classes, without
changing any existing code except
construction code?
4. Yes → you rock! go back to 2
5. No → disable the new test and
refactor until you can

View Slide

Example: The FizzBuzz Game
28
Example:
1, 2, Fizz!, 4, Buzz!, Fizz!, 7, 8,
Fizz!, Buzz!, 11, Fizz!, 13, 14,
FizzBuzz!, 16, 17, Fizz!...
Rules:
If the number is a multiple of 3, say “Fizz”
If it is a multiple of 5, say “Buzz”
If it is a multiple of 3 and 5, say “FizzBuzz”
Otherwise, just say the number.
public class FizzBuzzGameTest {
private FizzBuzzGame game;
@BeforeEach
public void setUp() {
game = new FizzBuzzGame();
}
@Test
public void justSayTheNumber() {
assertEquals("1", game.say(1));
}
@Test
public void multiplesOfThree() {
assertEquals("Fizz", game.say(3));
}
@Test
public void multiplesOfFive() {
assertEquals("Buzz", game.say(5));
}
@Test
public void multiplesOfFiveAndThree() {
assertEquals("FizzBuzz", game.say(15));
}

View Slide

1. Take a standard solution
29
@BeforeEach
game = new FizzBuzzGame();
}
@Test
public void justSayTheNumber() {
}
@Test
public void multiplesOfThree() {
}
@Test
public void multiplesOfFive() {
}
@Test
public void multiplesOfFiveAndThree() {
}
if (isMultipleOf(3, number) && isMultipleOf(5, number)) {
return "FizzBuzz";
}
if (isMultipleOf(3, number)) {
return "Fizz";
}
return "Buzz";
}
}
private boolean isMultipleOf(int divisor, int number) {
return number % divisor == 0;
}
}

View Slide

2. A new requirement!
30
If it is a multiple of 7, say “Bang”
@Test
public void multiplesOfSeven() {
assertEquals("Bang", game.say(7));
assertEquals("Bang", game.say(14));
}
return "FizzBuzz";
}
return "Fizz";
}
return "Buzz";
}
}
}
}
Can we implementing by adding
new classes, with no modification
to existing classes?

View Slide

5. I don’t see a way!
31
So: Disable the new test
and refactor until you can
return "FizzBuzz";
}
return "Fizz";
}
return "Buzz";
}
}
}
}
String response = "";
response += "Fizz";
}
response += "Buzz";
}
if (response.isEmpty()) {
}
return response;
}
}
}

View Slide

Keep going…
32
response += "Fizz";
}
response += "Buzz";
}
}
return response;
}
}
}
response += sayFizz(number);
response += sayBuzz(number);
}
return response;
}
private String sayBuzz(int number) {
return "Buzz";
}
return "";
}
private String sayFizz(int number) {
return "Fizz";
}
return "";
}

View Slide

Keep going…
33
response += sayFizz(number);
response += sayBuzz(number);
}
return response;
}
private String sayBuzz(int number) {
return "Buzz";
}
return "";
}
private String sayFizz(int number) {
return "Fizz";
}
return "";
}
response += sayWord(number, 3, "Fizz");
response += sayWord(number, 5, "Buzz");
}
return response;
}
private String sayWord(int number, int divisor, String word) {
if (isMultipleOf(divisor, number)) {
return word;
}
return "";
}

View Slide

Almost there…
34
}
return response;
}
return word;
}
return "";
}
response += new WordRule(3, "Fizz").say(number);
response += new WordRule(5, "Buzz").say(number);
}
return response;
}
}
public class WordRule {
private final int divisor;
private final String word;
public WordRule(int divisor, String word) {
this.divisor = divisor;
this.word = word;
}
return word;
}
return "";
}
}
}

View Slide

Refactoring
done
35
private List rules;
public FizzBuzzGame(List rules) {
this.rules = rules;
}
for (WordRule rule: rules) {
response += rule.say(number);
}
}
return response;
}
}
@BeforeEach
game = new FizzBuzzGame(List.of(
new WordRule(3, "Fizz"),
new WordRule(5, "Buzz")
));
}
}
return response;
}
return word;
}
return "";
}

View Slide

There!
36
@BeforeEach
new WordRule(5, "Buzz")
));
}
@BeforeEach
new WordRule(5, "Buzz"),
new WordRule(7, "Bang")
));
}

View Slide

Applying the OCP at work
37

View Slide

}
if (inventoryService.checkAvailability(command.getItem()) == NOT_AVAILABLE) { // 󰍹
}
cart.addItem(command.getItem()); // 󰍽
Item todaysGiftItem = giftItemService.getTodaysGiftItem(); // 󰍼
}
if (fraudDetectionService.looksSuspicious(cart)) { // 󰍶
}
cartRepository.update(cart); // 󰍵
}
38
How to fix this?!
🤔🤔
🤔

View Slide

Sources of ideas:

View Slide

Sketching at a whiteboard…
40
Check inventory
Add bought
item
Add gift item
Fraud check
Persist changes
An OO perspective: these
could all be decorators
An FP perspective: these
could all be “functions”

View Slide

Let’s try with functions
It’s the zeitgeist…
41
We can model a service as a function from command to result. In math notation:
addItemToCart: AddItemToCartCommand → AddItemToCartResponse
In Java:
Function addItemToCart;
Functions can be composed: (f ○ g)(x) = f(g(x))
In Java:
Our services will be composed of many small functions
f.andThen(g)

View Slide

@Configuration
public class AddItemToCartServiceConfig {
@Autowired private InventoryService inventoryService;
@Autowired private GiftItemService giftItemService;
@Autowired private CartRepository cartRepository;
@Autowired private FraudDetectionService fraudDetectionService;
@Autowired private AlertService alertService;
@Bean
public Function addItemToCartService() {
Function checkInventory = new CheckInventory(inventoryService);
Function addItemToCart = new AddItemToCart();
Function addGiftItem = new AddGiftItem(giftItemService);
Function fraudCheck = new FraudCheck(fraudDetectionService, alertService);
Function persistChanges = new PersistChanges(cartRepository);
return checkInventory
.andThen(addItemToCart)
.andThen(addGiftItem)
.andThen(fraudCheck)
.andThen(persistChanges)
;
}
}

View Slide

Function addItemToCart = new AddItemToCart();
@Test
void addItem_ok() {
Item previousItem = new Item("a tv");
Item addedItem = new Item("a book");
Cart cart = new Cart().withItem(previousItem);
AddItemToCartCommand command = new AddItemToCartCommand(cart, addedItem);
AddItemToCartResult addItemToCartResult = addItemToCart.apply(command);
assertThat(cart.getItems()).containsExactly(previousItem, addedItem);
assertThat(addItemToCartResult).isEqualTo(AddItemToCartResult.ok());
}

View Slide

Unless we are ﬂuent, we will not
be able to do this at work!
44
44

View Slide

● We should refactor our code towards composition
● We will never be able to apply this in practice
unless we achieve ﬂuency
● A good way to achieve ﬂuency is by doing and
repeating exercises
45

View Slide

Start getting the OCP under your fingers today
46
● Choose a kata from the Kata-log: https://kata-log.rocks/
● Solve it
● Invent a new requirement
● Apply the OCP kata rules
● Do it again;
● try different ways to make your code composable

View Slide

Resources
47
● The OCP kata repository https://github.com/xpmatteo/ocp-kata
● How to organize a Coding Dojo https://leanpub.com/codingdojohandbook
● Code Retreats are awesome, look for one near you https://twitter.com/coderetreat
● A well-organized repository of examples: https://kata-log.rocks/
● Freeman & Pryce are very good at evolving a composable set of objects to
express a complex domain:
https://www.infoq.com/presentations/design-principles-code-structures/

View Slide

Thanks for listening
Matteo Vaccari
Grumpy Developer
[email protected]
48

View Slide

Accelerate development with simple design - ShareIT

Accelerate development with simple design - ShareIT

Matteo Vaccari

More Decks by Matteo Vaccari

Other Decks in Technology

Featured

Transcript