Software engineering principles cheat sheet

Software engineering principles cheat sheet

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.

Discover more from Coursity

Subscribe to get the latest posts sent to your email.

Leave a Comment

Comments

No comments yet. Why don’t you start the discussion?

    Leave a Reply

    Your email address will not be published. Required fields are marked *