Best Software Design Principles

1. Keep it simple, stupid (KISS):

This principle noted by U.S. Navy in 1960.This principle state that your software design should be simple not complex. Easily end user can use the software also with less training developer can board and start delivering.

How to implement:

• UI Design: Any layman can use your software or less training require for the end users 
• Implementation and deployment:  This should take less time to deploy in any environment and easy to configure customer specific data so that earliest possible system can be live
• Architectural design: Need to keep it simple and understandable by all the developers. 
• Class and methods design: Class and method design should be simple, should not unnecessary implement the design patterns, if require the patterns then only implement. 
• Maintainability and code readability: Code is written such a way that easy to maintain when move to production. Code should have good readability. 

Reference:
https://en.wikipedia.org/wiki/KISS_principle

2. Don’t Repeat yourself (DRY):

What does mean of doesn’t repeat yourself in the software development? This mean you write the code in one place and keep re-using the piece of code in different places.

How to implement:

• Don’t write big methods instead split the big method to small reusable code.
• Create the utility class to include all common methods (mathematical calculation methods )  
• Create a class for the contact variables
• Business logic layer should be design such a way that method should be re-usable 
• Well define the blue print of design so that all the developer know about the design and re-use the code instead of re-writing the code.
• Create the model layer (data structure ) which can be use in the DAL, BLL and UI layer 

Reference:
en.wikipedia.org

3. SOLID:

Reference:
www.oodesign.com
docs.microsoft.com

4. Independent testable components:

Component or class should be independent testable, in other word the piece of code written can be unit testable.

How to implement:

• There should not be any dependency in the class or method
• Implement DP (dependency injection) or IOC (inversion or control ) if any object need to create in the class’s methods.

5. Maintain the version:

when every you release the software or code there should be opportunity to maintain the version.

How to implement:

• DLL or exe should have the version no. on each release
• When you develop API then maintain the version by URI, query string , custom header and accept header parameter either one way
• Class : use inheritance, static or dynamic polymorphism or interface

6. Separation of concerns:

This (SoC) principle state that each module will address different concern in other word I will say that you divide the software in different layers.

How to implement:

• Divide the layers as UI , BLL and DAL
• Implement MVC, MVVM or MVP design pattern
• Implement micro service (domain driven design )
• Implement service oriented architecture

7. What you produce other can consume:

What you develop the software there are different kind of users i.e. end user, documentation guy, who maintain the code after push production so always keep in mind when design someone else will be consuming or owning the portion of software .

7. What you produce other can consume:

Under construction

8. Principle of Least knowledge:

Under construction

9. Minimize upfront design:

Under construction

10. Flexible enough to integrate with third party components:

Under construction