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
How do you track user stories? Does it help your team work better? We’ll compare multiple different approaches. Why Track? Why do we want to track user stories? There are several reasons, some better than others. We want to: understand Continue reading 7+ Ways to Track User Stories
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