Adaptive Code Agile coding with design patterns and SOLID principles

  • ISBN13:


  • ISBN10:


  • Edition: 2nd
  • Format: Paperback
  • Copyright: 2017-04-12
  • Publisher: Microsoft Press

Note: Supplemental materials are not guaranteed with Rental or Used book purchases.

Purchase Benefits

  • Free Shipping On Orders Over $35!
    Your order must be $35 or more to qualify for free economy shipping. Bulk sales, PO's, Marketplace items, eBooks and apparel do not qualify for this offer.
  • Get Rewarded for Ordering Your Textbooks! Enroll Now
List Price: $49.99 Save up to $32.49
  • Rent Book $17.50
    Add to Cart Free Shipping


Supplemental Materials

What is included with this book?

  • The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.
  • The Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.


Write code that can adapt to changes.


By applying this book’s principles, you can create code that accommodates new requirements and unforeseen scenarios without significant rewrites. Gary McLean Hall describes Agile best practices, principles, and patterns for designing and writing code that can evolve more quickly and easily, with fewer errors, because it doesn’t impede change.


Now revised, updated, and expanded, Adaptive Code, Second Edition adds indispensable practical insights on Kanban, dependency inversion, and creating reusable abstractions. Drawing on over a decade of Agile consulting and development experience, McLean Hall has updated his best-seller with deeper coverage of unit testing, refactoring, pure dependency injection, and more.


Master powerful new ways to:

• Write code that enables and complements Scrum, Kanban, or any other Agile framework

• Develop code that can survive major changes in requirements

• Plan for adaptability by using dependencies, layering, interfaces, and design patterns

• Perform unit testing and refactoring in tandem, gaining more value from both

• Use the “golden master” technique to make legacy code adaptive

• Build SOLID code with single-responsibility, open/closed, and Liskov substitution principles

• Create smaller interfaces to support more-diverse client and architectural needs

• Leverage dependency injection best practices to improve code adaptability

• Apply dependency inversion with the Stairway pattern, and avoid related anti-patterns


About You

This book is for programmers of all skill levels seeking more-practical insight into design patterns, SOLID principles, unit testing, refactoring, and related topics. Most readers will have programmed in C#, Java, C++, or similar object-oriented languages, and will be familiar with core procedural programming techniques.

Author Biography

Gary McLean Hall is a software developer, architect, and consultant with more than a decade of experience optimizing processes and practices in diverse Agile environments. He recently founded Igirisu to provide developer training for TDD, continuous integration, refactoring, design patterns, SOLID principles, and Git source control; cultural coaching towards Agile; and related services. His book, Adaptive Code via C# (Microsoft Press, 2014), has been translated into German, Japanese, and Korean, and won the Society for Technical Communications

Distinguished Award in 2015.

Table of Contents

Chapter 1 Introduction to Scrum                                          

Scrum versus waterfall

Roles and responsibilities

Product owner

Scrum master

Development team


The Scrum board

Charts and metrics


The sprint

Release planning

Sprint planning

Daily Scrum

Sprint demo

Sprint retrospective

Scrum calendar

Agile in the real world





Chapter 2 Introduction to Kanban                                         

Kanban quickstart

The information radiator

Limiting work in progress

Protecting against change

Defining “done”

Event-driven ceremonies

Classes of service

Service level agreements

Class WIP limits

People as a class of service


Lead time and cycle time

Cumulative flow diagrams



Part II  Foundations of adaptive code

Chapter 3 Dependencies and layering                                    


A simple example

Framework dependencies

Third-party dependencies

Modeling dependencies in a directed graph

Managing dependencies

Implementations versus interfaces

The new code smell

Alternatives to object construction

Resolving dependencies

Dependency management with NuGet


Common layering patterns

Cross-cutting concerns

Asymmetric layering


Chapter 4 Interfaces and design patterns                               

What is an interface?


Explicit implementation


Adaptive design patterns

The Null Object pattern

The Adapter pattern

The Strategy pattern

Further versatility



Fluent interfaces


Chapter 5 Testing                                                               

Unit testing

Arrange, Act, Assert

Test-driven development

More complex tests

Unit-testing patterns

Writing maintainable tests

The Builder pattern for tests

The Builder pattern

Clarifying unit test intent

Writing tests first

What is TDD?

Test-driven design

Test-first development

 Further testing

The testing pyramid

Testing pyramid anti-patterns

The testing quadrant

Testing for prevention and cure

How do you decrease MTTR?


Chapter 6 Refactoring                                                         

Introduction to refactoring

Changing existing code

A new account type

Aggressive refactoring

Red, green, refactor…redesign

Making legacy code adaptive

The golden master technique



Part III SOLID code     

Chapter 7 The single responsibility principle                            

Problem statement

Refactoring for clarity

Refactoring for abstraction

SRP and the Decorator pattern

The Composite pattern

Predicate decorators

Branching decorators

Lazy decorators

Logging decorators

Profiling decorators

Decorating properties and events


Chapter 8 The open/closed principle                                      

Introduction to the open/closed principle

The Meyer definition

The Martin definition

Bug fixes

Client awareness

Extension points

Code without extension points

Virtual methods

Abstract methods

Interface inheritance

“Design for inheritance or prohibit it”

Protected variation

Predicted variation

A stable interface

Just enough adaptability

Predicted variation versus speculative generality

Do you need so many interfaces?


Chapter 9 The Liskov substitution principle                             

Introduction to the Liskov substitution principle

Formal definition

LSP rules




Data invariants

Liskov contract rules

Code contracts

Covariance and contravariance


Liskov type system rules


Chapter 10  Interface segregation                                          

A segregation example

A simple CRUD interface


Multiple interface decoration

Client construction

Multiple implementations, multiple instances

Single implementation, single instance

The Interface Soup anti-pattern

Splitting interfaces

Client need

Architectural need

Single-method interfaces


Chapter 11  Dependency inversion                                        

Structuring dependencies

The Entourage anti-pattern

The Stairway pattern

An example of abstraction design



Abstracting capabilities

The improved client

Abstracting queries

Further abstraction



Part IV Applying adaptive code

Chapter 12  Dependency injection                                         

Humble beginnings

The Task List application

Constructing the object graph

Beyond simple injection

The Service Locator anti-pattern

Illegitimate Injection

The composition root

Convention over configuration


Chapter 13  Coupling, cohesion, and connascence                    

Coupling and cohesion









Execution order




Measuring connascence


Unofficial connascence

Static vs. dynamic connascence


Appendix   Adaptive tools                                                     

Source control with Git

Cloning a repository

Switching to a different branch

Continuous integration 

Rewards Program

Write a Review