Exploring Extreme Programming
Suppose you want to represent a finite set of possibilities in a compact way. An And-Or Tree can do this, and is useful in several situations. An And-Or Tree has leaf nodes and interior nodes. The leaf nodes contain some Continue reading And-Or Trees
Our “geek” group tackled a problem a couple weeks ago, that one of us had heard suggested by Michael Feathers: given a sequence of numbers, tell how many non-zero runs it has. Ron Jeffries described a procedural implementation; we’ll look Continue reading TDD with a Function Pipeline
Test-Driven Development (TDD) depends on assembling well-tested parts into a trustworthy whole. Some design structures make this easier. Today, we’ll look at trees. A tree is a structure consisting of leaf and interior nodes. An interior node contains some number Continue reading Trees – Confidence in Design
The other day, Kent Beck pointed out a skill that test-driven development (TDD) relies on but doesn’t give much guidance about: “behavioral composition”. This is the skill of dividing a big behavior in such a way that we trust the Continue reading Pipelines – Confidence in Design
Let’s look at the threaded code approach. It’s a less-well-known way to build an interpreter for a programming language. (The more common approach simulates each instruction.) Threaded code has a high-level analog, and some extra tricks when done in assembly Continue reading Threaded Code (and Composite)
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
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