YAGNI

YAGNI

YAGNI, or “You Ain’t Gonna Need It” (or “You Aren’t Gonna Need It”), emerged as one of the key principles of Extreme Programming.  Put another way, the principle states: “Always implement things when you actually need them, never when you just … Continued
Inversion of Control

Inversion of Control

Inversion of Control (IoC or IOC) describes a system that follows the Hollywood Principle. That is, flow of control within the application is not controlled by the application itself, but rather by the underlying framework. Typically in such an architecture, … Continued
Keep It Simple

Keep It Simple

The KISS principle, or Keep It Simple, Stupid, spans many trades, industries, and professions.  The more complex something is, the more ways there are for it to fail, and the more difficult it is to explain to someone else who … Continued
Stable Dependencies

Stable Dependencies

The Stable Dependencies Principle states that “The dependencies between software packages should be in the direction of the stability of the packages. That is, a given package should depend only on more stable packages.” Whenever a package changes, all packages … Continued
Hollywood Principle

Hollywood Principle

The Hollywood Principle states, “Don’t Call Us, We’ll Call You.” It’s closely related to the Dependency Inversion Principle, and illustrates a different way of writing software from the more traditional form of programming in which one’s own code dictates the flow … Continued
Explicit Dependencies Principle

Explicit Dependencies Principle

The Explicit Dependencies Principle states: Methods and classes should explicitly require (typically through method parameters or constructor parameters) any collaborating objects they need in order to function correctly. If your classes require other classes to perform their operations, these other … Continued
Separation of Concerns

Separation of Concerns

A key principle of software development and architecture is the notion of separation of concerns.  At a low level, this principle is closely related to the Single Responsibility Principle of object oriented programming.  The general idea is that one should … Continued
Once and Only Once

Once and Only Once

The Once and Only Once principle can be thought of as a subset of the Don’t Repeat Yourself principle, and is one of the most fundamental principles of software development.  Once and Only Once basically states that any given behavior … Continued
SOLID

SOLID

The SOLID principles of Object Oriented Design include these five principles: SRP – Single Responsibility Principle OCP – Open/Closed Principle LSP – Liskov Substitution Principle ISP – Interface Segregation Principle DIP – Dependency Inversion Principle Generally, software should be written … Continued
Don’t Repeat Yourself

Don’t Repeat Yourself

The Don’t Repeat Yourself (DRY) principle states that duplication in logic should be eliminated via abstraction; duplication in process should be eliminated via automation. Duplication is Waste Adding additional, unnecessary code to a codebase increases the amount of work required … Continued