SOFTWARE DEVELOPMENT

Principles of Software Engineering

SOLID DRY KISS What does it mean?

Photo by Tim Foster on Unsplash

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.

  • OOpen-closed principle
    Any part of the software, should be available and easily extended for further features, but should not be modified.
  • LLiskov substitution principle
    Objects within a program can be replaced with instances of their sub-category types without changing the accuracy of that specific program.
  • IInterface 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.

Conclusion

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.

Co-founder and CTO at Datamart, Ex-Googler, specializes in Analytics, Software Development and Architecture Design. vpodk.com

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store