Exploring Extreme Programming
We’ll look at how Arrange-Act-Assert (AAA) tests reflect the lifecycle of the objects we’re working with. Object Lifecycle An object has a basic lifecycle: create (command | query)* (abandon | delete) That is, create the object, do a series of Continue reading AAA and the Object Lifecycle
“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
I’m frustrated when unit tests run slowly. One way to speed them up in Xcode when developing using a simulator: isolate your model to a framework, and run your tests without a host application. Context: Developing a Swift-based app for Continue reading Run Tests Without an App — Step by Step with Xcode
Apple has introduced a new unit testing framework. It has a simpler syntax, much simpler assertions, parameterized testing, and more. Let’s take a look. You can find a bonus cheatsheet at the end of this article. Easier Syntax XCTest (the Continue reading Swift Testing – A New Unit Testing Framework
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