Software Design Principles
Software design principles are guidelines that help developers create software that is easy to understand, maintain, and extend. While patterns provide solutions to specific problems, principles provide a general philosophy for writing code.
1. KISS (Keep It Simple, Stupid)
The KISS principle states that most systems work best if they are kept simple rather than made complicated. Simplicity should be a key goal in design, and unnecessary complexity should be avoided.
- Core Idea: Don't use a complex solution when a simple one will do.
- Example: Don't use a heavy design pattern or a new library just to format a date string if a built-in function can do it in one line.
- Benefit: Simple code is easier to read, debug, and test.
2. YAGNI (You Aren't Gonna Need It)
YAGNI is a principle of Extreme Programming (XP) that states a programmer should not add functionality until it is necessary.
- Core Idea: Don't implement features "just in case" you might need them in the future.
- The Trap: "I'll add this extra parameter to the function now because we might need it later."
- The Reality: You usually don't need it, or when you do, the requirements will be different than what you guessed.
- Benefit: Saves time, reduces code bloat, and keeps the codebase focused on current requirements.
3. DRY (Don't Repeat Yourself)
The DRY principle is stated as "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system."
- Core Idea: Avoid code duplication. If you change logic, you should only have to change it in one place.
- Violation (WET - Write Everything Twice): Copy-pasting the same validation logic into 5 different forms. If the validation rule changes, you have to find and update all 5 places.
- Solution: Extract the logic into a shared function or component.
- Caveat: Don't apply DRY too aggressively. Sometimes duplication is better than the wrong abstraction (coupling unrelated code just because it looks similar).
4. SoC (Separation of Concerns)
Separation of Concerns is a design principle for separating a computer program into distinct sections such that each section addresses a separate concern.
- Core Idea: A program should be broken down into distinct modules that overlap as little as possible.
- Example: HTML (Structure), CSS (Presentation), and JavaScript (Behavior) are separated. In backend, MVC separates Model, View, and Controller.
5. Law of Demeter (LoD)
The Law of Demeter (LoD), also known as the Principle of Least Knowledge, states that a given object should assume as little as possible about the structure or properties of anything else.
- Motto: "Only talk to your immediate friends."
- The Rule: A method should not invoke methods of objects returned by another method call.
- Violation (Train Wreck):
order.getCustomer().getAddress().getZipCode(). This couples the code to the structure of Customer and Address. - Solution:
order.getCustomerZipCode(). The Order object should handle the delegation internally.
programming/solid-principles programming/refactoring-techniques programming/clean-architecture programming/extreme-programming