The S.O.L.I.

D Principles
S — Single Responsibility.
A class should have a single responsibility.

O — Open-Closed.
Classes should be open for extension, but closed for modification

L — Liskov Substitution.
If S is a subtype of T, then objects of type T in a program may be replaced with
objects of type S without altering any of the desirable properties of that program.

I — Interface Segregation
.Clients should not be forced to depend on methods that they do not use.

D — Dependency Inversion.
- High-level modules should not depend on low-level modules. Both should depend
on the abstraction.
- Abstractions should not depend on details. Details should depend on abstractions.

CQRS
stands for Command Query Responsibility Segregation. It's a pattern that I first
heard described by Greg Young. At its heart is the notion that you can use a different
model to update information than the model you use to read information. For some
situations, this separation can be valuable, but beware that for most systems CQRS
adds risky complexity.QRS
Domain Driven Design

Domain-Driven Design is an approach to software development that centers the

development on programming a domain model that has a rich understanding of the
processes and rules of a domain.

Domain-driven design is predicated on the following goals:

● Placing the project's primary focus on the core domain and domain logic;
● Basing complex designs on a model of the domain;
● Initiating a creative collaboration between technical and domain experts to
iteratively refine a conceptual model that addresses particular domain
problems.

Clean Architecture
Clean Architecture is a software design approach that comprises multiple
interconnected components, each meticulously crafted with a well-defined purpose
and role. These components work harmoniously to create an overall structure that
promotes maintainability, scalability, and testability. By adhering to Clean
Architecture principles, developers can ensure a separation of concerns, enabling
easier modification or replacement of specific parts of the system without affecting
the entire application. This modular and flexible design fosters code reuse, enhances
developer productivity, and ultimately results in a robust and adaptable software
solution.