Why? When To? Software Design Patterns. Interesting topic right?

Software Design Patterns Explained


Let’s 1st talk about software design patterns. Software design patterns can be defined as recurring solutions to common problems in software design. You might be wondering how does your application work without design patterns if this’s so important. The main point to understand is that if your application doesn’t contain any errors it will work like a charm. But working application does not mean that your application’s codebase is up to the industry standard. Just writing code is not gonna help you but writing the code right way will help you. GOF A.K.A. Gang Of Four(Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides) are considered to be the gurus of software design patterns. They introduced 23 design patterns which fall into three types. Creational design patterns, Structural design patterns and behavioural design patterns. See the list below

1. Creational

Creational patterns are ones that create objects for you, rather than having you instantiate objects directly. This gives your program more flexibility in deciding which objects need to be created for a given case.

  • Abstract Factory groups object factories that have a common theme.
  • Builder constructs complex objects by separating construction and representation.
  • Factory Method creates objects without specifying the exact class to create.
  • Prototype creates objects by cloning an existing object.
  • Singleton restricts object creation for a class to only one instance.


2. Structural
These concern class and object composition. They use inheritance to compose interfaces and define ways to compose objects to obtain new functionality.

  • Adapter allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
  • Bridge decouples an abstraction from its implementation so that the two can vary independently.
  • Composite composes zero-or-more similar objects so that they can be manipulated as one object.
  • Decorator dynamically adds/overrides behaviour in an existing method of an object.
  • Facade provides a simplified interface to a large body of code.
  • Flyweight reduces the cost of creating and manipulating a large number of similar objects.
  • Proxy provides a placeholder for another object to control access, reduce cost, and reduce complexity.


3. Behavioral

Most of these design patterns are specifically concerned with communication between objects.

  • Chain of responsibility delegates commands to a chain of processing objects.
  • Command creates objects which encapsulate actions and parameters.
  • Interpreter implements a specialized language.
  • Iterator accesses the elements of an object sequentially without exposing its underlying representation.
  • Mediator allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
  • Memento provides the ability to restore an object to its previous state (undo).
  • Observer is a publish/subscribe pattern which allows a number of observer objects to see an event.
  • State allows an object to alter its behavior when its internal state changes.
  • Strategy allows one of a family of algorithms to be selected on-the-fly at runtime.
  • Template method defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior.
  • Visitor separates an algorithm from an object structure by moving the hierarchy of methods into one object.

Above list is extracted from Wikipedia.


MVC is one of the most used design pattern but it’s not under above 3 categories. Also you will find extension to MVC. Good place to start reading about would be Wikipedia. I’m planning to write a post about MVC, so for the time being let me stop at this point.


Why Use Software Design Patterns


Let’s talk about why you should use software design patterns in your application.

  • Speed up the development process by proven solutions
  • End up having standard & maintainable codebase
  • Robust system design than ad-hoc system design
  • It’s easy for developers to communicate since patterns are well defined
  • Correct use of OOP concepts
  • Well-tested & well-documented solutions for common problems
  • Easy to accommodate change
  • Nothing to innovative, Just reuse


When To Use Software Design Patterns


One of the hardest question is which software design pattern to be applied when. Usually there isn’t a pattern to figure out which design pattern should be used. It comes through the understanding & experience of using design patterns correctly. You will have to study application and read a book or two. A good start would be Head First Design Patterns from O’Reilly. There are a lot of books but this one is recommend for beginners. Also I found below two links important.

How do you know when to use design patterns?

How do you apply design patterns?

That’s it. Good luck with software design patterns & your feedback is highly appreciated.

software design patterns GOF 23 Patterns

Be Sociable, Share!