Exploring Extreme Programming
When you have hierarchical information, a tree is a natural representation. We’ll look at ways to test-drive trees and their close variants. Trees A tree consists of nodes which may have child nodes. The nodes form a hierarchy – no Continue reading Tree-Like Objects – TDD Patterns
In a perfect world, we don’t have to worry about errors. That’s not this world, however. Here, handling errors can easily be half the effort of doing things. We’ll look at a basic test structure, several ways to report errors, Continue reading Errors and Exceptions – TDD Patterns
In incremental development, we grow a system by adding capabilities one at a time. Our bet is that we won’t often hit a dead end, but if we do, the time we’ve already saved will let us dig our way Continue reading Disaster Strikes! A Design Dead End
Sometimes, TDD goes smoothly from story to story, or micro-story to micro-story. Other times, we aren’t clear how to proceed, and do a spike. But there’s a third approach I use occasionally, when I’m in a new area and want Continue reading Trailblaze and Pave – TDD Patterns
Software is hard to create. (This isn’t news.) All we want is two things: everything we have, and more. Is that too much to ask? Stability and progress conflict: changes we make for progress threaten stability. Test-driven development is a Continue reading TDD: Balancing Progress with Stability
List-like objects include linked lists, arrays (somewhat), stacks, queues, deques, heaps, etc. While we can often just pull one from a standard library, other times we have to create our own “linear” types. Let’s look at some tools for test-driving Continue reading List-Like Objects – TDD Patterns
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