Engineering for Agility (.NET)

Leverage automated testing as a framework for allowing teams to experiment with code.

Agility is not just for humans. If our software is brittle and inflexible, our ability to pivot with market demands is severely compromised. Whether we are working with new code or old, the agility we need has to be deliberately designed. This course combines the human and technology elements to form a basis for intentional, thoughtful development of high-quality, easy-to-change architecture and code.

The two-day Engineering for Agility course leverages automated testing as a framework for thinking about code — whether legacy or greenfield — and for liberating teams to experiment freely and safely. Students learn patterns and anti-patterns of testing, architecture, collaboration and tooling for making software releases a monotonously frequent and uneventful experience.

Extend the learning experience to include hands-on workshops that expand this course to a deeper dive into areas of particular interest using your own systems, teams, and backlog as the subject matter. Topics include:

  • Architecting Socially – Collaborating with Architects and Each Other
  • Managing Technical Debt- Maneuvering in Legacy Code and Incremental Modernization
  • Effective Usage of Git – Branching Models, Clean History
  • Social Programming – Mobbing, Pairing, and Product Owner Collaboration
  • Testing Strategies – API, Exploratory, Contract, Performance
  • DevSecOps & CI/CD – Pipeline Design, Continuous and Automated Deployment

Each workshop involves assessing areas of concern, exploring the patterns and techniques that may help, and planning out an approach for iterative improvement.

This class and its related workshops emphasize thought and behavioral patterns applied through hands-on exercises to reinforce learning. Concepts are taught progressively, with each layer building upon and reinforcing the previous ones.

Notes: This course is also available for private delivery using Java or Python instead of .NET. When taken live, online, this class is delivered in three half-day sessions.

2 days/16 hours of instruction
Public Classroom Pricing


Group Rate: $1695

Private Group Pricing

Have a group of 5 or more students? Request special pricing for private group training today.

Part 1: Moving Towards Good

  1. Introduction
    1. Logistics
    2. Getting to know one another
  2. Agile Engineering Values
    1. Good code matters
    2. Better together
    3. Encourage experiments
  3. Steps towards making our code better together
    1. Group code review
    2. Code smells
    3. Refactoring safely
      1. Git revert
      2. Using tests
    4. Qualities of “Good Code”

Part 2: Building Better Software Together

  1. Social programming
    1. Mobbing
    2. Pairing
    3. Whole team
  2. Principles and patterns
    1. Heuristics
      1. Cognitive load
      2. Coupling
    2. Dependency breaking
      1. Tests
      2. Mocks
      3. Refactoring

Part 3: Stories and Work Size

  1. Small testable stories
    1. Size matters
    2. Example mapping
    3. Story mapping
  2. Test driving
    1. Red Green Refactor
    2. Not just Test First
    3. TDD and Flow

Part 4: Beyond the Basics

  1. CI/CD
    1. CI vs. CD
    2. Git workflow
    3. Branching strategies
  2. Practice Improvement
    1. Feedback speed
    2. Testing strategies
    3. Continuous flow
  3. Next steps for your team
  4. Experiments to try

Part 5: Summary

  1. Agility requires Agility in software practices
  2. Three principles should guide you
    1. Good code matters
    2. Better together
    3. Encourage experiments

This course includes live coding exercises that are worked in pairs. Participants need to be comfortable coding and have an IDE setup. The course is offered in Java, .NET, or Python as the base language.

Professionals who benefit from this course include:

  • Product Engineers
  • Software Engineers (front-end and back-end)
  • Architects
  • Testers
  • Scrum Masters

  • Recognize and remediate code that will limit future agility
  • Understand and practice test-driven development (TDD) as a design tool to create flexible, modular, maintainable software
  • Comprehend architectural styles, patterns and principles that design agility into the system
  • Iteratively re-engineer and introduce agility into a legacy codebase
  • Familiarize with typical tools for supporting agile engineering and how to use them well
  • Practice with teaming and social programming concepts and methods including pair programming and mob programming
  • Familiarize with the testing pyramid and strategies for testing at each level of it
  • Recognize advanced testing concepts for further exploration

Engineering for Agility (.NET) Schedule

There are currently no scheduled classes for this course. Please contact us if you would like more information or to schedule this course for you or your company.

Request Private Group Training