Exploring Extreme Programming
When A depends on B (A → B), a change in B may force A to change as well. Dependencies are both good and bad: they let objects work together, but they make software harder to change. We can use Continue reading Reduce Dependencies Using Lambda
“Iterative Enhancement” is a model for iterative development, from Basili & Turner, described in 1975 (!). We’ll look at it, and compare it to XP’s approach. I’ve seen occasional mention of this paper in people writing about evolutionary design or Continue reading Iterative Enhancement and XP-Style Design
Some languages (e.g., Swift, C#, Java) support extension methods. These let you add new methods to an existing class, even a system class. Extension methods support testing by providing convenient improvements in control and visibility. Extension Methods I’ll show Swift Continue reading Extension Methods for TDD
An object holds state, and you observe and control it (or both) through its public fields or methods. We’ll look at techniques you can use when an object provides no direct way to observe or control it the way a Continue reading Observe and Control Objects – TDD Patterns
Code that writes code is fun in a meta sort of way, but it requires extra testing. We’ll start by considering generic systems and their tests, then look at testing for code generation. “I’d rather write programs to write programs Continue reading Code That Writes Code Needs Multi-Level Tests
A user can treat a product as a black box – “I like what it does, even though I don’t know how it works.” A product owner doesn’t have that luxury. Friend 1 – That’s a big trip you’re planning Continue reading A Product Owner Can’t Own a Black Box
Some exception-handling code peels apart exceptions to figure out how to handle them. This is a missed opportunity for more direct code. The Simple Case: Type-Tested Exceptions Sometimes we see handler code like this: catch (Exception e) { // possible Continue reading Refactoring Undifferentiated Exceptions
For most sorting problems, we use a pre-existing algorithm. Then, our job is to create a comparator that reflects the desired order. What is Sorting? Suppose you have a sequence of items a[0]…a[n-1], and an operator “<=”. The sorted sequence Continue reading TDD for Sorting, Using Comparators
Extracting a local lambda turns a block of code into an anonymous inline function. Motivation A local lambda can isolate code for improvement (the Isolate-Improve-Inline pattern – see References), or be the first step in using a lambda another way. Continue reading Refactoring: Extract Local Lambda
Sometimes, when you try to break up a long method, you run into a problem: you have to pass a bunch of local variables into the new method, some of which are both input and output. One solution is the Continue reading Refactoring: Replace Method with Method Object