Software design patterns

Design patterns are solutions to recurring problems; guidelines on how to tackle certain problems.

Conformity to patterns is not a measure of goodness.

Ralph Johnson, Coauthor of the Design Patterns classic

When I see patterns in my programs, I consider it a sign of trouble. The shape of a program should reflect only the problem it needs to solve. Any other regularity in the code is a sign, to me at least, that I'm using abstractions that aren't powerful enough - often that I'm generating by hand the expansions of some macro that I need to write.

Paul Graham, Lisp hacker and venture capitalist

Caution

Design patterns are not a silver bullet to all your problems.

Do not try to force them; bad things are supposed to happen, if done so. Keep in mind that design patterns are solutions to problems, not solutions finding problems; so don't overthink.

If used in a correct place in a correct manner, they can prove to be a savior; or else they can result in a horrible mess of a code.

Do we need them all? Maybe there are a few principles we may use instead?

As to methods there may be a million and then some, but principles are few. The man who grasps principles can successfully select his own methods. The man who tries methods, ignoring principles, is sure to have trouble.

How to create it

Simple factory simply generates an instance for client without exposing any instantiation logic to the client.

Real world example

Consider, you are building a house and you need doors. It would be a mess if every time you need a door, you put on your carpenter clothes and start making a door in your house. Instead you get it made from a factory.

Use when creating an object is not just a few assignments and involves some logic, it makes sense to put it in a dedicated factory instead of repeating the same code everywhere.

classPizza(object):""" Implements interface. """def__init__(self):self._price=Nonedefget_price(self):returnself._priceclassHamAndMushroomPizza(Pizza):def__init__(self):self._price=8.5classDeluxePizza(Pizza):def__init__(self):self._price=10.5classHawaiianPizza(Pizza):def__init__(self):self._price=11.5classPizzaFactory(object):@staticmethoddefcreate_pizza(pizza_type):ifpizza_type=='HamMushroom':returnHamAndMushroomPizza()elifpizza_type=='Deluxe':returnDeluxePizza()elifpizza_type=='Hawaiian':returnHawaiianPizza()if__name__=='__main__':forpizza_typein('HamMushroom','Deluxe','Hawaiian'):pizza=PizzaFactory.create_pizza(pizza_type=pizza_type)print('Price of {pizza_type} is {price}'.format(pizza_type=pizza_type,price=pizza.get_price()))# Price of HamMushroom is 8.5# Price of Deluxe is 10.5# Price of Hawaiian is 11.5

Real world example

Consider the case of a hiring manager. It is impossible for one person to interview for each of the positions. Based on the job opening, she has to decide and delegate the interview steps to different people.

Useful when there is some generic processing in a class but the required sub-class is dynamically decided at runtime. Or putting it in other words, when the client doesn't know what exact sub-class it might need.

A factory of factories; a factory that groups the individual but related/dependent factories together without specifying their concrete classes.

Abstract Factory has more then one factory methods.
Each of the methods creates a different kind of object.
We can select methods behavior by selecting particular factory.

Abstract Factory is used when you need to create a family of objects that do some work together.

classObstacle:defaction(self):passclassCharacter:definteractWith(self,obstacle):passclassKitty(Character):definteractWith(self,obstacle):print("Kitty has encountered a",obstacle.action())classKungFuGuy(Character):definteractWith(self,obstacle):print("KungFuGuy now battles a",obstacle.action())classPuzzle(Obstacle):defaction(self):return"Puzzle"classNastyWeapon(Obstacle):defaction(self):return"NastyWeapon"# The Abstract FactoryclassGameElementFactory:defmakeCharacter(self):passdefmakeObstacle(self):pass# Concrete factoriesclassKittiesAndPuzzles(GameElementFactory):defmakeCharacter(self):returnKitty()defmakeObstacle(self):returnPuzzle()classKillAndDismember(GameElementFactory):defmakeCharacter(self):returnKungFuGuy()defmakeObstacle(self):returnNastyWeapon()classGameEnvironment:def__init__(self,factory):self.factory=factoryself.character=factory.makeCharacter()self.obstacle=factory.makeObstacle()defplay(self):self.character.interactWith(obstacle=self.obstacle)if__name__=='__main__':g1=GameEnvironment(KittiesAndPuzzles())g2=GameEnvironment(KillAndDismember())g1.play()# Kitty has encountered a Puzzleg2.play()# KungFuGuy now battles a NastyWeapon

Real world example

Based on your needs you might get a wooden door from a wooden door shop, iron door from an iron shop or a PVC door from the relevant shop. Plus you might need a guy with different kind of specialities to fit the door, for example a carpenter for wooden door, welder for iron door etc. As you can see there is a dependency between the doors now, wooden door needs carpenter, iron door needs a welder etc.

Use when there are interrelated dependencies with not-that-simple creation logic involved.

Allows you to create different flavors of an object while avoiding constructor pollution. Useful when there could be several flavors of an object. Or when there are a lot of steps involved in creation of an object.

Instead of using numerous constructors use only one + methods to modify it.

Imagine you are at Hardee's and you order a specific deal, lets say, "Big Hardee" and they hand it over to you without any questions; this is the example of simple factory. But there are cases when the creation logic might involve more steps. For example you want a customized Subway deal, you have several options in how your burger is made e.g what bread do you want? what types of sauces would you like? What cheese would you want? etc. In such cases builder pattern comes to the rescue.

Use when there could be several flavors of an object and to avoid the constructor telescoping. The key difference from the factory pattern is that; factory pattern is to be used when the creation is a one step process while builder pattern is to be used when the creation is a multi step process.

There can only be one president of a country at a time. The same president has to be brought to action, whenever duty calls. President here is singleton.

Use with caution

Singleton pattern is actually considered an anti-pattern and overuse of it should be avoided. It is not necessarily bad and could have some valid use-cases but should be used with caution because it introduces a global state in your application and change to it in one place could affect in the other areas and it could become pretty difficult to debug. The other bad thing about them is it makes your code tightly coupled plus it mocking the singleton could be difficult.

classSingleton(object):__instance=Nonedef__new__(cls,*args,**kwargs):ifcls.__instanceisNone:cls.__instance=super(Singleton,cls).__new__(cls,*args,**kwargs)returncls.__instanceif__name__=='__main__':instance1=Singleton()instance2=Singleton()# points to the same objectprint(instance1,instance2)# <__main__.Singleton object at 0x1032f1950> <__main__.Singleton object at 0x1032f1950>

Structure of it

Structural patterns are mostly concerned with object composition or in other words how the entities can use each other. Or yet another explanation would be, they help in answering "How to build a software component?"

Adapter

Adapter pattern lets you wrap an otherwise incompatible object in an adapter to make it compatible with another class.

Real world example

Consider that you have some pictures in your memory card and you need to transfer them to your computer. In order to transfer them you need some kind of adapter that is compatible with your computer ports so that you can attach memory card to your computer. In this case card reader is an adapter. Another example would be the famous power adapter; a three legged plug can't be connected to a two pronged outlet, it needs to use a power adapter that makes it compatible with the two pronged outlet. Yet another example would be a translator translating words spoken by one person to another.

Bridge

Bridge pattern is about preferring composition over inheritance. Implementation details are pushed from a hierarchy to another object with a separate hierarchy.

Real world example

Consider you have a website with different pages and you are supposed to allow the user to change the theme. What would you do? Create multiple copies of each of the pages for each of the themes or would you just create separate theme and load them based on the user's preferences? Bridge pattern allows you to do the second i.e.

Composite

Every organization is composed of employees. Each of the employees has the same features i.e. has a salary, has some responsibilities, may or may not report to someone, may or may not have some subordinates etc.

Decorator

Decorator pattern lets you dynamically change the behavior of an object at run time by wrapping them in an object of a decorator class.

Real world example

Imagine you run a car service shop offering multiple services. Now how do you calculate the bill to be charged? You pick one service and dynamically keep adding to it the prices for the provided services till you get the final cost. Here each type of service is a decorator.

Facade (façade)

If something is ugly, hide it inside an object.

Facade pattern provides a simplified interface to a complex subsystem.

This design pattern aggregates classes that implement the functionality of the subsystem but does not hide them completely. Should not add any new functionality, just simplify the access to a system.

Goal: make a software library easier to use, understand and test.

Real world example

How do you turn on the computer? "Hit the power button" you say! That is what you believe because you are using a simple interface that computer provides on the outside, internally it has to do a lot of stuff to make it happen. This simple interface to the complex subsystem is a facade.

Flyweight

It is used to minimize memory usage or computational expenses by sharing as much as possible with similar objects.

Real world example

Did you ever have fresh tea from some stall? They often make more than one cup that you demanded and save the rest for any other customer so to save the resources e.g. gas etc. Flyweight pattern is all about that i.e. sharing.

Proxy

Using the proxy pattern, a class represents the functionality of another class.

Relates to: State (or State provider), Surrogate. Proxy is used to control access to its implementation, while State allows you to change the implementation dynamically. Surrogate - uses for both (controlling access to implementation).

A Proxy is a design pattern that helps to decouple the client code from the object that the client code uses. Proxy acts like a real object but delegates all calls to the real object.

Real world example

Have you ever used an access card to go through a door? There are multiple options to open that door i.e. it can be opened either using access card or by pressing a button that bypasses the security. The door's main functionality is to open but there is a proxy added on top of it to add some functionality. Let me better explain it using the code example below.

How it behaves

It is concerned with assignment of responsibilities between the objects. What makes them different from structural patterns is they don't just specify the structure but also outline the patterns for message passing/communication between them. Or in other words, they assist in answering "How to run a behavior in software component?"

Chain of Responsibility

It helps building a chain of objects. Request enters from one end and keeps going from object to object till it finds the suitable handler.

Real world example

For example, you have three payment methods (A, B and C) setup in your account; each having a different amount in it. A has 100 USD, B has 300 USD and C having 1000 USD and the preference for payments is chosen as A then B then C. You try to purchase something that is worth 210 USD. Using Chain of Responsibility, first of all account A will be checked if it can make the purchase, if yes purchase will be made and the chain will be broken. If not, request will move forward to account B checking for amount if yes chain will be broken otherwise the request will keep forwarding till it finds the suitable handler. Here A, B and C are links of the chain and the whole phenomenon is Chain of Responsibility.

Command

Choosing the operation at runtime.

Allows you to encapsulate actions in objects. The key idea behind this pattern is to provide the means to decouple client from receiver.

Real world example

A generic example would be you ordering a food at restaurant. You (i.e. Client) ask the waiter (i.e. Invoker) to bring some food (i.e. Command) and waiter simply forwards the request to Chef (i.e. Receiver) who has the knowledge of what and how to cook. Another example would be you (i.e. Client) switching on (i.e. Command) the television (i.e. Receiver) using a remote control (Invoker).

Interpreter (TODO)

TODO

Iterator

It presents a way to access the elements of an object without exposing the underlying presentation.

Real world example

An old radio set will be a good example of iterator, where user could start at some channel and then use next or previous buttons to go through the respective channels. Or take an example of MP3 player or a TV set where you could press the next and previous buttons to go through the consecutive channels or in other words they all provide an interface to iterate through the respective channels, songs or radio stations.

Mediator

Mediator pattern adds a third party object (called mediator) to control the interaction between two objects (called colleagues). It helps reduce the coupling between the classes communicating with each other. Because now they don't need to have the knowledge of each other's implementation.

Real world example

A general example would be when you talk to someone on your mobile phone, there is a network provider sitting between you and them and your conversation goes through it instead of being directly sent. In this case network provider is mediator.

Memento

Memento pattern is about capturing and storing the current state of an object in a manner that it can be restored later on in a smooth manner.

Real world example

Take the example of calculator (i.e. originator), where whenever you perform some calculation the last calculation is saved in memory (i.e. memento) so that you can get back to it and maybe get it restored using some action buttons (i.e. caretaker).

Usually useful when you need to provide some sort of undo functionality.

State

Or State provide. See Proxy.

It lets you change the behavior of a class when the state changes.

Real world example

Imagine you are using some drawing application, you choose the paint brush to draw. Now the brush changes its behavior based on the selected color i.e. if you have chosen red color it will draw in red, if blue then it will be in blue etc.

Strategy

Strategy pattern allows you to switch the algorithm or strategy based upon the situation.

Real world example

Consider the example of sorting, we implemented bubble sort but the data started to grow and bubble sort started getting very slow. In order to tackle this we implemented Quick sort. But now although the quick sort algorithm was doing better for large datasets, it was very slow for smaller datasets. In order to handle this we implemented a strategy where for small datasets, bubble sort will be used and for larger, quick sort.

Template method

Template method defines the skeleton of how a certain algorithm could be performed, but defers the implementation of those steps to the children classes.

Defines the basis of an algorithm and enables successors to redefine some steps of the algorithm without changing its structure.

There is a method that calls some other methods. Some of these methods remain the same for different algorithms and some may be changed.

Real world example

Suppose we are getting some house built. The steps for building might look like

Prepare the base of house

Build the walls

Add roof

Add other floors

The order of these steps could never be changed i.e. you can't build the roof before building the walls etc but each of the steps could be modified for example walls can be made of wood or polyester or stone

Visitor

Visitor pattern lets you add further operations to objects without having to modify them.

Real world example

Consider someone visiting Dubai. They just need a way (i.e. visa) to enter Dubai. After arrival, they can come and visit any place in Dubai on their own without having to ask for permission or to do some leg work in order to visit any place here; just let them know of a place and they can visit it. Visitor pattern lets you do just that, it helps you add places to visit so that they can visit as much as they can without having to do any legwork.