UML and Object-Oriented Design

  1. Object-Oriented Analysis and Design Process
    1. Requirements Analysis
      1. Stakeholder Identification
        1. Requirements Gathering Techniques
          1. Interviews
            1. Workshops
              1. Observation
                1. Document Analysis
                2. Functional Requirements
                  1. Use Case Identification
                    1. Actor Identification
                      1. System Boundary Definition
                      2. Non-Functional Requirements
                        1. Performance Requirements
                          1. Security Requirements
                            1. Usability Requirements
                              1. Reliability Requirements
                              2. Use Case Documentation
                                1. Use Case Templates
                                  1. Main Success Scenarios
                                    1. Alternative Flows
                                      1. Exception Handling
                                        1. Preconditions and Postconditions
                                      2. Domain Modeling
                                        1. Conceptual Model Development
                                          1. Class Identification Techniques
                                            1. Noun Extraction
                                              1. Domain Vocabulary Analysis
                                                1. Responsibility Assignment
                                                2. Initial Class Diagram Creation
                                                  1. Candidate Classes
                                                    1. Class Relationships
                                                      1. Attribute Identification
                                                      2. Domain Rules and Constraints
                                                        1. Model Validation
                                                          1. Walkthrough Scenarios
                                                            1. Stakeholder Review
                                                          2. System Architecture Design
                                                            1. Architectural Patterns
                                                              1. Layered Architecture
                                                                1. Model-View-Controller
                                                                  1. Client-Server Architecture
                                                                    1. Service-Oriented Architecture
                                                                    2. System Decomposition
                                                                      1. Subsystem Identification
                                                                        1. Interface Definition
                                                                          1. Dependency Management
                                                                          2. Package Organization
                                                                            1. Package Structure
                                                                              1. Package Dependencies
                                                                                1. Namespace Design
                                                                                2. Component Architecture
                                                                                  1. Component Identification
                                                                                    1. Component Interfaces
                                                                                      1. Component Dependencies
                                                                                    2. Detailed Design
                                                                                      1. Responsibility Assignment
                                                                                        1. Class Responsibilities
                                                                                          1. Method Allocation
                                                                                            1. Collaboration Design
                                                                                            2. Interaction Design
                                                                                              1. Scenario Modeling
                                                                                                1. Sequence Diagram Development
                                                                                                  1. Communication Patterns
                                                                                                  2. Class Design Refinement
                                                                                                    1. Method Signatures
                                                                                                      1. Attribute Specifications
                                                                                                        1. Visibility Decisions
                                                                                                        2. Design Pattern Application
                                                                                                          1. Pattern Selection
                                                                                                            1. Pattern Integration
                                                                                                              1. Pattern Customization
                                                                                                              2. State Modeling
                                                                                                                1. Stateful Object Identification
                                                                                                                  1. State Machine Design
                                                                                                                    1. State Transition Logic
                                                                                                                    2. Error Handling Design
                                                                                                                      1. Exception Hierarchies
                                                                                                                        1. Error Recovery Strategies
                                                                                                                      2. Design Validation and Verification
                                                                                                                        1. Design Reviews
                                                                                                                          1. Peer Reviews
                                                                                                                            1. Walkthrough Sessions
                                                                                                                              1. Inspection Processes
                                                                                                                              2. Design Testing
                                                                                                                                1. Design Simulation
                                                                                                                                  1. Prototype Development
                                                                                                                                    1. Model Validation
                                                                                                                                    2. Traceability Management
                                                                                                                                      1. Requirements Traceability
                                                                                                                                        1. Design Decision Documentation
                                                                                                                                      2. Implementation Considerations
                                                                                                                                        1. Code Generation from Models
                                                                                                                                          1. Model-to-Code Transformation
                                                                                                                                            1. Code Templates
                                                                                                                                              1. Automated Generation Tools
                                                                                                                                              2. Forward Engineering
                                                                                                                                                1. Model-Driven Development
                                                                                                                                                  1. Code Synchronization
                                                                                                                                                  2. Reverse Engineering
                                                                                                                                                    1. Code-to-Model Extraction
                                                                                                                                                      1. Legacy System Analysis
                                                                                                                                                      2. Round-Trip Engineering
                                                                                                                                                        1. Model-Code Synchronization
                                                                                                                                                          1. Change Management
                                                                                                                                                            1. Version Control Integration

                                                                                                                                                        Previous

                                                                                                                                                        6. Design Patterns in UML

                                                                                                                                                        Go to top

                                                                                                                                                        Next

                                                                                                                                                        8. UML Tools and Methodologies