The software engineering principles cheat sheet I would give to myself If I was preparing for technical interviews again

🟠 ACID Properties

1. Atomicity: Transactions are all-or-nothing, fully completed, or not.
2. Consistency: Transactions ensure the database remains in a valid state.
3. Isolation: Transactions operate independently, unaffected by others.
4. Durability: Completed transactions are permanently recorded despite failures.

🟠SOLID Principles

1. Single Responsibility: Limit each class to a single responsibility.
2. Open/Closed: Classes should be open for extension but closed for modification.
3. Liskov Substitution: Subclasses should be substitutable for their base classes.
4. Interface Segregation: Prefer small, focused interfaces over broad ones.
5. Dependency Inversion: Rely on abstractions rather than concrete implementations.

🟠Design Patterns:

1. Factory Method: Create objects without specifying the exact class.
2. Abstract Factory: Create families of related objects without specifying their concrete classes.
3. Builder: Construct complex objects through a series of steps.
4. Prototype: Copy existing objects without knowing the specifics of their construction.
5. Singleton: Ensure a class has only one instance with a global point of access.
6. Adapter: Enable cooperation between incompatible interfaces.
7. Bridge: Decouple an abstraction from its implementation.
8. Composite: Organize objects into tree structures to represent part-whole hierarchies.
9. Decorator: Add responsibilities to objects dynamically.
10. Facade: Provide a simple interface to a complex system.
11. Flyweight: Reduce the cost of creating and managing many similar objects.
12. Proxy: Control access to another object, handling expensive or complex operations.
13. Command: Encapsulate a request as an object, allowing parameterization and queuing.

🟠 System Design Principles

1. Scalability: Design systems to handle growth in users and data smoothly.
2. Performance: Optimize response times and resource utilization.
3. Reliability: Ensure the system functions correctly and consistently.
4. Availability: Design for near-constant operability.
5. Security: Safeguard systems against unauthorized access and vulnerabilities.
6. Maintainability: Facilitate updates and maintenance with minimal disruption.
7. Modularity: Build components that can be updated independently.
8. Reusability: Design for components to be reused across different parts of the system.
9. Decomposability: Break down complex processes into simpler, manageable parts.
10. Concurrency: Design interactions to handle multiple operations simultaneously without conflict.