Essential Software Architecture Principles Explained by a Senior Architect

The author, a senior architect, shares a quick guide to the fundamental principles that underpin robust software architecture, aiming to help developers design, test, and maintain clean, modular systems.

1. Dependency Inversion : Depend on abstractions rather than concrete implementations, reversing the direction of dependency control.

2. Separation of Concerns (SoC) : Divide a system by functional areas (business logic, infrastructure, UI) to simplify development, testing, and deployment.

3. Inversion of Control (IoC) : Let frameworks such as Spring manage the control flow and object creation instead of manual instantiation.

4. Dependency Injection (DI) : Inject required dependencies at runtime, typically via constructors, to increase flexibility.

5. Single Responsibility Principle (SRP) : Ensure each module, class, or function has only one reason to change.

6. DRY (Don’t Repeat Yourself) : Reuse existing functionality instead of duplicating code.

7. Open‑Closed Principle : Software entities should be open for extension but closed for modification.

8. Persistence Ignorance : Keep business logic independent of any specific persistence technology.

9. YAGNI : Avoid implementing features until they are truly needed.

10. Boy Scout Rule : Leave the codebase cleaner than you found it.

11. Liskov Substitution Principle : Subtypes must be substitutable for their base types without altering program behavior.

12. Encapsulation : Hide internal details of components to protect against unintended access.

13. Loose Coupling : Minimize inter‑module dependencies to reduce impact of changes.

14. Cohesion : Keep related functionality within the same module to improve maintainability.

15. Interface Segregation : Clients should not be forced to depend on interfaces they do not use.

16. Bounded Context : Partition a large domain into independent sub‑domains with clear boundaries.

17. Stable Dependencies : Depend only on reliable, stable artifacts.

18. Polymorphism : Use interfaces that can have multiple implementations.

19. Modularization : Structure the system as independent modules.

20. Abstraction : Focus on essential characteristics while ignoring irrelevant details.

21. KISS (Keep It Simple, Stupid) : Favor simple, understandable solutions.

22. Incremental/Iterative Approach : Develop software in small, repeatable increments.

23. Least Knowledge (Law of Demeter) : Limit the knowledge each component has about others.

Below is a Java example illustrating Dependency Injection and Inversion of Control:

package az.alizeynalli.di;

public interface Action {
    void do();
}

public class HumanAction implements Action {
    @Override
    public void do() {
        System.out.print("run");
    }
}

public class Human {
    Action action;
    public Human(Action action) {
        this.action = action;
    }
    public void do() {
        action.do();
    }
    public static void main(String[] args) {
        Human human = new Human(new HumanAction());
        human.do();
    }
}

Another snippet shows a service interface and its implementations for converting income and expense objects:

package az.alizeynalli.cashflow.core.service;

public interface ConverterService {
    Income convertIncome(Income income);
    Expense convertExpense(Expense expense);
}

@Component
public class ExpenseConverterServiceImpl implements ConverterService {
    @Override
    public Income convertIncome(Income income) {
        throw new UnsupportedOperationException();
    }
    @Override
    public Expense convertExpense(Expense expense) {
        // convert expense here
        return expense;
    }
}

@Component
public class IncomeConverterServiceImpl implements ConverterService {
    @Override
    public Income convertIncome(Income income) {
        // convert income here
        return income;
    }
    @Override
    public Expense convertExpense(Expense expense) {
        throw new UnsupportedOperationException();
    }
}

The article also contains numerous links to external articles for deeper exploration of each principle and promotional calls inviting readers to join groups, claim gifts, or access additional resources.