Single Responsibility Principle Simple Example

faisol-riza — Mon, 02 Mar 2020 03:58:24 +0000

(Cover Photo by David McEachan from Pexels)

Good Day, guys!
Single Responsibility Principle is the first part of the SOLID principle. In this article, I’ll try to explain the Single Responsibility Principle in with a simple example. So, we can get the philosophy of it. Then we can implement it in our daily coding activity.

However, as a formality. Firstly, I will state it’s the definition from Wikipedia. Even though it is a little bit abstract, but it is still worth to get a theoretical definition of the Single Responsibility Principle.

In Wikipedia, The Single Responsibility Principle means:

“The single responsibility principle is a computer programming principle that states that every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class, module or function. All its services should be narrowly aligned with that responsibility”

We were all beginner and maybe it needs a little extra effort to understand the definition above.

So, let’s jump to our illustration of the Single Responsibility Principle.

Let’s say that once upon a time, there was a pharaoh. He wanted to build a pyramid. He had a great and smart commander. He ordered his commander to build one.

Then the commander started to design the pyramid, he made the blueprint of the building structure. After that, he contacted the material supplier to provide all material that he needed. After ensuring all work well, he started to manage the labour to build the pyramid.

From this illustration above, we know how the Single Responsibility Principle was violated. Since the commander has all responsibility, from the design, arrange material supply and manage the labour. Of course, it was still possible to run. However, it wasn’t very adaptive and flexible. Moreover, it can cause high complexity.

Afterwards, the commander read a paper from Uncle Bob (Robert C Martin) about software design principle. And he interested to implement the Single Responsibility Principle. He hired several managers, and breakdown the responsibilities to departments. Each manager led a department and responsible for specific jobs.

(Photo by fauxels from Pexels)

Yeah, the commander implemented a basic form of Single Responsibility Principle. Now, do you get the picture of the Single Responsibility Principle? Give me your own words to define it. And please do not stuck to Wikipedia definition, but we make it as a reference.

Next, let’s try to translate it to simple pseudocode.

Before implementing the Single Responsibility Principle

Public class main(){
    //Design works
    decimal pyramidLength;
    decimal pyramidWidth;
    decimal pyramidHeight;
    decimal totalAreaPyramid = CalculatePyramidArea(pyramidLength, pyramidWidth, pyramidHeight);

    decimal materialSupply = CalculateMaterialSupply(totalAreaPyramid);

    int totalLabor = CalculateTotalLabor(totalAreaPyramid);

    return Build(totalAreaPyramid, materialSupply, totalLabor);
}

After implementing the Single Responsibility Principle

Public class main(){
    //Design responsibility
    BuildingBluePrint PyramidDesign = new BuildingBluePrint(BuildingTypeEnum.Pyramid, pyramidLength, pyramidWidth, pyramidHeight);

    //Material supply responsibility
    BuildingMaterial PyramidMaterial = new MaterialBuilding(PyramidDesign);

    //Labor management responsibility
    BuildingContstructionLabor PyramidLabor = new PyramidLabor(PyramidDesign);

    //Let’s build the pyramid
    Return Build(PyramidDesign, PyramidMaterial, PyramidLabor);
}

The code above is not working code, I just try to give the picture of the Single Responsibility Principle. Please let me know if you have any feedback, both for my explanation or for may pseudo code.
Next, I will continue with my second article about the Open Closed Principle.

Thanks.

Difference Between Recursion and Iteration

faisol-riza — Mon, 20 Jan 2020 04:32:05 +0000

What is the difference between recursion and iteration? Both recursion and iteration are running instruction repeatedly. However, they are totally different. At the first time I was also a little bit confuse. But after read some article and reference, finally I understand. I will summarize it for you and make it very simple to be understood.

Recursion is call a function from inside it's function. This will make a repetitive process.

We can take example a film titled "Inception" as a recursion process. In this film, the actor Leonardo DiCaprio as Dominic Cobb, and his team must go inside into someone's dream. If the mission is not succeed, they must go into deeper dream. And it happen repeatedly until they accomplish the mission.

So recursion is somehow go deeper inside by repeatedly doing such a function from inside the function.

Next, what is iteration? Even though it has similarity with recursion in term of repeated. But it has different meaning. Iteration is doing instruction repeatedly within a function.

For example, when our mom are making soup with love, she cuts the carrots repeatedly until they all be cut. So, she will chop the carrots for more than once, in order to make delicious soup.

I hope my explanation can be understood in a very easy way.

DEV Community: faisol-riza

Single Responsibility Principle Simple Example

Difference Between Recursion and Iteration