Exploring Extreme Programming
To refactor is to systematically “improve the design of existing code”. There are many ways to classify refactorings, but one distinction stands out to me: local refactorings. A local refactoring affects only one file (and perhaps its tests). Why Local? Continue reading Local Refactorings
Primitive types are the basis of others. They’re typically small (ish), and don’t involve repetition or recursion. We’ve already looked at numbers; today we’ll look at Booleans, characters, and simple enumerations. Beyond that, we’ll look at combining values via product Continue reading Primitives, Products, and Sums – TDD Patterns
Partitions can help us divide up our input space for testing purposes, but what drives the partitions we use, and how do we choose suitable examples for TDD? We’ll look at several concerns: Problem-Oriented Partitions Solution-Oriented Partitions Partitions Arising from Continue reading Integers, Floats, and Partitions – TDD Patterns
Alchemists sought to transmute lead into gold. TDD turns a small set of examples into code that handles the whole range of inputs. Quite a trick – how does it work? TDD often implicitly uses the idea of partitions; we’ll Continue reading TDD is an Alchemy Trick: Points and Partitions
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
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