Software Engineering Principles

  1. Object-Oriented Design Principles
    1. SOLID Principles Overview
      1. Historical Context
        1. Relationship to Object-Oriented Programming
          1. Benefits of SOLID Principles
          2. Single Responsibility Principle
            1. Definition and Rationale
              1. Identifying Responsibilities
                1. Cohesion Analysis
                  1. Change Reasons
                    1. Actor Identification
                    2. Violation Indicators
                      1. Large Classes
                        1. Multiple Change Reasons
                          1. Mixed Concerns
                          2. Refactoring for SRP
                            1. Class Extraction
                              1. Method Extraction
                                1. Responsibility Redistribution
                              2. Open/Closed Principle
                                1. Definition and Motivation
                                  1. Extension Mechanisms
                                    1. Inheritance
                                      1. Composition
                                        1. Strategy Pattern
                                          1. Template Method Pattern
                                          2. Abstraction Usage
                                            1. Abstract Classes
                                              1. Interfaces
                                                1. Polymorphism
                                                2. Implementation Strategies
                                                  1. Plugin Architectures
                                                    1. Configuration-Driven Behavior
                                                      1. Dependency Injection
                                                    2. Liskov Substitution Principle
                                                      1. Definition and Formal Specification
                                                        1. Behavioral Subtyping
                                                          1. Preconditions
                                                            1. Postconditions
                                                              1. Invariants
                                                              2. Common Violations
                                                                1. Strengthened Preconditions
                                                                  1. Weakened Postconditions
                                                                    1. Exception Throwing
                                                                    2. Design Guidelines
                                                                      1. Contract Inheritance
                                                                        1. Behavioral Compatibility
                                                                          1. Interface Segregation
                                                                        2. Interface Segregation Principle
                                                                          1. Definition and Rationale
                                                                            1. Interface Design
                                                                              1. Client-Specific Interfaces
                                                                                1. Role-Based Interfaces
                                                                                  1. Minimal Interfaces
                                                                                  2. Fat Interface Problems
                                                                                    1. Unnecessary Dependencies
                                                                                      1. Implementation Burden
                                                                                        1. Change Propagation
                                                                                        2. Refactoring Techniques
                                                                                          1. Interface Splitting
                                                                                            1. Adapter Pattern
                                                                                              1. Facade Pattern
                                                                                            2. Dependency Inversion Principle
                                                                                              1. Definition and Motivation
                                                                                                1. Abstraction Dependencies
                                                                                                  1. High-Level Policy
                                                                                                    1. Low-Level Details
                                                                                                      1. Stable Abstractions
                                                                                                      2. Implementation Techniques
                                                                                                        1. Dependency Injection
                                                                                                          1. Service Locator
                                                                                                            1. Factory Patterns
                                                                                                            2. Benefits
                                                                                                              1. Testability
                                                                                                                1. Flexibility
                                                                                                                  1. Maintainability

                                                                                                              Previous

                                                                                                              4. Principles for Robust and Maintainable Systems

                                                                                                              Go to top

                                                                                                              Next

                                                                                                              6. General Coding and Simplicity Principles