Exploring Extreme Programming
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)
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
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