Exploring Extreme Programming
Today we’ll look at how to implement state machines as direct code. In part 1, we looked at what state machines are. In part 2, we looked at how you might implement them with an interpreter that process a data Continue reading State Machines, Part 3: Direct Code
In Part 1, we looked at state machines and some common variants. This time we’ll look at code: how can you implement state machines? We’ll look at several approaches, in two classes: interpreter and direct-coded. (You could think “interpreter vs Continue reading State Machines, Part 2: Interpreter Code
State machines are a very useful abstraction for behavior, but not everybody has run across them. This tool is useful for programmers, and for anybody else who is trying to create or understand a system. Why take the trouble to Continue reading State Machines: Part 1, Principles
Some teams try to start projects directly with user stories, but many important things need to happen earlier to make those effective. Chartering (aka Liftoff) provides a better way to structure the start of a project. Beyond that, there are Continue reading Chartering and more: What happens before user stories?
Your code sometimes evolves to have two or more arrays operating in parallel. If these arrays work in lockstep, it might be better to have one array with objects instead. Let’s look at an example refactoring from one to the Continue reading Refactor: Parallel Arrays to Array of Objects
“If” statements often attract complexity. They gather compound conditions that are hard to understand. More “if” statements get nested inside. It gets hard to know under what conditions any bit of code will run. “Duplicate and Customize” is a refactoring Continue reading Refactor: Duplicate and Customize
I’ve been involved with several projects over the last few months, and each has user stories associated with it. People often ask for examples of user stories, so I thought I’d share these. The Form By default, I use the Continue reading Examples of User Stories 2020
When a “raw” type appears in a protocol, it encourages it to spread all over. Recently, I needed to encapsulate a type: I had used “array of integer” ([Int]) in a number of places, and I wanted to change this Continue reading Refactor: Change Signature on a Protocol [Interface]
For most problems, we have a choice: implement current needs only, or generalize the solution to more easily handle variations we expect to need in the future. The evolutionary design community refers to the latter approach as speculative generality, and Continue reading Speculative Generality
This post summarizes the material on xp123.com related to refactoring in Swift. Swift Refactorings Divide Class into Class + Extension Extract Protocol Other Refactoring-Related Material Refactoring – articles tagged on xp123.com Resources on Refactoring – pointers to other sites’ materials