Design Principles

Software design principles are time-tested guidelines that help developers create maintainable, scalable, and robust code. These principles represent decades of collective wisdom from the software engineering community.

Why Principles Matter

Principle Categories

SOLID Principles

The five fundamental principles of object-oriented design, promoted by Robert C. Martin (Uncle Bob).

Single Responsibility (SRP)

A class should have only one reason to change

Open/Closed (OCP)

Open for extension, closed for modification

Liskov Substitution (LSP)

Subtypes must be substitutable for their base types

Interface Segregation (ISP)

Many specific interfaces over one general interface

Dependency Inversion (DIP)

Depend on abstractions, not concretions

General Principles

Fundamental guidelines that apply to all programming paradigms.

DRY - Don't Repeat Yourself

Every piece of knowledge should have a single source of truth

KISS - Keep It Simple

The simplest solution is usually the best

YAGNI - You Aren't Gonna Need It

Don't build features until you actually need them

Coupling & Communication

Principles that govern how components interact with each other.

Law of Demeter

Only talk to your immediate friends

Composition over Inheritance

Favor object composition over class inheritance

Tell, Don't Ask

Command objects, don't query them for decisions

Architectural Principles

Higher-level principles for system design.

Separation of Concerns

Each module should address one concern

Fail Fast

Detect and report errors immediately

Quick Reference

Principle	Mnemonic	Core Idea	Problem Solved
SRP	Single Responsibility	One reason to change	God classes, mixed concerns
OCP	Open/Closed	Extend, don't modify	Fragile code, regression bugs
LSP	Liskov Substitution	Substitutable subtypes	Broken polymorphism
ISP	Interface Segregation	Specific interfaces	Fat interfaces, forced implementations
DIP	Dependency Inversion	Depend on abstractions	Tight coupling, hard to test
DRY	Don't Repeat Yourself	Single source of truth	Scattered changes, inconsistency
KISS	Keep It Simple	Simplest solution wins	Over-engineering
YAGNI	You Aren't Gonna Need It	Build for today	Wasted effort, bloat
LoD	Law of Demeter	Talk to friends only	Train wrecks, hidden dependencies
CoI	Composition over Inheritance	Combine, don't inherit	Rigid hierarchies

Balance is Key

These principles sometimes conflict. Use judgment based on your specific context. The goal is maintainable, working software—not dogmatic adherence to rules.