A Developer’s Principle Design Series

The Modern Developer’s daily development practices include the Core and Code Principles of good Object Oriented Programming.

The Principle Design Series will concentrate on the
Seven Core design principles:

1. SRP – The Single Responsibility Principle

2. OCP – The Open / Closed Principle

3. LSP – The Liskov Substitution Principle

4. ISP – The Interface Segregation Principle

5. DIP – The Dependency Inversion Principle

6. DRY – The Don’t Repeat Yourself Principle

7. IOCP – The Inversion of Control Principles

Each of the Principle Design Series Posts

… Will Concentrate on One Principles

The post will cover the selected core principle in the following format:

1. A clear definition of the principle

2. The justification for the implementation of the principle

3. A real-world description of a violation

4. Key code smells that identify the violation

5. A violation code example

6. The code example that refactors the design principle violation

These concepts will be presented in the following Developer’s Principle Design Series posts:

1. The Single Responsibility Principle – Just because you can doesn’t mean you should

2. The Don’t Repeat Yourself Principle – Repetition is the root of all software evil

3. The Open / Closed Principle – Brain surgery is not required when putting on a hat

4. The Liskov Substitution Principle – If it looks like a Duck, quacks like a Duck, but needs batteries – You probably need a better abstraction

5. The Interface Segregation Principle – Tailor your Interfaces to the Client’s specific requirements

6. The Dependency Inversion Principle – Would you solder a lamp directly into the electrical wiring in a wall?

7. The Inversion of Control Principle – Manage all your toys in one place

The Modern Developer’s Wisdom Pearl # 107:
Technical Insanity

Applying the Same Failing Process Over and Over

… Expecting a Different Result