Comprehensive Design
                                                                                                                 Patterns
              
             Object-Oriented Analysis and Design (OOAD) is a process of identifying the needs of a software project 
             and then laying out those specifications in a readable model.  Design Patterns are an extension of these 
             skills that create more maintainable and robust code.  Using well-known, proven patterns that either 
             stand-alone or build from one to the next, designers are able to further define the specifications of the 
             project, optimizing quality and time spent on developing the project by programmers.   
              
             This advanced Object-Oriented course provides software architects and designers with skills to create 
             high quality object-oriented designs exhibiting improved flexibility, reduced maintenance costs, and 
             with increased understanding of the resulting code.  Participants learn more than 30 object-oriented 
             patterns, including the 23 micro-architectures in “Design Patterns: Elements of Reusable Object-
             Oriented Software”, by Gamma, Helm, Johnson, and Vlissides (the gang-of-four, or GoF book).  
             Application examples and code snippets are provided to illustrate the patterns and the rationale for using 
             that pattern in a given situation. 
              
             Course Objectives: 
             •   Improve Software Architecture. 
             •   Build Design Pattern Vocabulary. 
             •   Be able to discuss trade-offs in applying various design patterns. 
             •   Gain concepts and tools for writing better object-oriented code. 
             •   Gain concepts for better documenting object-oriented code. 
             •   Review relevant UML notation. 
              
             Audience: Software architects and designers requiring advanced design skills. 
              
             Prerequisites: Object-Oriented Analysis & Design with the Unified Modeling Language or equivalent 
             experience.  At least 6 months experience programming with an object-oriented programming language. 
              
             Number of Days: 4 days 
              
              
             1. Course Introduction                                               Tell vs. Ask 
                     Course Objectives                                            Command/Query Separation (CQS)  
              Overview                                                     Composed Method 
              Suggested References                                         Combined Method 
             2.      Design Pattern Overview                                      Liskov Substitution Principle (LSP)  
                     Objectives in Software Design/Module                  Dependency Inversion Principle (DIP)  
                             Design                                               Interface Segregation Principle (ISP)  
                     Overview of Patterns                                         Law of Demeter 
                     Qualities of a Pattern                               4.      Principles of Package Architecture 
              Pattern Systems                                                     Package Cohesion Principles 
                     Heuristics vs. Patterns                                      Package Coupling Principles 
             3.      Principles of Object-Oriented Design                         Martin Package Metrics 
                     Overview of Principles                               5.      Basic Object-Oriented Design 
                     Single-Responsibility Principle (SRP)                                Patterns 
                     Open-Closed Principle (OCP)                                  Delegation vs. Inheritance 
                     © Batky-Howell, LLC                                                                              1 
                                                       Comprehensive Design Patterns 
                                                                     
             Interface                                                        Single Threaded Execution  
             Immutable                                                        Guarded Suspension  
             Null Object                                               Balking  
             Marker Interface                                          Scheduler 
             General Responsibility Assignment                         Read/Write Lock 
                           Software Patterns                           Producer/Consumer  
            6.      Catalog of GoF Patterns                                   Two-Phase Termination  
                    Overview of GoF Patterns                           Double-Checked Locking 
                    Introduction to Creation Patterns                 9. Patterns-Oriented Software 
             Factory Method                                                          Architecture 
                    Abstract Factory                                          Systems of Patterns  
             Builder                                                   Architectural Patterns 
             Prototype                                                        Layers Architecture  
             Singleton                                                        Pipes & Filters Architecture 
                    Introduction to Structural Patterns                Blackboard Architecture  
             Adapter                                                   Broker  
             Decorator                                                 Model-View-Controller 
             Proxy                                                     Presentation-Abstraction-Control  
             Façade                                                    Reflection  
             Composite                                                 Microkernel 
             Flyweight                                                        Catalog of J2EE Patterns 
             Bridge                                                           J2EE Pattern Relationships 
                    Introduction to Behavioral Patterns               10.     Selected Process Patterns (from PLoP) 
                    Chain of Responsibility                            The Selfish Class 
             Iterator                                                         Patterns for Evolving Frameworks 
             Strategy                                                         Patterns for Designing in Teams  
             Template Method                                                  Patterns for System Testing 
             Mediator                                                 11. Selected Anti-Patterns 
             Observer                                                  Stovepipe System 
             Memento                                                          Stovepipe Enterprise  
             Command                                                          Reinvent the Wheel  
             State                                                            Golden Hammer  
             Visitor                                                          Death by Planning  
             Interpreter                                                      Death March Projects  
            7.      Other Micro-Architecture and System                Additional Management Anti-Patterns 
                           Patterns                                   12. Patterns Summary 
                    Object Pool                                       13.     Appendix A – UML Review 
                    Worker Thread                                     14.     Appendix B – C# Code Examples for 
             Dynamic Linkage                                                         GoF 
             Cache Management                                         15.     Appendix C – Maze Game Java Code
             Type Object                                                               
                    Extension Object                                  16.     Appendix D – Possible Solutions for 
                    Smart Pointer (C++)                                              Exercises 
             Session                                                  17.     Appendix E – Diagram Worksheets 
             Transaction                                               
            8. Concurrency Patterns 
                    © Batky-Howell, LLC                                                                        2 
                                                        Comprehensive Design Patterns