Exploring Extreme Programming
Environments vary substantially between computers, so you’ll often see environment-specific code hidden in the PEEKs and POKEs of old BASIC programs. We’ll take a brief tour of the Ohio Scientific and Commodore 64, two computers from the late 1970s to Continue reading Ohio Scientific and Commodore 64 Environments
When we’re creating or extending systems, there’s often one type of user that’s our main focus. We often have no trouble thinking up capabilities they need. But other types of users are often forgotten. We need to enlarge our view, Continue reading Forgotten Stories
When we create test data in TDD, we do it to drive out new capabilities. But all test data is not of the same value. If your data has the wrong symmetry, it can mislead you about what’s working. Object Continue reading Avoid Irrelevant Symmetry!
When working with objects, there are different ways you can make them interact. We’ll take a quick look at a variety of connections, what’s needed to test them, and some alternatives you might consider. The connections below are in generally Continue reading Testing Objects and Relationships
Some refactorings (e.g., Extract Method or Extract Class) introduce new elements. Should you revise the tests to take these into account? The classic consultant’s answer applies: It depends. The obvious next question is “Depends on what?”, and we’ll explore some Continue reading Revise Tests While Refactoring? It Depends
A certain type of science-intensive application only has a few (or even no) control parameters. It is usually driven by a “big data” analysis. The algorithms inside may or may not be very complex. There are many applications like this: Continue reading Science-Intensive Apps: Handle with Care
Objects usually track state, but you can instead track history and derive the current state from the history. (For example, databases blend both modes behind the scenes.) Why might history be helpful? One reason is that it can make it Continue reading Reversible, Incremental Data Structures
Authorization is the process of deciding whether to allow a user can access or use some resource. (Don’t confuse it with authentication, the process of deciding whether a user is who they claim to be.) TDD and Authorization From a Continue reading Authorization – TDD Patterns
Evolutionary design works by growing a system one capability at a time, keeping the design just sufficient for the system so far. As needs change, the system evolves to meet them. Evolutionary design has its technical challenges, but limiting beliefs Continue reading Limiting Beliefs About Evolutionary Design
See also “The Gerrymander Game – Part 1, Puzzle“ I implemented the core of the gerrymandering game using TDD, and it was a challenge. Why? Because I didn’t know in advance how to solve it. My Overall Strategy To make Continue reading The Gerrymander Game – Part 2, TDD