Exploring Extreme Programming
Time is a well-known source of trouble for programmers. We looked earlier at one type of time troubles: overflow. Today, I’d like to look at another time trouble: transitions. Here are the problems we’ll see: Simultaneous Transitions Different units of Continue reading Time Troubles – Transitions
Sometimes, we feel that something we extracted isn’t as good as it could be. The Inline-Adjust-Extract refactoring pattern can help fix that. It has three steps: In a sense, this pattern is the opposite of the Isolate-Improve-Inline pattern. That tactic Continue reading Refactor: Inline-Adjust-Extract
When you’re making a class, in what order do you put the fields and methods? We’ll look at several choices and some tradeoffs between them. Organizing Fields I’ve seen a few approaches to organizing fields: In C#, Swift, and some Continue reading Organizing Fields and Methods
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
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
Many domains are shallow and impoverished, e.g., apps that exist to write well-understood fields into a database. A rich domain has many concepts (some contradictory); it has lots of history; and it’s full of incidental complexity, the consequences of human Continue reading Swimming in a Rich Domain