Software Design Principals
Principles exist in many areas of life, and they generally represent a fundamental truth or belief from which others are derived. In software, principles are rather abstract guidelines, which are supposed to be followed while designing software.
They can be applied to any programming language, implemented using different patterns, and achieved following different practices. Typically, patterns and practices are the tools used to achieve the desired outcome of the principles.
There are fundamental principles for writing quality software from which all the other principles are derived.
Examples of such principles include:
KISS — Keep it simple, stupid.
DRY — Don’t repeat yourself.
YAGNI — You aren’t gonna need it.
SoC — Separation of concerns.
Even if these principles do not specify concrete rules, they represent a language and common wisdom that many developers understand and refer to regularly.
There are also SOLID (Single responsibility, Open/closed, Liskov substitution, Interface segregation, Dependency inversion) principles that were introduced by Robert C. Martin, which represent guidelines for writing better object-oriented software.
It is a framework consisting of complementary principles that are generic and open for interpretation but still give enough direction for creating better object-oriented designs.
The expectation from SOLID principles is that, when applied, we are more likely to create a system that has higher-quality attributes and is more maintainable in the long term. The SOLID principles use object-oriented primitives and concepts such as classes, interfaces, and inheritance for reasoning about object-oriented designs.
In a similar way, there also principles for designing cloud-native applications in which the main primitive is the container image rather than a class.
Following these principles, we are more likely to create containerized applications that are better suited for cloud-native platforms such as Kubernetes.
