Software does not need to be badly written. A software application can be designed from the beginning to survive change. The best strategy for making software easy to change is to make the components of the application loosely coupled. In a loosely coupled application, you can make a change to one component of an application without making changes to other parts.

Over the years, several principles have emerged for writing good software. These principles enable you to reduce the dependencies between different parts of an application. These software principles have been collected together in the work of Robert Martin (AKA Uncle Bob).

Robert Martin did not invent all the principles; however, he was the first one to gather the principles into a single list. Here is his list of software design principles:

• SRP—Single Responsibility Principle
• OCP—Open Closed Principle
• LSP—Liskov Substitution Principle
• ISP—Interface Segregation Principle
• DIP—Dependency Inversion Principle

This collection of principles is collectively known by the acronym SOLID. (Yes, SOLID is an acronym of acronyms.)

For example, according to the Single Responsibility Principle, a class should have one, and only one, reason to change. Here’s a concrete example of how this principle is applied: If you know that you might need to modify your application’s validation logic separately from its data access logic, then you should not mix validation and data access logic in the same class.

Source of Information : Sams ASP .NET MVC Framework Unleashed


Subscribe to Developer Techno ?
Enter your email address:

Delivered by FeedBurner