Exploring Extreme Programming
“Test Interface, Not Implementation” Perhaps you’ve heard the phrase “Test interface, not implementation”, or its relative, “Test behavior, not implementation”. We’ll look at this from the TDD perspective, growing a system in small steps of testing and refactoring. Note: I Continue reading “Test Interface, Not Implementation”
Two objects are coupled if changing one requires us to change the other. (See Yourdon and Constantine.) We’d like to reduce coupling, since it makes changing code more complicated. A change in a highly-coupled object requires a change in others, Continue reading How to Reduce Coupling, Three Ways
Recently I needed to implement a drag-and-drop reordering, with persistence. At least with SwiftUI, reordering is easy if it’s all in memory: you have an array of items, the UI tells you which ones were dragged and where, and you Continue reading Reordering Items, Four Ways
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