Software Development

Principles of Software Engineering

SOLID DRY KISS — What does it mean?

Photo by Tim Foster on Unsplash

By the definition, software engineering is known as a systematic and procedural approach to software development.

It usually consists of collecting and documenting requirements from the users, designing and outlining the platform structure, coding or…

Just like any other branch of science and engineering, there are some basic principles governing good software engineering, of which three popular ones are described below:

1. The KISS principle:

The “Keep It Simple, Stupid” principle reminds us that all software or applications design and deployment should be done as simple as possible with least complexities and clear to understand development procedures. This principle ensures that the source code is made easy to debug (whenever required) and future maintenance by any other operations and maintenance software engineer becomes easier. Usually it is advised to keep only one method for one use case, in order to comply with the KISS principle.

2. The DRY principle:

The “Don’t Repeat Yourself” (or “Duplication Is Evil”) principle tells us that every software engineer should aim to reduce repetition of information or methods within their work in order to avoid redundancy. Therefore, it’s recommended to segregate the entire system of consideration into fragments. Dividing the code into smaller segments can help manage the code and use a single segment at any point, by calling, whenever required.

3. The SOLID design principles:

The solid design principles are a set of combined principles that help to guide software engineers make software designs understandable, easier to manage or maintain, and convenient to extend or scale.

The S.O.L.I.D. design principles comprise of the following:

  • S — Single responsibility principle Every module should be designed to carry out just its responsibility over a single part of the functionality provided by the software.
  • O — Open-closed principle Any part of the software, should be available and easily extended for further features, but should not be modified.
  • L — Liskov substitution principle Objects within a program can be replaced with instances of their sub-category types without changing the accuracy of that specific program.
  • I — Interface segregation principle It’s best to avoid adding new functionalities or methods to an existing interface. Rather it’s recommended to incorporate a new interface and permit the classes to implement different interfaces based on the need.
  • D — Dependency inversion principle We should always use a design pattern known as dependency inversion pattern, which is usually resolved by the use of dependency injection.

Usually the S.O.L.I.D design principles seem quite philosophical and abstract. However, when comparing real-life applications of S.O.L.I.D. principles, the advantages of these principles are easily and evidently reflected. Any software backend code that proceeds with the recommendations of the S.O.L.I.D. principles are much easier to be shared with collaborators, scaled up to meet volume, modified based on user requirements, tested for stress or usability, and managed and troubleshooted without any issues.


In conclusion, the software engineering principles are proposed to maintain a standard discipline of software development and designing procedure so that irrespective of the ownership of the source code or the application, there is always a flexibility in utilizing, transferring, scaling up, and reconfiguring the code in different dynamic scenarios. Although we have only discussed some of the main principles here in our article, it’s strongly recommended to adopt the principles as much as possible while implementing our software engineering practices, so as to ensure the qualities of a flexible code are transferred across the user requirements.