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

    Adapter

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

    Bridge

    • 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

    Command

    • 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’

    Decorator

    • 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

    Proxy

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

    State

    • 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

    Strategy

    • 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

$399

Start Training Today

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

BUY NOW

Single All Access Pass

$599

Save 60%

Access this course along with ALL other Construx OnDemand Content.

BUY NOW

Team License

$399

Discounts Start At 10%

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

CONTACT US

Team All Access Pass

$599

Best Savings

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

CONTACT US

Start Your Free Trial

Try a free preview of the entire Construx OnDemand Catalog.

TRY NOW