Design Patterns

Eric Rimbey

This seminar introduces and explains design patterns in a clear way that’s easy to understand. You will learn specific design patterns to improve your designs, practice applying design patterns to design problems and see how design patterns can improve your design process overall.

4 Hours of Content
11 Lectures
Purchase Options

Course Details

  • Overview

    Design patterns made understandable! Design patterns are powerful, predefined solutions to common software design problems. Patterns provide a powerful form of reuse because they are transportable across different languages and software architectures. This seminar introduces and explains the highest-leverage design patterns in a clear way that’s easy to understand. You will learn how to use specific design patterns to improve your designs, and you will practice applying design patterns to sample design problems. You will also see how design patterns can improve your design process overall.

    Who Should Attend

    This seminar will benefit programmers, designers, technical leads, and anyone who needs to learn how to apply design patterns in modern software development projects. Attendees should have a basic understanding of object oriented software and be able to read Java, C++, or C# code.

  • Course Details

    Fundamental Design Principles

    • Manage coupling and cohesion
    • Prefer association to inheritance
    • Encapsulate what varies
    • Information hiding
    • Separate creation and usage
    • Identify abstractions
    • Delay binding times
    • Design to interfaces
    • Design to contracts
    • Principle of least knowledge
    • Design for evolution
    • Design for testability

    The Patterns

    Abstract Factory

    • Specify object creation with an interface
    • Create families of factory methods
    • Allocate responsibility for instance creation to a service
    • Keep the client ignorant of instantiation details while maintaining conformance to a contract


    • Convert between interfaces
    • Reuse services
    • Class Adapter uses inheritance
    • Object Adapter uses association
    • Reduce the coupling between a client and its dependencies


    • Decouple an abstract specification from any particular implementation
    • Enable late and dynamic binding between components
    • Specify collaborations using interfaces and contracts
    • Enable substitution of different implementations
    • Enable reuse of implementations among different clients


    • Encapsulate a service request as an object
    • Parameterize methods for consistency
    • Dynamically specify and sequence methods with structure
    • Reduce complexity of code by reducing branching logic
    • Specify flexible workflows as data structures
    • Maintain action history
    • Implement ‘Undo’


    • Dynamically augment an object’s behavior
    • Aggregate several effects into a single behavior
    • Replace complicated branching logic with flexible data structures
    • Encapsulate behavioral variations behind a unified interface

    Dependency Injection

    • Maintain loose coupling between a component and its dependencies
    • Re-assign responsibility for object instantiation
    • Inject flexibility into the design
    • Simplify testing

    Factory Method

    • Create polymorphic methods for object creation
    • Delegate responsibility for object construction
    • Isolate instantiation logic
    • Enable ‘pre-packaged’ default configurations
    • Reduce coupling to rigid constructor methods
    • Afford interface variation while maintaining implementation consistency


    • Inject new behavior without altering the interface
    • Encapsulate ‘orthogonal’ behavior
    • Encapsulate ‘non-functional’ enhancements and optimizations
    • Robustly utilize remote services


    • Simplify implementation of a state machine
    • Allow objects to respond differently according to internal state
    • Allow responsibilities and states to evolve with minimal effort
    • Reduce branching logic
    • Reduce number of components required to perform a service


    • Isolate changeable characteristics to avoid combinatorial explosion of configurations
    • Interchange behaviors among components
    • Increase cohesion by delegating specific responsibilities
    • Allow configurations to evolve with minimal effort
    • Reduce cost of testing

    Template Method

    • Fix a sequence of behaviors while allowing each step to vary
    • Allow alternate algorithms to conform to the same contract
    • Enforce constraints in one place
    • Simplify verification of behavior

  • Eric Rimbey

    Eric Rimbey is a Senior Fellow at Construx Software where he focuses on software design, requirements, quality, and testing. Eric has developed a wide range of Web 2.0 applications for social networking, wireless systems, manufacturing, large-scale military programs and the retail industry. Prior to joining Construx, Eric worked for Cozi, AXC Interactive and Wolfram Research, Inc. His professional roles have included business analyst, technical lead, test lead and QA lead.

    Eric has a B.A. from Milligan College in Humanities and an M.A. from the University of Washington in Mathematics. He is a Certified Software Development Professional (CSDP) and a member of IEEE.

Purchase Options

Single License


Start Training Today

Get unlimited access to this online course for an entire year.


Single All Access Pass


Save 60%

Access this course along with ALL other Construx OnDemand Content.


Team License


Discounts Start At 10%

Need 10 or more seats? Contact us to learn how much you can save!


Team All Access Pass


Best Savings

The more seats you need, the more you save! Contact us for info.


Start Your Free Trial

Try a free preview of the entire Construx OnDemand Catalog.