Design patterns enable the emergent design that is needed on Agile projects. Although patterns at one time were thought of as a “design up-front" technique, they can be used in Agile projects to encapsulate variations that are discovered over time.  For development organizations to thrive in an Agile environment, it is critical that the systems they create are not vulnerable to changing requirements, business priorities, technologies, or market pressures.


This course addresses key questions in modern development such as how to design systems that have changeability as a fundamental quality and how the team can communicate effectively when a design is in a constant state of change.


All Net Objectives consultants have hands-on practical experience with applying Lean thinking to the delivery of software technology solutions. Our approach is to show how Lean applies to an incremental realization of software features and systems and how to apply practices that improve the team’s ability to deliver.


How the course is organized

This course uses patterns in a new way. Historically, patterns have been thought of as part of an  “up-front design” style of development. Now, we realize they are powerful tools in an Agile environment, where much is assumed to be unknown at the beginning of a project, and where the design is expected to emerge through the iterative process.

Patterns are examples of following the wisdom that guides good design. They emphasize the importance of creating encapsulation and using delegation to segregate systems to protect them from cascading change. When they were first suggested, computers were fundamentally slower, and technology resources (memory, disk space) were far more expensive than they are today. The style of design suggested by patterns is far more realistic. Patterns are far more useful as collection of best practices rather than simply “reusable solutions.”


Participants learn to use patterns as part of a thought process that guides analysis, using “pattern orientation” as a way to understand an ever-changing problem domain.


Participants also learn to consider patterns in the context of testability (specifically unit testing), commonality-variability analysis, and a technique called “refactoring to the open-closed.” By combining these techniques into an overall paradigm of design, developers and teams learn to move a design forward confidently even when there is an expectation that the sand beneath their feet will shift.


Learning Objectives: 

In this course, you will learn:

  • How to use patterns thinking to enable your designs to emerge

  • How to add functionality to designs while minimizing complexity

  • What design patterns really are

  • Twelve specific design patterns

  • What code qualities you need to maintain to keep code flexible

  • How to use design patterns to keep code quality high

  • Several easy, low-cost practices that will improve the quality of your designs and code

  • How to use design patterns in an Agile environment


Day 1: Theory

  • Examination of typical causes of project failure

  • Example of a failed design

  • Qualities of changeable code

  • Testability as a Trim-Tab in development

  • The principles and practices of professional development: The Strategy Pattern

  • Wisdom from our field


Day 2: Application

  • Commonality-Variability Analysis (CVA)

  • The Template Method as an example of CVA

  • Using CVA to derive the Bridge Pattern

  • Patterns in context: Adapter and Façade Patterns

  • Re-solving the problem from Day 1 in a new, better way

  • Emergence through encapsulation and patterns: Refactoring to the Open-Closed

  • Group design exercise, Part 1


Day 3: Expansion

  • Group design exercise, Part 2

  • Aspects of flexibility

  • The Analysis Matrix and the Abstract Factory

  • Separation of use and creation

  • Encapsulating construction

  • The Singleton Pattern

  • The Proxy Pattern

  • The Decorator Pattern

  • The Chain of Responsibility Pattern

Full Description

Most everyone has learned that design patterns are valuable as “solutions to recurring problems in a context.”  Since their identification we’ve seen patterns hatching (combining patterns), refactoring to patterns (changing designs until they implement the intention of patterns), and thinking in patterns (thinking in terms of the problems the patterns portend to solve).  However, there is a deeper level and intent of patterns.  Christopher Alexander, the creator of patterns, coined the definition given above near the beginning of his iconic book “The Timeless Way of Building.” However, four pages from the end of the book he states -


“At this final stage, the patterns are no longer important: the patterns have taught you to be receptive to what is real.”

Combining, refactoring or thinking in patterns is not the real intention of patterns.  Their intention is to teach you to be receptive to what’s real.  Learning common patterns such as adapter, façade, strategy, singleton and the like are good starts.  But the true power of patterns is in understanding the principles underneath them and the practices they suggest you use.


Net Objectives has been teaching design patterns for 2 decades and this deeper patterns thinking for almost as long.  It includes many common patterns - Strategy, Bridge, Adapter, Façade, plus more. However, our course goes beyond teaching patterns as solutions in several ways.  First, we teach the principles underlying the patterns.  This not only enables participants to improve their object-oriented skills it enables adjusting the patterns as required to fit the problem being solved when an exact match doesn’t occur.  We also incorporate several practices into the course.  A “practice” is an almost no-cost habit that reaps huge rewards.  An example in a non-software field is the practice of doctors washing their hands before they see a patient.  These seems obvious now, but it wasn’t always so.  There are many software practices, that if followed, greatly improve one’s design and code.  Several of these are incorporated into the course.


Perhaps most importantly, the course incorporates the design paradigm Christopher Alexander suggests but which is usually ignored in patterns training.  This is that design is not a mere combination of objects.  Instead, it suggests the intention of the patterns be applied in a way that they build upon each other.  This insight led to Al Shalloway and Jim Trott’s book on Design Patterns Explained: A New Perspective on Object-Oriented Design.  The course is based on this book and illustrates how our normal approach of designing objects as “nouns and verbs” only takes you so far.

In the current Agile space of emergent design how to write code that is changeable over time is critical – this is one aspect that is often ignored in patterns courses.  They are not only useful for handling multiple variations at one time but variations over time.  The course also builds on Scott Bain’s Jolt Award winning book Emergent Design: The Evolutionary Nature of Professional Software Development.



Max class size



3 Days




Design Patterns Thinking