An introduction to software design patterns that emphasises the relationship between software engineering and other creative domains when it comes to distilling the wisdom of experience.

1. I’m
sensing a
pattern
Tony Veale 2018

2. Ssshhhh
Great artists
steal …
Help!
When we refer to the idea
of “genre” or “style” or
“paradigm” in Art, Science
or Commercial Design, we
are referring to the idea of
Design Patterns …
These codify the unspoken
norms of good design, and
apply in many disciplines.

3. Rene Magritte’s
Design Patterns
(1928)

4. How should
I organize
my classes?
Be Wise!
Use the
Luke.
Be Wise!
Use the
Luke.

8. … and threaten it
with imminent
destruction by an
inventive means.

11. We meet
again, Mr.
Bond …

14. Compartmentalize responsibility
Maximize coherence within
compartments
Minimize dependencies between
compartments
Reduce redundancy & inefficiency
Explicitly assign responsibilities
Orderly flow of information
Scalability & Extensibility

15. So
alone

16. Different parameterized
configurations of the same
class are instantiated to suit
different contexts and uses.

17. Flippin’
Nora, that’s
a Big ‘Un …
There can
be only one
silverback.

18. public interface Quantifiable extends Identifiable {
public int getQuantity();
public int addQuantity(int delta);
public int removeQuantity(int delta);
}
Let’s start by defining an Interface type for tracking
the ingredients in our restaurant’s pantry …
Clean
that
fridge!

19. public interface Manageable {
public Quantifiable lookup(String identifier);
public Quantifiable add(Quantifiable entry);
public void remove(Quantifiable entry);
}
Now add an Interface type for bringing all of this
stock together into a Manageable system …
Inventory
Control!

20. import java.util.Hashtable;
public class CentralPantry implements Manageable {
private Hashtable<String, Quantifiable> store = null;
private CentralPantry() {
store = new Hashtable<String, Quantifiable>();
}
}
We can now begin to implement our central pantry.
But why does our class require a private constructor?

21. private static CentralPantry cache = null;
public static synchronized CentralPantry getPantry()
{
if (cache == null)
cache = new CentralPantry();
return cache;
}
Only a class instance can call a private constructor.
So provide a static method to instantiate the class.
So use the
static method,
and not the
constructor

22. public class CentralPantry implements Manageable {
public static CentralPantry getPantry() {
return SingletonCache.ONE;
}
private static class SingletonCache {
public static final CentralPantry ONE
= new CentralPantry();
}
private CentralPantry() { … }
OR: We can exploit Java’s lazy evaluation of assignments
Java lazily loads classes only as they are needed …

23. static getInstance()
singletonOperations()
getSingletonData()
static uniqueInstance
singletonData
return uniqueInstance;
Here’s the
Singleton
pattern in a
nutshell.

24. P1
P2
P3
P4
P5 P6
P8
P7
P9
P0
P10
P11

25. When a class has a complicated,
multi-step set up procedure, and a
diversity of configuration options,
then it makes sense to define
another class, called a Builder,
whose responsibility is the
construction of new instances
of the more complex class.
Take, for
example, the
making of a
pizza …

26. public class Commodity implements Quantifiable {
private String identifier = null;
private int amount = 1;
public Commodity(String name) {
identifier = name;
}
public String getIdentifier() {
return identifier;
}
First, let’s create the most generic and reusable set of
classes and interfaces for our our example …
Continued overleaf …
Pizzas are
commodities

27. public int getQuantity() {
return amount;
}
public int addQuantity(int delta) {
amount += delta;
return amount;
}
public int removeQuantity(int delta) {
amount += delta;
return amount;
}
}
Implement
Quantifiable
interface

28. public interface Bakeable {
public void setDough(Quantifiable dough);
public void addSauce(Quantifiable sauce);
public void addTopping(Quantifiable topping);
}
Before defining a Pizza class, generalize to the category
of all bakeable commodities …
Pizzas implement
these methods

29. public class Pizza extends Commodity
implements Bakeable {
private Quantifiable dough = null, sauce = null;
Vector<Quantifiable> toppings
= new Vector<Quantifiable>();
public Pizza(String name) {
super(name);
}
Now we define Pizza as the class of bakeable commodities
Continued overleaf …

30. public void setDough(Quantifiable dough) {
this.dough = dough;
}
public void addSauce(Quantifiable sauce) {
this.sauce = sauce;
}
public void addTopping(Quantifiable topping) {
toppings.add(topping);
}
}
Implement Bakeable requirements for pizza variations

31. public interface Subcontractable {
public void buildSequence();
public void startProduct(String name);
public Commodity getProduct();
}
A subcontractor is a builder to which we delegate jobs.
Each subcontractor must implement Subcontractable …
Our pizza builders
will implement this

32. public interface Contractable {
public void setSubcontractor(Subcontractable
subcontractor);
public Commodity deliverContract();
}
A Contractor can form a contract with a subcontractor to
deliver on a contract for a commodity with a client ….
Think of the link
between a chef
and a sous chef

33. abstract public class PizzaBuilder
implements Subcontractable {
private Pizza pizza = null;
public void buildSequence() {
buildDough();
buildSauce();
buildToppings();
}
A PizzaBuilder is a subcontractable class that combines
specific dough, sauce and toppings to make a pizza
Continued overleaf …

34. public Commodity getProduct() {
return pizza;
}
public void startProduct(String name) {
pizza = new Pizza(name);
}
abstract public void buildDough();
abstract public void buildSauce();
abstract public void buildToppings();
}
Abstract methods must be implemented by specific builders

35. public class HawaiianBuilder extends PizzaBuilder {
public void buildDough() {
startProduct(“Hawaiian”);
((Bakeable)getProduct())
.setDough(new Commodity("thin crust"));
}
public void buildSauce() {
((Bakeable)getProduct())
.addSauce(new Commodity("marinara"));
}
public void buildToppings() {
Let’s look at a specific builder for a specific kind of pizza …
Continued overleaf …

36. public void buildToppings() {
((Bakeable)getProduct())
.addTopping(new Commodity("Mozzarella"));
((Bakeable)getProduct())
.addTopping (new Commodity("ham"));
((Bakeable)getProduct())
.addTopping (new Commodity("pineapple"));
}
}
A specific builder applies specific elements to the build

37. public class PizzaContractor implements Contractable {
private PizzaBuilder subcontractor = null;
public void setSubcontractor(Subcontractable
subcontractor) {
this.subcontractor = (PizzaBuilder)subcontractor;
}
public Commodity deliverContract() {
subcontractor.buildSequence();
return subcontractor.getProduct();
}
A Pizza Contractor delivers on a contract for a pizza
Continued overleaf …

38. public static void main(String[] args) {
PizzaBuilder souschef = new HawaiianBuilder();
Contractable chef = new PizzaContractor();
chef.setSubcontractor(souschef);
Commodity pizza = chef.deliverContract();
if (pizza.getIdentifier() == "Hawaiian")
System.out.println("Aloha!");
}
}
At last we create a contractor and a subcontractor for pizza
ALOHA!

39. ExpertBuilder
+startProduct()
+getProduct()
ExpertBuilder
+startProduct()
+getProduct()
Subcontractor
buildSequence()
Contractor
deliverContract()
Commodity
ExpertBuilder
+startProduct()
+getProduct()
for all aspects of scheme
subcontractor
.buildSequence();

41. Exemplar1
+startProduct()
+getProduct()
Exemplar1
+startProduct()
+getProduct()
Exemplar1
+startProduct()
+getProduct()
Exemplar1
+startProduct()
+getProduct()
Commodity
clone()
Contractor
prototype
deliverContract()
Exemplar1
clone()
ExemplarN
clone()
return prototype.clone();

42. public static void main(String[] args) {
Pizza hawaiian = new Pizza("Magnum P.I.");
hawaiian.setDough(new Commodity("thin crust"));
hawaiian.addSauce(new Commodity("barbecue"));
hawaiian.addTopping(new Commodity("ham"));
hawaiian.addTopping(new Commodity("mushroom"));
hawaiian.addTopping(new Commodity("pineapple"));
Let’s build a Hawaiian pizza directly, with No Builder class

43. Pizza sicilian = new Pizza("The Godfather");
sicilian.setDough(new Commodity("deep pan"));
sicilian.addSauce(new Commodity("spicy"));
sicilian.addTopping(new Commodity("salami"));
sicilian.addTopping(new Commodity("pepperoni"));
sicilian.addTopping(new Commodity("chilies"));
sicilian.addTopping(new Commodity("black olives"));
Now build another prototype pizza, with No Builder class

44. public Commodity clone() {
try {
return (Commodity)super.clone();
} catch (Exception e) {
return null;
}
}
In the Commodity class we define a method to “clone” a
commodity, catching any exceptions that are thrown …
A “clone” is a copy
of an object with the
same (==) field
values

45. public class CommodityContractor
implements Contractable {
private Commodity style = null;
public void setStyle(Commodity exemplar) {
this.style = exemplar;
}
public void setSubcontractor(Subcontractable sub) {};
public Commodity deliverContract() {
return style.clone();
}
}
We can simplify our Contractor classes greatly now …

46. CommodityContractor chef = new CommodityContractor();
chef.setStyle(sicilian);
Commodity myPizza = chef.deliverContract();
System.out.println(myPizza.getIdentifier());
chef.setStyle(hawaiian);
myPizza = chef.deliverContract();
System.out.println(myPizza.getIdentifier());
Let’s revisit our pizza-making example via our Prototypes
“Magnum P.I.”
“The
Godfather”

47. Notice how the Singleton, Builder
and Prototype patterns alter the
way we view class instantiation.
Where possible, we delegate this
responsilibity to experts who hide
(by encapsulation) the true
complexity of object creation.
I prefer my
pizza to be
made by an
expert!

48. CommodityContractor chef = new CommodityContractor();
chef.setStyle(sicilian);
Contractable chef = new PizzaContractor();
chef.setSubcontractor(hawaiianChef);
Notice how in both the Builder and Prototype
we use interfaces to minimize dependencies
between contractor and subcontractor …
We inject these dependencies late in the game

49. Some developers consider Dependency
Injection to be a design pattern in its own
right. What is clear is that it is a key part of
many other dependency-reducing patterns.
We call this
strategy
Dependency
Injection

50. When we want a family of related builders that construct
a thematically-consistent family of related commodities

51. A factory of
GUI widgets
for MAC OS
can replace
A factory of
GUI widgets
for Windows.

52. Factory_Style1
getPart1(), …,
getPartN(),
Factory_Style1
getPart1(), …,
getPartN(),
Factory_Style1
getPart1(), …,
getPartN(),
Factory
getPart1(), …,
getPartN(),
Consumer
factory
useParts()
Factory_Style_1
getPart1(), …,
getPartN(),
Factory_Style_N
getPart1(), …,
getPartN(),

53. public class PizzaFactory extends PizzaContractor {
public Commodity getPizza() {
return deliverContract();
}
public Commodity getSandwich() {
Pizza pie = (Pizza)deliverContract();
pie.setDough(new Commodity("crusty roll"));
return pie;
}
Let’s turn our Pizza maker into a Factory of Italian dishes
Continued overleaf …

54. public Commodity getCalzone() {
Pizza pie = (Pizza)deliverContract();
pie.setDough(new Commodity("folded crust"));
return pie;
}
public Commodity getLasagne() {
Pizza pie = (Pizza)deliverContract();
pie.setDough(new Commodity("lasanga sheets"));
return pie;
}
}
Add calzones and even lasagnes for good measure …

55. public static void main(String[] args) {
PizzaBuilder stylist = new HawaiianBuilder();
PizzaFactory factory = new PizzaFactory();
factory.setSubcontractor(stylist);
Commodity lunch = factory.getSandwich();
if (lunch.getIdentifier() == "Hawaiian")
System.out.println("The End");
}
}
Now our pizza factory makes thematically consistent dishes
The End