Principles

• KISS (Keep It Simple, Stupid): Emphasizes simplicity in design to avoid unnecessary complexity.

• YAGNI (You Ain't Gonna Need It): Encourages developers to avoid adding features or functionality until it's proven necessary.

• DRY (Don't Repeat Yourself): Promotes code reusability by avoiding duplication of code.

• Overengineering: Designing the system to be more complex or sophisticated than necessary, often resulting in unnecessary costs, resources, or complications.

• Premature Optimization: Optimizing code or processes before it is clear where optimization is truly needed, often resulting in wasted time and effort.

• Separation of Concerns: Divides a software system into distinct sections, each addressing a specific concern or functionality.

• Single Responsibility Principle (SRP): A class or module should have only one reason to change, meaning it should only have one responsibility.

• Open/Closed Principle (OCP): Software entities should be open for extension but closed for modification.

• Liskov Substitution Principle (LSP): Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

• Interface Segregation Principle (ISP): A class should not be forced to implement interfaces it does not use.

• Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules; both should depend on abstractions.

• Law of Demeter (LoD): A module should not be aware of the internal workings of the objects it interacts with.

• Minimize Coupling and Maximize Cohesion: Reduce dependencies between different components while ensuring strong connections within each component.

• Principle of Least Astonishment (POLA): Design should not surprise its users; it should behave as expected.