Agile Practices for Developers

Agile Practices for Developers

We offer this course privately at your location, online, virtually, and at our Bellevue, WA campus.

Get in touch

About Agile Practices for Developers

  Duration: 1.5 – 3 day course
  Resources: Workbook, Online Companion Course

Despite the wide adoption of Agile frameworks, many development teams are not reaping the benefits of agility because of the poor quality of their code and the high volume of manual, error-prone, tasks. While Scrum—for example—is deliberately nonprescriptive on how the software is built, its adoption is rarely successful without applying good technical practices.

Development teams that mistakenly ignore good technical practices keep snowballing technical debt and are unable to add new features and respond to change within a Sprint time-box. This seminar provides hands-on experience on proven engineering practices, design principles and patterns that will enable developers to deliver high-quality, valuable, working software frequently while accommodating changing requirements.

This course focuses on engineering practices and techniques. To get the most out of it, we encourage you to bring a laptop loaded with your preferred development environment (IDE/editor and a unit testing framework at minimum). For some hands-on labs, we provide sample code in C#, Python, Ruby, and Java for you to choose.

Clean Coding

  • Coding standards
  • The Telephone Test
  • Programming by Intention and the Compose Method pattern

Code Metrics

  • Static code analysis
  • Measuring complexity
  • Measurable code smells

Design Principles & Patterns

  • Single Responsibility Principle (SRP)
  • Don’t Repeat Yourself (DRY)
  • Open-Closed Principle (OCP)
  • Dependency Inversion Principle (DIP)
  • Law of Demeter (LoD)
  • Strategy Pattern
  • Hexagonal architecture

Test Case Design

  • Contract tests
  • Domain testing
  • Decision Tables
  • Capturing test scenarios in Gherkin

Automated Testing

  • Test Automation Pyramid and Testing Quadrants
  • Design for Testability (DfT)
  • xUnit test patterns
  • Test Doubles
  • Refactoring test code
  • Code coverage

Refactoring

  • Emergent Design
  • Rules of Simple Design
  • Improving names
  • Removing duplication
  • Refactoring to Patterns

Test-Driven Development (TDD)

  • Acceptance Test-Driven Development and Behavior-Driven Development (BDD)
  • The Red-Green-Refactor cycle
  • Three Laws of TDD

Continuous Integration (CI) & Continuous Delivery (CD)

  • Essential practices for CI
  • Trunk-based development
  • Essential practices for CD

At the end of this seminar, participants will be able to:

  • Automate tests to efficiently ensure software code is working
  • Understand the benefits of automated builds and continuous integration
  • Develop code using Test-Driven Development to ensure testability
  • Write clean code to ease maintenance and avoid unintentional rework
  • Improve the quality of the code continuously via refactoring
  • Refine requirements to improve planning and remove ambiguities
  • Design effective and efficient test cases
Software developers who are, or will be, part of an agile team.

“The instructor was very knowledgeable and articulate. He was also very responsive to questions and allowed plenty of time for discussions.”

Stacy Dimeo, Strasz

“Great lessons/topics covering our needs. Very well designed course materials.”

Hemambara Vadlamudi, Parametric

“Loved the Jenga example – it really proved the point but was technology agnostic. It was also great to actually DO TDD. I’ve read a lot about it, but now it really makes sense.”

Steve Jackson, Equifax

“The hands-on labs allowed me to become more comfortable with the tools in a more controlled (lower stress) environment.”

John Reno, MSA Safety

“Emphasis on flexibility of methodology – not formally prescriptive. Melvin very good at responding to each person on their level.”

Mark Shimizu, Bsquare

“Learning to break stories down further was great. That is something that is actionable for me right away. The testing approaches were great and how to evaluate code complexity.”

Shayne Meyer, Providence

“The course material was helpful to me as an evaluation of where I currently stand vs Agile best practices, and the materials give me many “jumping off” points for further learning.”

Dave M, Cisco

“The course was a very good introduction. I wish I’d attended something similar when I was first starting TDD. I will definitely recommend to my coworkers.”

Dave Strock, Astronautics

“Most valuable: seeing my developers learn more about testing smaller chunks of work sooner and more often. Also, the TDD part was great and much needed. Job well done!”

Doug Poole, Equifax

“The exercises were fantastic — especially the Jenga teamwork. This could be an essential way of communicating to colleagues outside of software engineering.”

Aaron Kupniewski, MSA Safety

Customize this course

Your team has unique challenges. Learn about the ways we can customize this course to fit your needs.