Finding the way to Design Patterns : more SOLID

So continuing into the process of finding our way into design patterns from my last post , we will try and unfold SOLID a bit more. Some of the SOLID principle interpretations and applications can be very subjective and a matter of debate. How do you know the classes that you wrote have adhered to the Single Responsibility Principle ? Is there a way to determine ? What does Single Responsibility exactly mean?  How far do you try and take these things…blah ..blah.

There needs to be a balance in everything of course.One needs to find a mid way between over-engineering and under-engineering. We need to create small classes with very few cohesive/related functions without getting carried away by having so many classes that we cannot manage those either. At the same time , understanding exactly how to create classes with just one relevant behavior or few cohesive functions can get tricky. It’s important to ask the question while writing a class , what is it that will potentially change in this class later , that can be re-factored into a separate class , so minimal changes / or no changes need to be made to the existing implementation when the change needs to be made.

It’s important to ask the question while writing a class , what is it that will potentially change in this class later , that can be re-factored into a separate class , so minimal changes / or no changes need to be made to the existing implementation when the change needs to be made.

If we take the Logging example that we discussed in the previous post , we discussed three functions a logger can do. Initializing a medium to log , Formatting to the medium itself  and Writing to the medium . So, they all look like related functions don’t they ? So they all can go in one class , which is a violation of SRP . If we take one step further into re-factoring  perhaps it’s easy to recognize right away that there are different mediums to log , each requires a different method to write to itself. So we create separate classes for the medium . Yes , we applied SRP here.

What about formatting ?  Can formatting change ? Yes, it can . Say we need to add a new logging medium called Mobile Device. To the mobile device , you want to send text messages whenever severe conditions occur. Doesn’t the format of what goes into a database differ from a mobile device ?  Also , later down the line the potential users of our Logger may require that they want the format of the message a little different. Now if we did not separate the format function into it’s own class , we have it as part of the class that writes to the medium or worse as part of the Logger class. Logger class is actually our client facing class that the client would use to log messages . Just to change  formatting , we have to go and change this Logger class or the medium classes.

At this point we need to consider  whether it’s worth writing something like this:

   1:  interface IFormatter {
   3:  public string Format( string message );
   5:  }

and the logger could do something like this :

   1:  public class Logger{
   3:  public Write( IFormatter formatter){}
   5:  }

Or let’s go couple of steps further along these lines,

   1:  public interface ILogMedium{
   3:  void Write(String Message);
   5:  }

   1:  public class LogToDatabase : ILogMedium{
   3:  public void Write(string message){
   5:  // medium specific logging
   7:  }
   9:  }

   1:  public class Logger{
   3:  ILogMedium _logTodb;
   5:  IFormatter _formatter;
   7:  public void Logger( ILogMedium logToMedium,  IFormatter formatter )
   9:  {
  11:  _logTodb = DBMediumProvider.Create(); // DBMediumProvider could be a creation class
  13:  _formatter = DBFormatProvider.Create(); // DBFormatProvider could be a creation class
  15:  }
  17:  public Write(String message){
  19:  _logTodb.Write( _formatter.Format(message) );
  21:  }
  23:  }

Please note : The code above is not a working solution. It is only like pseudo code to demonstrate the thought process .

The advantage of the above is we kept the formatter completely separate from the medium , as well as the Logger class. This allows us to plug in new mediums , formatters and configure them based on our needs. Also , if there are bugs it’s easier to fix a specific class as opposed to one big class which could potentially break other functions.

This brings us to the Open Closed principle , which is the next one and the ‘O’ in SOLID as we all know.

A consistent use of SRP can lead to OCP , which simply states: A class should be open for extension but closed for changes. This does not mean that classes should be completely sealed for change , it means that the class should be in a state where only bug fixes should be made and new functions should be added via new classes , minimizing implementation changes to the existing classes.

Words should not be taken literally here : once you wrote the class does not mean that it cannot be changed at all : however we should get to a point that , when behavior changes in predictable ways, you should not have to make several changes into a single class or several classes in the system. An ideal situation would be where you achieve the change by adding new class / code rather than changing existing code . For anyone who has been in programming for a few years supporting production systems , this will make a lot of logical sense.

Whatever we discussed above with Logger example with reference to SRP will apply to OCP as well , because OCP can be achieved by applying SRP consistently. So had we written the formatting in the Logger or the individual medium classes we would not be able to add new formatters or change existing formatting without changing the Logger or the mediums classes , plus mix and match formatting with mediums . The way we achieved OCP with Logger example is we gave the Logger a Single Responsibility of writing to the medium. We gave the Medium classes a Single Responsibility of initializing / creating the medium and specifically write to that medium as well. And then OCP came into effect when we made it possible for new formatters to be added to the system by simply implementing the interface IFormatter and adding that class to the system as a plugin. So , when a user wants to use the new Formatter , she can do it through the configuration system and that formatter will get automatically used which needs to be implemented through some creation classes of course , which is a separate topic – an example is Factory Method pattern.

Several design patterns use the SRP and OCP , and following the above two will put you in the mode of clean and efficient code . Some popular patterns like Strategy , Factory are all based on OCP . We will continue with this discussion in the next post , happy programming !

Few references :

Wikipedia definition Open-Closed

Interesting read on OCP by Jon Skeet

6 thoughts on “Finding the way to Design Patterns : more SOLID”

  1. I just wanted to jot down a remark so as to say thanks to you for all of
    the fabulous information you are giving out on this site.
    My long internet look up has at the end of the
    day been recognized with useful tips to talk about with my family
    and friends. I would repeat that we readers actually are really lucky to dwell
    in a really good site with many special people with insightful concepts.

    I feel somewhat lucky to have encountered your
    webpage and look forward to some more awesome minutes reading here.
    Thanks a lot once again for a lot of things.

  2. I love your blog..very nice colors & theme. Did you design this website yourself or did
    you hire someone to do it for you? Plz respond as I’m looking to design my own blog
    and would like to find out where u got this from. cheers

  3. Greetings I am so delighted I found your blog page, I really found you by mistake, while I was looking on Yahoo for something else, Anyhow
    I am here now and would just like to say thanks for a tremendous post and a all round entertaining blog (I
    also love the theme/design), I don’t have time to go through it all at the moment but I have book-marked it and also added in your RSS feeds, so when I have time I will be back to read more, Please do keep
    up the excellent b.

  4. Hey just wanted to ggive you a quick heads up. The words in your content
    seem tto bee running off tthe screen iin Ie.
    I’m not sure if this is a formatting issue or something to do
    with browser compatibility but I thought I’d post to let you know.

    The design and style look great though! Hopee you geet the issue resolved soon. Kudos

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s