Design Patterns in the 21st Century - Samir Talwar

Design Patterns
in the 21st Century
15th October 2014
@SamirTalwar

What do you want
from me?
I want you to stop using design patterns.

What do you want
from me?
I want you to stop using design patterns…
like it’s 1999.

The elements of this language are entities
called patterns. Each pattern describes a
problem that occurs over and over again in our
environment, and then describes the core of the
solution to that problem, in such a way that you
can use this solution a million times over,
without ever doing it the same way twice.
– Christopher Alexander

And now, an aside, on
functional programming.

int courses = 3;
Course dessert =
prepareCake.madeOf(chocolate);
Preparation prepareCake = new Preparation() {
@Override
public Course madeOf(Ingredient mmmmm) {
return
new CakeMix(eggs, butter, sugar)
.combinedWith(mmmmm);
}
};

Preparation prepareCake = new Preparation() {
@Override
public Course madeOf(Ingredient mmmmm) {
return
}
};
Preparation prepareCake =
mmmmm ->

mmmmm ->
Mix mix = new CakeMix(eggs, butter, sugar);
mix::combinedWith;

Mix mix = new CakeMix(eggs, butter, sugar);
mix::combinedWith;
Course combinedWith(Ingredient);
@FunctionalInterface
interface Preparation {
Course madeOf(Ingredient mmmmm);
}

The
Abstract Factory
pattern

public interface Bakery {
Pastry bakePastry(Topping topping);
Cake bakeCake();
}
public class DanishBakery implements Bakery {
@Override
public Pastry bakePastry(Topping topping) {
return new DanishPastry(topping);
}
@Override
public Cake bakeCake() {
return new Æblekage(); // mmmm, apple cake…
}
}
Abstract Factory

public interface Bakery {
Pastry bakePastry(Topping topping);
}
@Override
}
}
Abstract Factory

Abstract Factory
@Override
}
}
Bakery danishBakery = topping ->
new DanishPastry(topping);
Bakery danishBakery = DanishPastry::new;

package java.util.function;
/**
* Represents a function that
* accepts one argument and produces a result.
*
* @since 1.8
*/
public interface Function<T, R> {
/**
* Applies this function to the given
argument.
*/
R apply(T t);
...
}
Abstract Factory

public class DanishBakery
implements Function<Topping, Pastry> {
@Override
public Pastry apply(Topping topping) {
}
}
Function<Topping, Pastry> danishBakery
= topping ->
new DanishPastry(topping);
Function<Topping, Pastry> danishBakery
= DanishPastry::new;
Abstract Factory

interface Fire {
<T> Burnt<T> burn(T thing);
}
interface Oven {
Food cook(Food food);
}
class WoodFire implements Fire { ... }
class MakeshiftOven
extends WoodFire
implements Oven {
@Override public Food cook(Food food) {
Burnt<Food> nastyFood = burn(food);
return nastyFood.scrapeOffBurntBits();
}
}
Adapter

interface Fire {
<T> Burnt<T> burn(T thing);
}
interface Oven {
}
class MakeshiftOven implements Oven {
private final Fire fire;
public MakeshiftOven(Fire fire) { /* ... */ }
Burnt<Food> nastyFood = fire.burn(food);
}
}
Adapter

interface Oven {
}
Oven oven = new MakeshiftOven(fire);
Food bakedPie = oven.cook(pie);
Adapter

interface Oven {
}
}
}
Adapter

}
}
Oven oven = food -> {
};
Adapter

Oven oven = food -> {
Adapter
};
Oven oven = food ->
fire.burn(food).scrapeOffBurntBits();

Oven oven = food ->
fire.burn(food).scrapeOffBurntBits();
// Do *not* do this.
Function<Food, Burnt<Food>> burn
= fire::burn;
Function<Food, Food> cook
= burn.andThen(Burnt::scrapeOffBurntBits);
Oven oven = cook::apply;
Adapter

package java.util.concurrent;
/**
* An object that executes
* submitted {@link Runnable} tasks.
*/
public interface Executor {
void execute(Runnable command);
}
Adapter

}
Executor executor = ...;
Stream<Runnable> tasks = ...;
tasks.forEach(executor);
Adapter

public interface Stream<T> {
...
void forEach(Consumer<? super T> action);
...
}
public interface Consumer<T> {
void accept(T t);
...
}
Adapter

}
public interface Consumer<T> {
void accept(T t);
}
Executor executor = ...;
Stream<Runnable> tasks = ...;
tasks.forEach(task -> executor.execute(task));
tasks.forEach(executor::execute);
/

The
Chain of Responsibility
pattern

@Test public void whoAteMyPie() {
PieEater alice = PieEater.whoLoves(APPLE);
PieEater bob = PieEater.whoLoves(BLUEBERRY);
PieEater carol = PieEater.whoLoves(CHERRY);
alice.setNext(bob);
bob.setNext(carol);
alice.give(blueberryPie);
assertThat(bob, ate(blueberryPie));
}
Chain of
Responsibility

public final class HitCounterFilter implements Filter {
private FilterConfig filterConfig = null;
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
}
public void destroy() {
this.filterConfig = null;
}
public void doFilter
(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
if (filterConfig == null)
return;
Counter counter =
(Counter)filterConfig.getServletContext().getAttribute("hitCounter");
StringWriter sw = new StringWriter();
PrintWriter writer = new PrintWriter(sw);
writer.println("The number of hits is: " + counter.incCounter());
writer.flush();
filterConfig.getServletContext().log(sw.getBuffer().toString());
chain.doFilter(request, response);
}
}
Chain of
Responsibility

public final class HitCounterFilter
implements Filter {
// init and destroy
public void doFilter(
ServletRequest request,
ServletResponse response,
FilterChain chain) {
int hits = getCounter().incCounter();
log(“The number of hits is ” + hits);
}
}
Chain of
Responsibility

public final class SwitchEncodingFilter
implements Filter {
// init and destroy
request.setEncoding(“UTF-8”);
}
}
Chain of
Responsibility

public final class AuthorizationFilter
implements Filter {
// init and destroy
if (!user().canAccess(request))
throw new AuthException(user);
}
}
Chain of
Responsibility

Chain of
Responsibility
Ick.
So much mutation.
Where’s the start?
What happens at the end?

PieEater carol = PieEater.atTheEnd()
.whoLoves(CHERRY);
PieEater bob = PieEater.before(carol)
.whoLoves(BLUEBERRY);
PieEater alice = PieEater.before(bob)
.whoLoves(APPLE);
}
Chain of
Responsibility

Chain<PieEater> carol =
Chain.endingWith(PieEater.whoLoves(CHERRY));
Chain<PieEater> bob =
Chain.from(PieEater.whoLoves(BLUEBERRY))
.to(carol);
Chain<PieEater> alice =
Chain.from(PieEater.whoLoves(APPLE))
.to(bob);
}
Chain of
Responsibility

Chain<PieEater> pieEaters =
Chain.from(alice)
.to(Chain.from(bob)
.to(Chain.endingWith(carol)));
pieEaters.find(person -> person.loves(BLUEBERRY))
.give(blueberryPie);
}
Chain of
Responsibility

Chain<PieEater> pieEaters =
Chain.from(alice)
.to(Chain.from(bob)
Chain of
Responsibility
.to(Chain.endingWith(carol)));
(cons alice (cons bob (cons carol nil)))

Chain of
Responsibility
(cons alice (cons bob (cons carol nil)))

Stream<PieEater> pieEaters
= Stream.of(alice, bob, carol);
pieEaters
.findAny(person -> person.loves(BLUEBERRY))
.get()
.give(blueberryPie);
}
Chain of
Responsibility

I want you to use design patterns…
like it’s 1958.

Credits
Bakery, by Boris Bartels
Just baked, by Sergio Russo
cherry pie with crumble topping, by Ginny
This presentation is licensed under
Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)

Design Patterns in the 21st Century - Samir Talwar

More Related Content

Similar to Design Patterns in the 21st Century - Samir Talwar (20)

More from JAXLondon2014 (20)

Recently uploaded (20)

Design Patterns in the 21st Century - Samir Talwar