Skip to main content
CF

TDD & BDD - Design Through Testing

5h 42m 42s
English
Paid

"TDD and BDD: Designing Through Testing" demonstrates how to make testing the driving force of development, utilizing it to create higher quality, flexible, and maintainable software. Learn to write truly effective tests and apply them as a design tool rather than as a secondary check of the finished code.

Course Overview

The course, led by Dave Farley, is based on step-by-step explanations, demonstrations, and practical exercises. It aims to help you master TDD and BDD consistently and understand how these approaches strengthen each other, leading to reduced defects and improved system architecture.

Learning Objectives

By enrolling, you will learn how to:

  • Significantly reduce the number of errors in production and spend less time fixing bugs.
  • Guide code design through tests, increasing its modularity, flexibility, and resistance to changes.
  • Create cleaner, maintainable, and evolving solutions.
  • Write durable tests that are resistant to changes in implementation.
  • "Listen to the code" and use feedback from tests to improve architectural decisions.
  • Confidently work with existing and legacy code, gradually improving its structure.

Debunking Myths

The course also addresses common myths about TDD, such as lack of time, inflexible architecture, or resistance from management. It highlights why investing in tests early on allows for faster, more reliable, and less stressful development.

Training Outcomes

As a result of this training, you will gain:

  • A deep understanding of TDD and BDD and their combined application.
  • A noticeable reduction in the number of defects in production (up to 60%).
  • A higher level of confidence in changes and releases.
  • Increased professional satisfaction and sought-after engineering skills.

Target Audience

This course is intended for developers, engineers, and technical leaders who want to build better software faster and with predictable quality.

About the Author: Dave Farley

Dave Farley thumbnail

Dave Farley is a UK-based software engineer and one of the most authoritative independent voices on Continuous Delivery, TDD, and modern software engineering practice. He is the co-author of Continuous Delivery (Addison-Wesley) — the canonical reference on the discipline — and the author of Modern Software Engineering. He runs the popular Continuous Delivery YouTube channel.

His CourseFlix listing carries three Dave Farley courses: Microservices Masterclass, TDD & BDD — Design Through Testing, and Acceptance Testing — BDD From Stories to Executable Specs. The teaching style is unusually principled — Dave's material is taught at the level of an engineer who has shaped the field's literature for two decades.

Material is paid and aimed at engineers ready to take software engineering practice as a deliberate discipline. For broader content, see CourseFlix's QA & Testing and System Design & Architecture category pages.

Watch Online 30 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 30 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Course Preview
All Course Lessons (30)
#Lesson TitleDurationAccess
1
Course Preview Demo
05:22
2
Continuous Delivery Principles
18:32
3
What is Test Driven Development?
14:59
4
Red, Green, Refactor!
05:47
5
Unit Testing and the Properties of Good Tests
06:44
6
Practising Testing
06:30
7
Demo: Getting Started with TDD - String Calculator - Step 1
16:30
8
Demo: Getting Started with TDD - String Calculator - Steps 2 & 3
16:09
9
TDD and the Properties of Good Tests
06:00
10
Three Types of Test in TDD
06:48
11
Demo: Dealing with Exceptions
11:56
12
The Importance of Dependency Injection
05:33
13
Mocking and Dependencies
07:42
14
Demo: Dependency Injection
20:42
15
More on Mocking
06:45
16
Testing at the Edges
08:14
17
BDD & The Importance of Naming
14:15
18
The Shape of Your Tests
09:33
19
Demo: How Tests Improve Design - Part 1
12:07
20
Demo: How Tests Improve Design - Part 2
20:29
21
Modern Software Engineering - Focus on Design
06:59
22
Common Design Problems and Their Solutions
17:08
23
Demo: Thinking Not Just Coding (Part 1)
16:17
24
Demo: Thinking Not Just Coding (Part 2)
13:33
25
The Importance of Refactoring
04:21
26
Refactoring - TDD in Legacy Systems
11:03
27
Listening to the Code
07:24
28
Common TDD Smells
13:45
29
Acceptance Test Driven Development
21:58
30
TDD Top Tips
09:37
Unlock unlimited learning

Get instant access to all 29 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book TDD & BDD - Design Through Testing

#TitleTypeOpen
1Exercise 1 Getting Started with TDD - String Calculator PDF
2Information Sheet 1 - The Properties of Good Tests PDF
3Exercise 2 Dealing with Exceptions PDF
4Exercise 3 Dependency Injection PDF
5Exercise 4 - Part 1 - How Tests Improve Design PDF
6Exercise 4 - Part 2 - How Tests Improve Design PDF
7Information Sheet 2 - Fixing Common Design Problems PDF
8Exercise 5 - Thinking Not Just Coding PDF
9Information Sheet 3 - TDD Smells Anti-Patterns and their Solutions PDF
10Information Sheet 4 - Course References and Useful Links PDF
11TDD-BDD Info 1 - Properties of Good Tests PDF
12TDD-BDD Information Sheet 2 - Common Design Problems and their Solutions PDF
13TDD-BDD Information sheet 3 - Smells TDD Anti-patterns, Causes and Corrections PDF
14TDD-BDD Information Sheet 4 - References and Links PDF

Related courses

Frequently asked questions

What prerequisites should I have before taking this course?
Before taking this course, you should have a basic understanding of software development and some experience with programming. Familiarity with concepts like unit testing and software design principles will be beneficial. The course will delve into Test Driven Development (TDD) and Behavior Driven Development (BDD), so prior exposure to testing frameworks and methodologies will help you grasp the content more quickly.
What will I build during this course?
Throughout the course, you will build a String Calculator using TDD, as demonstrated in a series of step-by-step lessons. You will also engage in practical exercises that involve dealing with exceptions, dependency injection, and refactoring, among others. These projects are designed to help you apply testing as a central part of the software design process, enhancing your ability to create flexible and maintainable code.
Who is the target audience for this course?
The course is intended for software developers and engineers who are looking to improve their understanding and application of TDD and BDD. It is especially useful for those who want to enhance their coding practices, reduce software defects, and improve system architecture. It is also suitable for those working with legacy code and seeking to introduce more robust design techniques into their workflow.
How does this course differ from other testing courses?
This course focuses on using TDD and BDD not just as testing techniques but as central components of the software design process. Unlike courses that focus solely on writing tests, this course emphasizes how tests can guide design decisions, improve code modularity, and facilitate better architectural outcomes. It also addresses common myths about TDD, providing a comprehensive view of its benefits and applications.
What specific tools or techniques will I learn?
You will learn techniques such as dependency injection, mocking, and refactoring, which are crucial for writing effective and maintainable tests. The course also covers the properties of good tests, the importance of naming in BDD, and how to listen to the code for feedback. Practical demonstrations, such as those involving the String Calculator and handling exceptions, provide hands-on experience with these tools.
What topics are not covered in this course?
While the course extensively covers TDD and BDD as design tools, it does not delve into specific testing frameworks or languages. The focus is on the principles and practices of test-driven and behavior-driven development rather than the implementation specifics of any particular software testing tool or platform.
How much time should I commit to this course?
The course consists of 30 lessons, and while the total runtime is not specified, you should plan to spend additional time on practical exercises and demonstrations. To fully benefit from the material, allocate time for hands-on practice beyond merely watching the lessons. The course is designed to help you integrate TDD and BDD into your workflow, which may require time for experimentation and application.