## Pages

### Micro refactoring - from here to there

One of my Mastery book snippets from a few days ago reads:

Masters ... are zealots of practice, connoisseurs of the small, incremental step.

I was doing the roman numerals kata in ruby and something related to small incremental steps occurred to me. Here's three tests:

```def test_to_roman
assert_equal "I", to_roman(1)
assert_equal "II", to_roman(2)
assert_equal "III", to_roman(3)
end
```

and here's the first code snippet:

```def to_roman(n)
roman = ''
if n == 3
roman = 'III'
end
if n == 2
roman = 'II'
end
if n == 1
roman = 'I'
end
roman
end
```

I can refactor these three if statements into a single while statement, in very small steps, as follows:

```def to_roman(n)
roman = ''
if n >= 3
roman += 'I'
n -= 1
end
if n >= 2
roman += 'I'
n -= 1
end
if n >= 1
roman += 'I'
n -= 1
end
roman
end
```

and then:

```def to_roman(n)
roman = ''
if n >= 1
roman += 'I'
n -= 1
end
if n >= 1
roman += 'I'
n -= 1
end
if n >= 1
roman += 'I'
n -= 1
end
roman
end
```

and then:

```def to_roman(n)
roman = ''
while n >= 1
roman += 'I'
n -= 1
end
roman
end
```

Ok. Now here's the original again:

```def to_roman(n)
roman = ''
if n == 3
roman = 'III'
end
if n == 2
roman = 'II'
end
if n == 1
roman = 'I'
end
roman
end
```

And this time I refactor in a different direction, towards an array lookup:

```def to_roman(n)
units = [ '', 'I', 'II', 'III' ]
roman = ''
if n == 3
roman = units[3]
end
if n == 2
roman = units[2]
end
if n == 1
roman = units[1]
end
roman
end
```

And then:

```def to_roman(n)
units = [ '', 'I', 'II', 'III' ]
roman = ''
if n == 3
roman = units[n]
end
if n == 2
roman = units[n]
end
if n == 1
roman = units[n]
end
roman
end
```

And then:

```def to_roman(n)
units = [ '', 'I', 'II', 'III' ]
roman = ''
if n == 3
roman = units[n]
end
if n == 2
roman = units[n]
end
if n == 1
roman = units[n]
end
roman
units[n]
end
```

And then:

```def to_roman(n)
units = [ '', 'I', 'II', 'III' ]
units[n]
end
```

In this case I can refactor from a sequence of if statements in two directions equally easy - towards a while or towards an array lookup. Ok. Now consider the situation if I was starting from a switch instead of a sequence of ifs:

```def to_roman(n)
case n
when 3 then 'III'
when 2 then 'II'
when 1 then 'I'
end
end
```

From this I can easily refactor towards an array lookup but refactoring towards a while is perhaps not quite so straightforward.

I'm suggesting that a construct is useful not just in it's own right but also in relation to all the other constructs it might get refactored to or from. How easily can I move from one construct to another? Do some constructs live only on one-way roads? Do some lead you down more dead-ends than others?

I'm reminded of the family on holiday in the West Country who got thoroughly lost. Spotting a farmer leaning on a gate they stop the car, wind down the window and ask

Excuse me. Can you tell me how to get to Nempnett Thrubwell?

The old farmer looks at them and says

Well.... you don't want to start from here.