Exploring Extreme Programming
Sometimes you want to change from using a basic type (such as Int or String) to a type that contains the basic type as a value. (See Refactoring in the References.) The change itself isn’t hard, but then you have Continue reading Wrapping a Type, All the Way
I developed the INVEST model years ago to help someone (and then many people) think about the user stories they were creating. Is INVEST all you need to create good stories? Unfortunately, no. INVEST Briefly, INVEST (see References) is an Continue reading All You Need is INVEST? No!
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
Once in a while, I run into a 1980s-era BASIC program, typically written for Commodore 64, Apple ][, or TRS-80. I’d like to transliterate it into a modern language, refactor it, and explore it. These old programs make a nice Continue reading Transliterating Old-School BASIC
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
As you refactor, you sometimes need to understand how the data flow through the code. We’ll look at several ways that can reveal that information. Data Flow Analysis Data flow analysis tracks the creation and use of data through the Continue reading Data Flow Analysis for Refactoring
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