Exploring Extreme Programming
Would-be agile teams sometimes get stuck in half-waterfall, a combination of waterfall and agile. Half-waterfall has the costs of both agile and waterfall approaches, but may not get enough benefit to offset the extra cost. Or, it may be a Continue reading Half-Waterfall: Extra Cost, Uncertain Benefits
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
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
It’s easy to throw around terms like Customer and User, but what do they mean? They’re actually complex concepts, and our goal for stories is sometimes not for the user’s direct benefit. Customers are a subset of Stakeholders, or the Continue reading Who is the Customer?
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