About the course
Test Driven Development (TDD) has evolved from a niche Agile practice into a foundational discipline for modern software engineering. This course moves beyond the theory of testing to focus on TDD as a design tool, enabling developers to create cleaner interfaces and more modular codebases. By shifting the focus from "verifying code" to "defining behavior," participants learn how to reduce technical debt and increase confidence in every commit.
Throughout this intensive session, you will engage with the core mechanics of the TDD development cycle, exploring how the strict adherence to the Red/Green/Refactor mantra shapes better software architecture. The workshop is designed to be language-agnostic, ensuring that the architectural principles and refactoring patterns discussed can be immediately applied to any high-level programming environment, from JavaScript to Jakarta EE, Python, Go or Rust.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
By the end of this course, attendees will be able to:
- Internalise the three rules of TDD and the Red/Green/Refactor cycle.
- Distinguish between TDD as a design methodology versus traditional unit testing.
- Apply TDD Katas to develop muscle memory for iterative development.
- Identify and correct common TDD anti-patterns.
- Execute refactoring patterns to improve internal code structure without changing external behavior.
-
This course is designed for application developers and software engineers who are proficient in at least one high-level programming language. It is ideal for those moving into Agile environments or teams looking to improve their deployment frequency and code quality through automated feedback loops.
-
Delegates must have prior programming experience and a solid understanding of at least one modern high-level language. Familiarity with general testing concepts and the standard testing frameworks relevant to your primary language - such as JUnit, Jasmine, PyTest, or ScalaTest - is required.
-
Delegates must have prior programming experience and a solid understanding of at least one modern high-level language. Familiarity with general testing concepts and the standard testing frameworks relevant to your primary language - such as JUnit, Jasmine, PyTest, or ScalaTest - is required.
-
Foundations of Test Driven Development
Defining TDD: More than just a testing phase
The business and technical case: Why adopt TDD?
Contextual constraints: When is TDD not the right fit?
The shift in mindset: Prioritising interfaces over implementation
The TDD Development Cycle
The TDD Mantra: Red, Green, and Refactor
The 3 Rules of TDD
Driving design through tests
Focusing on the interface: How TDD influences software architecture
Code Katas and Repetitive Practice
Introduction to Katas: Building coding muscle memory
The Bowling Game Kata: Walkthrough and logic
Collaborative Practical: The String Calculator Kata
Group presentations and peer review of design decisions
Refactoring and Advanced Patterns
The critical role of refactoring in the TDD cycle
Common Refactoring Patterns for cleaner code
Identifying TDD Anti-Patterns: Brittle tests, mocking obsession, and over-engineering
Individual Practical: The Tic-Tac-Toe Kata (Language of choice)
Summary and Integration
Integrating TDD into existing workflows
Final Q&A and technical roundup
-
The Clean Code Blog by Robert C. Martin: https://blog.cleancoder.com/
Refactoring.com (Catalog of Patterns): https://refactoring.com/catalog/
The Official JUnit Documentation: https://junit.org/
PyTest Documentation: https://docs.pytest.org/
Martin Fowler's Guide to Test Driven Development: https://martinfowler.com/bliki/TestDrivenDevelopment.html
Trusted by
