There are number of common design principles that, like design patterns, best practice over the years to build maintainable software.
I'm up to describe some widely used design principles though out the post.
Following common principle are extracted by the same book that I mentioned before (Professional ASP.Net Design Patterns - Scott Millet).
Principles are as follows:
Keep It Simple Stupid (KISS)
One common issue in software programming is over-complicating a solution. So main concern of this principle is keep the code simple but not simplistic. Eventually this will avoid unnecessary complexities.
Don't Repeat yourself (DRY)
Main concern of this principle is to avoid the repetition. In other words this is all about abstracting out the common functionalities into a single place.
Ex: If there is a price calculation method in a system. It should lay in a single place there.
Tell Don't Ask
The Tell, Don’t Ask principle is closely aligned with encapsulation and the assigning
of responsibilities to their correct classes. This principle state that you should tell the
object to what actions that you want to perform instead of checking the state of an object and performing the action by yourself. This avoids the tight coupling between classes.
You Ain’t Gonna Need It (YAGNI)
This is about putting of any features that are going to add having the idea in mind, that you gonna need this later. A design methodology that adheres to YAGNI is test-driven development (TDD). In brief TDD is all about righting the code only to pass the test.
Separation of Concerns (SoC)
SoC is the process of dissecting a piece of software into distinct features that encapsulate unique behavior and data that can be used by other classes. Generally, a concern represents a feature or behavior of a class. The act of separating a program into discrete responsibilities significantly increases code reuse, maintenance, and testability.
So this is it.
Comments