Exploring Extreme Programming
Input validation is the process of checking that an input value is legal according to some set of rules. We’ll look at some considerations of developing such code. Validation and Normalization Functions The simplest form of validation is a boolean Continue reading Input Validation – TDD Patterns
Sets are fundamental in mathematics — and programming. We’ll look at some considerations when using Test-Driven Development (TDD) for set-like objects. This is the last in a series of articles describing TDD for container objects; see the References for the Continue reading Set-Like Objects – TDD Patterns
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
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
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