Exploring Extreme Programming
How do you know if two objects are equal? One breakdown is to classify objects as value objects or reference objects. Value objects compare as equal when their component values are equal. Reference objects compare as equal only when it’s Continue reading Value Objects – TDD Patterns
A Builder (design pattern) lets you create an object piecemeal rather than requiring the data all at once. Let’s look at what’s involved in testing one into existence. Builder A builder has a constructor, methods that gather information, and a Continue reading Building a Builder – TDD Patterns
In Test-Driven Development (TDD), it’s hard to know what the next test should be – even if you know about Zero-One-Many or ZOMBIES. We’ll look at the challenge of observability – understanding an object, and we’ll look at a couple Continue reading Observability, Constructor Test, Invariants – TDD Patterns
The Zero-One-Many principle says that zero, one, and many are the three cases that make sense. (“A few” is more trouble than many.) This principle can guide you in splitting or expanding capabilities at multiple levels. You can use it Continue reading Zero-One-Many in Test-Driven Development
Duplication in production code leads to errors, but certain duplication in test code causes problems too. When test after test has the same structure, the part that varies (aka the interesting part) gets buried in the part that stays the Continue reading Parameterized Unit Testing
TDD with a user interface (UI) is a challenge: you have to decide which parts to test. Recently, Ted Young has been using the Yacht dice game (the root of the commercial game Yahtzee) as a testbed for TDD with Continue reading TDD & GUI in Swift
“Sufficient Completeness” is a characteristic of specifications, from the theory of abstract data types. It can help guide our testing. One way of looking at objects is to consider the history of what has happened to them: the sequence of Continue reading Sufficient Completeness and TDD
This article (originally published in Better Software) explores generalization in TDD. The basic notion is that refactoring sets out to not change the behavior of code for any of its inputs, but TDD sets out to change behavior (in the Continue reading Refactoring and Generalization in TDD
We’ll look at Test-Driven Development (TDD) and Test-Commit-Revert (TCR) in terms of how they work with frequent commits to source control. Test-Driven Development (TDD) Test-Driven Development is often described with this cycle: Red-Green-Refactor (or Red-Green-Gold, as I learned from Alex Continue reading TDD, TCR, and Frequent Commits
Kent Beck’s TCR workflow experiment has generated some good discussion. Rachel Carmena has documented several TDD workflows. I’d like to add an approach that I’ve used for a while: “Call Your Shots”. Call Your Shots If you’re playing pool seriously, you don’t just Continue reading The “Call Your Shots” TDD Workflow