Software Design Principles DRY and KISS

In this article, I am going to explore software design principles and their benefits, why design principles are useful for us, and how to implement them in our daily programming. We will explore the DRY and KISS software design principles.

The DRY Principle – Don’t Repeat Yourself

DRY stand for "Don’t Repeat Yourself," a basic principle of software development aimed to reduce repetition of information. The DRY principle is stated as, “Every piece of knowledge or logic must have a single, unambiguous, representation within a system."

Violations of DRY:

“We enjoy typing” (or, “Wasting everyone’s time."): "We enjoy typing," means writing the same code or logic again and again. It will be difficult to manage the code and if the logic changes then we have to make changes in all the places where we have written the code, thereby wasting everyone's time.

How to Achieve DRY:

To avoid violating the DRY principle, divide your system into pieces. Divide your code and logic into smaller reusable units and use that code by calling it where you want. Don’t write lengthy methods, but divide logic and try to use the existing piece in your method.

DRY Benefits

Less code is good, it saves time and effort, is easy to maintain, and also reduces the chances of bugs.

One good example of the DRY principle is the helper class in enterprise libraries, in which every piece of code is unique in the libraries and helper classes.

KISS - Keep It Simple, Stupid

KISS principle keeps code simple, clear, and easy to understand. Programming languages are for humans to understand, so keep coding simple and straight, to be understood by human beings. Keep your methods small each method should never be more than 40-50 lines.

Each method should only solve one small problem, not many use cases. If you have a lot of conditions in the method, break these out into smaller methods. It will not only be easier to read and maintain but also can find bugs a lot faster.

Violations of KISS:

We have all experienced situations in which we had work to do in the project and found some messy code. "Why they have written these unnecessary lines and conditions when we could do the same thing in just 2-3 lines?" Just have a look at the two codes shown below. Both methods are doing the same thing, but which one would you use?

public String weekday1(int day) {
switch (day) {
case 1:
return “Monday”;
case 2:
return “Tuesday”;
case 3:
return “Wednesday”;
case 4:
return “Thursday”;
case 5:
return “Friday”;
case 6:
return “Saturday”;
case 7:
return “Sunday”;
default:
throw new InvalidOperationException(“day must be in range 1 to 7”);
}

}
public String weekday2(int day) {
if ((day < 1) || (day > 7)) throw new InvalidOperationException(“day must be in range 1 to 7”);
string[] days = {
“Monday”,
“Tuesday”,
“Wednesday”,
“Thursday”,
“Friday”,
“Saturday”,
“Sunday”
};
return days[day – 1];
}

How to Achieve the KISS principle:

To avoid violating the KISS principle try to write the simplest code. Think of many solutions to your problem and choose the best one and transform that into your code. Wherever there is lengthy code, divide that into multiple methods, right-click and refactor in the editor. Try to write small blocks of code which do a single task.

Benefits of KISS:

If we have some badly-written functionality by one developer, and if we ask further developers to make modifications in that code, then first he has to understand the code, which will be more time-consuming than it has to be. If the code is written simply, then there will not be any difficulty in understanding that code, it will be easier to modify, and will take significantly less time. 

Summary

While writing any code or module, keep software design principles in mind and use them wisely. Make them your habit so you won't need to keep remembering every time; it will save development time and make your software module robust, maintainable, and extendable.