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
Dependency Inversion Principle

Dependency Inversion Principle

The Dependency Inversion Principle (DIP) states that high level modules should not depend on low level modules; both should depend on abstractions. Abstractions should not depend on details.  Details should depend upon abstractions. It’s extremely common when writing software to implement … Continued
Interface Segregation Principle

Interface Segregation Principle

The Interface Segregation Principle (ISP) states that clients should not be forced to depend on methods that they do not use.  Interfaces should belong to clients, not to libraries or hierarchies. Application developers should favor thin, focused interfaces to “fat” … Continued