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
When you face something urgent, noisy, and insistent, your impulse is to feed the beast even if it isn’t the most important thing right now. I knew a team that was well-regarded but wasn’t delivering as fast as the business Continue reading Feed the Beast – A Cautionary Tale
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
A fixed-size counter (triggered by some sort of pulse) is a common way to represent time. When you use this approach, you generally have to answer three questions: Answering those questions lets you answer several other questions: (For all these, Continue reading Time Troubles – Binary Timer Overflow
The Template Method design pattern defines an algorithm in an abstract class, and defers some steps to its subclasses. A Strategy defines a family of pluggable implementations. We’ll see how to convert from Template Method to Strategy. Template Method A Continue reading Refactor Template Method to Strategy
State machines are useful, but how do we know they’re correct? We’ll look at several aspects of testing state machines: the machines themselves, and the interpreter and direct code implementations. The “State Machines” Series Levels of Testing When using state Continue reading State Machines, part 4: Testing
Today we’ll look at how to implement state machines as direct code. In part 1, we looked at what state machines are. In part 2, we looked at how you might implement them with an interpreter that process a data Continue reading State Machines, Part 3: Direct Code