Surgical Refactors

1.

None

2.

Hey, I'm @searls! justin@testdouble.com

3.

Hey, I'm @searls! justin@testdouble.com

4.

Hey, I'm @αʔϧζ! justin@testdouble.com

5.

ൃԻ͕೉͍͠ͷͰɺ೔ຊޠ Ͱδϡʔεͱਃ͠·͢ɻ justin@testdouble.com

6.

ൃԻ͕೉͍͠ͷͰɺ೔ຊޠ Ͱδϡʔεͱਃ͠·͢ɻ justin@testdouble.com

7.

I come from @testdouble. We are software consultants. Say hello@testdouble.com.

8.

None

9.

1. I talk fast when I'm nervous

10.

1. I talk fast when I'm nervous

11.

1. I talk fast when I'm nervous 2. I am
always nervous

12.

1. I talk fast when I'm nervous 2. I am
always nervous

13.

օ͞Μ΁ɺ͝ΊΜͳ͍ $

14.

օ͞Μ΁ɺ͝ΊΜͳ͍ ؤுͬͯԼ͍͞ʂ $

15.

I was very nervous about screen size

16.

16 9

17.

4 3

18.

Wait! ☝

19.

The secret to Ruby 3×3!

20.

3 3

21.

3 3 ✅

22.

_____ is a massively successful language!

23.

Early success

24.

Early success

25.

Early success

26.

Early success

27.

Early success: Making it easy to make new things

28.

Early success: Making it easy to make new things

29.

Later success

30.

Later success

31.

Later success

32.

Later success

33.

Later success: Making it easy to maintain old things

34.

Later success: Making it easy to maintain old things

35.

Can we make it easier to maintain old Ruby? Today's
Question:

36.

Can we make it easier to maintain old Ruby? Today's
Question:

37.

Today, let's refactor some legacy code

38.


39.

Refactor - verb

40.

Refactor - verb To change the design of code without
changing its observable behavior.

41.

Refactor - verb To change in advance of a new
feature or bug fix, making the job easier.

42.


43.


44.

Legacy code has many definitions

45.

Legacy Code - noun

46.

Legacy Code - noun Old code.

47.

Legacy Code - noun Code without tests.

48.

Legacy Code - noun Code that we don't like.

49.

Today, my definition is:

50.

Legacy Code - noun Code we don't understand well enough
to change confidently.

51.


52.

Refactoring is hard

53.

Refactoring legacy code is very hard

54.

Easy to accidentally break functionality

55.

Legacy refactors often feel unsafe

56.

Legacy refactors are hard to sell

57.

None

58.

Business Priority

59.

Business Priority Cost/Risk

60.

Business Priority Cost/Risk New Features

61.

Business Priority Cost/Risk New Features Bug Fixes

62.

Business Priority Cost/Risk New Features Bug Fixes Testing

63.

Business Priority Cost/Risk New Features Bug Fixes Testing

64.

Business Priority Cost/Risk New Features Bug Fixes Testing ???

65.

Business Priority Cost/Risk New Features Bug Fixes Testing Refactoring

66.

Business Priority Cost/Risk New Features Bug Fixes Testing Refactoring No
selling Needed

67.

Business Priority Cost/Risk New Features Bug Fixes Testing Refactoring Easy
to sell

68.

Business Priority Cost/Risk New Features Bug Fixes Testing Refactoring Can
often sell

69.

Business Priority Cost/Risk New Features Bug Fixes Testing Refactoring Very
hard to sell

70.

Refactors are hard

71.

Refactors are hard ⏲

72.


73.


74.

As complexity goes up

75.

As complexity goes up Greater importance

76.

As complexity goes up Less certain

77.

As complexity goes up More costly

78.

Make Refactors Great Again

79.

None

80.

Make Refactors Great for the 1st Time

81.

Business Priority Cost/Risk Refactoring

82.


83.


84.

Selling refactoring to businesspeople ⌨

85.


86.


87.

1. Scare them!

88.

1. Scare them! "If we don't refactor, then . !"

89.

to rewrite everything someday we'll need

90.

to rewrite everything someday we'll need Far in the future

91.

costs will be much higher your maintenance

92.

costs will be much higher your maintenance Hard to quantify

93.

2. Absorb the cost

94.

2. Absorb the cost New Feature Activities

95.

2. Absorb the cost Planning New Feature Activities

96.

2. Absorb the cost Development Planning New Feature Activities

97.

2. Absorb the cost Development Testing Planning New Feature Activities

98.


99.

Refactoring

100.

2. Absorb the cost Development Testing Planning Refactoring Requires extreme
discipline

101.

2. Absorb the cost Development Testing Planning Refactoring Collapses under
pressure

102.

3. Take hostages

103.

3. Take hostages Feature #1

104.

3. Take hostages Feature #1 Feature #2

105.

3. Take hostages Feature #1 Feature #2 Feature #3

106.

3. Take hostages Feature #1 Feature #2 Feature #3 Feature
#4

107.

3. Take hostages Feature #1 Feature #2 Feature #3 Technical.Debt

108.

3. Take hostages Feature #1 Feature #2 Technical Debt Technical.Debt

109.

3. Take hostages Feature #1 Feature #2 Blames business for
rushing Technical Debt Technical.Debt

110.

3. Take hostages Feature #1 Feature #2 Erodes trust in
the team Technical Debt Technical.Debt

111.

Refactoring is hard to sell

112.


113.


114.


115.


116.

Too much pressure!

117.

Too much pressure!

118.

Too much pressure! ⌛

119.

Too much pressure! ⌛ ⛏

120.

Refactors are scary!

121.

You should buy my book!

122.

THE FRIGHTENED PROGRAMMER JUSTIN SEARLS UGH SOFTWARE

123.


124.


125.

1. Refactoring Patterns

126.

1. Refactoring Patterns

127.

1. Refactoring Patterns • Extract method

128.

1. Refactoring Patterns • Extract method • Pull up /
push down

129.

push down • Split loop

130.

push down • Split loop Safer with good tools

131.

None

132.

push down • Split loop

133.

1. Refactoring Patterns Not very expressive • Extract method •
Pull up / push down • Split loop

134.

2. Characterization Testing

135.


136.


137.


138.


139.


140.


141.


142.


143.


144.


145.


146.

2. Characterization Testing No wrong answers!

147.


148.


149.


150.


151.


152.


153.


154.


155.


156.

2. Characterization Testing That's a lot of testing!

157.


158.

2. Characterization Testing It's hard to let go of characterization
tests

159.

2. Characterization Testing Tempting to quit halfway through

160.

3. A/B Testing / Experiments

161.


162.


163.

3. A/B Testing / Experiments Old code

164.

3. A/B Testing / Experiments Old code New code

165.

3. A/B Testing / Experiments Old code New code if
rand < 0.2

166.

rand < 0.2 true

167.

rand < 0.2 false true

168.


169.

rand < 0.2 false true

170.

rand < 0.2 false true Rewriting in big steps is confusing & error-prone

171.

rand < 0.2 false true Heavy monitoring & analysis required

172.

rand < 0.2 false true Experimenting on humans is risky

173.

None

174.

Characterization Testing

175.

None

176.

A/B Experiments

177.

Development

178.

Development Testing

179.

Development Testing Staging

180.

Development Testing Staging Production

181.

Development Testing Staging Production

182.

Development Testing Staging Production Development

183.

Development Testing Staging Production Development Testing

184.

Development Testing Staging Production Development Testing Staging

185.

Development Testing Staging Production Development Testing Staging Production

186.

Development Testing Staging Production De Te St Pr

187.

Development Testing Staging Production De Te St Pr

188.

Development Testing Staging Production De Te St Pr Development

189.

Development Testing Staging Production De Te St Pr Development Testing

190.

Staging

191.

Staging Production

192.

Staging Production ❓

193.

❓

194.

"Oh no, I have to give a talk on this"

195.

None

196.

None

197.

☝

198.

"Instead of slides, I'll write a gem!"

199.

TDD

200.

TDD (Talk-Driven Development)

201.

suture

202.

github.com/testdouble/suture

203.

None

204.

$ gem install suture

205.

Refactors as Surgeries

206.

Refactors as Surgeries

207.

Refactors as Surgeries Serve a common purpose

208.

Refactors as Surgeries Serve a common purpose ☺

209.

Refactors as Surgeries Require careful planning

210.

Refactors as Surgeries Flexible tools

211.


212.


213.

Refactors as Surgeries Follow a process

214.


215.


216.

Refactors as Surgeries Multiple Observations

217.


218.


219.

9

220.

9 F E A T U R E S

221.

Plan

222.

Plan Cut

223.

Plan Cut Record

224.

Plan Cut Record Validate

225.

Plan Cut Record Validate Refactor

226.

Plan Cut Record Validate Refactor Verify

227.

Plan Cut Record Validate Refactor Verify ⚖ Compare

228.

Plan Cut Record Validate Refactor Verify ⚖ Compare Fallback

229.

Plan Cut Record Validate Refactor Verify ⚖ Compare Fallback Delete
✂

230.

Plan

231.

Two Bug Fixes:

232.

Calculator service doesn't add negative numbers correctly. #1

233.

Pure function ❄

234.

class Controller def show calc = Calculator.new @result = calc.add(
params[:left], params[:right] ) end end

235.


236.


237.


238.

class Calculator def add(left, right) right.times do left += 1
end left end end

239.

end left end end

240.

end left end end

241.

end left end end

242.

end left end end

243.

end left end end

244.

end left end end

245.


246.

params[:left], params[:right] ) end end We will create our "seam" here

247.

Calculator tally service doesn't handle odd numbers correctly. #2

248.

Mutation ☣

249.

class Controller def index calc = Calculator.new params[:nums].each {|n| calc.tally(n)
} @result = calc.total end end

250.


251.


252.


253.


254.

class Calculator attr_reader :total def tally(n) @total ||= 0 n.downto(0)
do |i| if i * 2 == n @total += i * 2 end end return end end

255.


256.


257.


258.


259.


260.


261.


262.


263.

} @result = calc.total end end This seam is more complex

264.

✂

265.

Cut

266.

Pure function ❄

267.


268.

ss Controller ef show calc = Calculator.new @result = calc.add(
params[:left], params[:right] ) nd

269.

calc = Calculator.new @result = calc.add(eate :add, params[:left], params[:right] )
params[:left], params[:right] ]

270.

calc = Calculator.new @result = Suture.create :add, old: calc.method(:add), args:
[ params[:left], params[:right] ]

271.


272.


273.

[ params[:left], params[:right] ] :old must respond_to?(:call)

274.


275.

[ params[:left], params[:right] ] Initially a no-op; verify it still works

276.

Mutation ☣

277.


278.

ef index calc = Calculator.new params[:nums].each {|n| calc.tally(n) } @result
= calc.total nd

279.

calc = Calculator.new params[:nums].each {|n| calc.tally(n) :tally, old: ->(my_calc, m)
{ my_calc.tally(m) my_calc.total }, args: [calc, n] } @result = calc.total

280.

calc = Calculator.new params[:nums].each {|n| Suture.create :tally, old: ->(my_calc, m)

281.


282.

{ my_calc.tally(m) my_calc.total }, args: [calc, n] } @result = calc.total Wait, calc isn't an arg!

283.

How to design a seam

284.

❄Pure functions are easy

285.

❄Pure functions are easy Calculator#add(a,b)

286.

❄Pure functions are easy Calculator#add(a,b) (2,8)

287.

❄Pure functions are easy Calculator#add(a,b) (2,8) 10

288.

❄Pure functions are easy Calculator#add(a,b) (2,8) 10 (2,8)

289.

❄Pure functions are easy Calculator#add(a,b) (2,8) 10 (2,8) 10

290.

❄Pure functions are easy Calculator#add(a,b) (2,8) 10 (2,8) 10 Repeatable
input & output ✅

291.

Mutation is hard ☣

292.

Mutation is hard Calculator#tally(n) ☣

293.

Mutation is hard Calculator#tally(n) (4) ☣

294.

Mutation is hard Calculator#tally(n) (4) 4 ☣

295.

Mutation is hard Calculator#tally(n) (4) 4 ☣ (4)

296.

Mutation is hard Calculator#tally(n) (4) 4 ☣ (4) 8

297.

Mutation is hard Calculator#tally(n) (4) 4 ☣ (4) 8 @total=

298.

Mutation is hard Calculator#tally(n) (4) 4 ☣ (4) 8

299.

Mutation is hard Calculator#tally(n) 4 ☣ (4) 8 (calc@0,4)

300.

Mutation is hard Calculator#tally(n) 4 ☣ 8 (calc@0,4) (calc@0,4)

301.

Mutation is hard Calculator#tally(n) 4 ☣ (calc@0,4) (calc@0,4) 4

302.

Mutation is hard Calculator#tally(n) 4 ☣ (calc@0,4) (calc@0,4) 4 Repeatable
input & output ✅

303.


304.

{ my_calc.tally(m) my_calc.total }, args: [calc, n] } @result = calc.total Broaden the seam

305.


306.


307.


308.

{ my_calc.tally(m) my_calc.total }, args: [calc, n] } @result = calc.total Return a value

309.


310.

✂

311.

Record

312.

Pure function ❄

313.


314.

[ params[:left], params[:right] ], record_calls: true

315.

[ params[:left], params[:right] ], record_calls: true

316.

[ params[:left], params[:right] ], record_calls: true Most options support ENV: SUTURE_RECORD_CALLS=true

317.

Record some calls!

318.

Record via CLI

319.

controller = Controller.new controller.params = {:left => 5, :right =>
6} controller.show controller.params = {:left => 3, :right => 2} controller.show controller.params = {:left => 1, :right => 89} controller.show

320.


321.


322.


323.


324.


325.


326.


327.

Record via browser

328.

Record via browser add(4,5)

329.

Record via browser add(4,5)

330.

Record in production!

331.


332.


333.

Mutation ☣

334.

{ my_calc.tally(m) my_calc.total }, args: [calc, n], record_calls: true } @result = calc.total

335.

{ my_calc.tally(m) my_calc.total }, args: [calc, n], record_calls: true } @result = calc.total

336.

controller = Controller.new controller.params = {nums: [2,4,6]} controller.index controller.params =
{nums: [10,20,30]} controller.index controller.params = {nums: [4,11]} controller.index controller.params = {nums: [1,3,5,7,9]} controller.index

337.


338.


339.


340.


341.


342.


343.


344.


345.

Where does it go?

346.

Suture.config({ database_path: "db/suture.sqlite3" })

347.


348.


349.

Suture.config({ database_path: "db/suture.sqlite3" }) I heard Ruby was getting a
database!

350.

Suture.config({ database_path: "db/suture.sqlite3" }) Marshal.dump

351.

What about Rails?

352.

Gilded Rose Kata

353.

None

354.

require "suture" class ItemsController < ApplicationController def update_all Item.all.each do
|item| Suture.create :gilded_rose, :old => lambda { |item| item.update_quality! item }, :args => [item], :record_calls => true end redirect_to items_path end end

355.

None

356.

None

357.

None

358.

None

359.

None

360.

None

361.

None

362.

None

363.

None

364.

None

365.

None

366.

None

367.

None

368.

None

369.

None

370.

None

371.

It apparently works

372.

✂

373.

Validate

374.

Pure function ❄

375.

def test_validate_old_add calc = Calculator.new Suture.verify :add, subject: calc.method(:add) end

376.


377.


378.


379.


380.

Verifies each recorded args yield the recorded result

381.


382.


383.


384.

Cheap tests!

385.

Mutation ☣

386.

def test_old_tally Suture.verify:tally, subject: ->(calc, n){ calc.tally(n) calc.total } end

387.


388.


389.


390.


391.

Duplicate the lambda exactly

392.

Finally, a good use for code coverage!

393.

Gilded Rose Kata

394.

Trial # 1 Characterization tests

395.

None

396.

None

397.

Trial # 2 Suture.verify

398.

def test_gilded_rose_old Suture.verify :rose, subject: ->(items) { update_quality(items) items },
fail_fast: true end

399.

fail_fast: true end

400.

fail_fast: true end

401.

fail_fast: true end

402.

fail_fast: true end

403.

fail_fast: true end Items in, mutated items out

404.

fail_fast: true end

405.

fail_fast: true end All recordings expected to pass

406.

Check coverage before continuing

407.

None

408.

100% Coverage and zero tests

409.

✂

410.

Refactor

411.

I'm no refactoring expert

412.

I'm no refactoring expert

413.

I'm no refactoring expert That's why I needed this tool

414.

None

415.

Unlike my book, this book exists

416.

Pure function ❄

417.

end left end end

418.

end left end end Doesn't work for negative values!

419.

class Calculator def new_add(left, right) return left if right <
0 # ^ FIXME later left + right end end

420.


421.


422.


423.


424.

0 # ^ FIXME later left + right end end Retain current behavior exactly, bugs & all

425.

0 # ^ FIXME later left + right end end We don't know what else depends on bad behavior

426.

Mutation ☣

427.


428.

do |i| if i * 2 == n @total += i * 2 end end return end end Skips odd values!

429.

class Calculator def new_tally(n) return if n.odd? # ^ FIXME
later @total ||= 0 @total += n return end end

430.


431.


432.


433.

later @total ||= 0 @total += n return end end Still returns nil

434.


435.


436.


437.

later @total ||= 0 @total += n return end end "Make the change easy, then make the easy change" - Beck

438.

✂

439.

Verify

440.

Pure function ❄

441.

def test_new_add calc = Calculator.new Suture.verify :add, subject: calc.method(:new_add) end

442.


443.


444.


445.


446.

✅

447.

Mutation ☣

448.

def test_new_tally Suture.verify :tally, subject: ->(calc, n){ calc.new_tally(n) calc.total }
end

449.

end

450.

end

451.

end

452.

end

453.

end ❌

454.

end ❌ ⁉

455.

Judge a library by its messages

456.

None

457.

None

458.

# Verification of your seam failed! Descriptions of each unsuccessful
verification follows: ## Failures 1.) Recorded call for seam :tally (ID: 13) ran and failed comparison. Arguments: ``` [<Calculator:@total=nil>, 1] ``` Expected returned value: ``` 0 ``` Actual returned value: ``` nil ``` Ideas to fix this: * Focus on this test by setting ENV var `SUTURE_VERIFY_ONLY=13` * Is the recording wrong? Delete it! `Suture.delete!(13)`

459.

1.) Recorded call for seam :tally (ID: 13) ran and
failed comparison. Arguments: ``` [<Calculator:@total=nil>, 1] ``` Expected returned value: ``` 0 ``` Actual returned value: ``` nil ```

460.

Ideas to fix this: * Focus on this test by
setting ENV var `SUTURE_VERIFY_ONLY=13` * Is the recording wrong? Delete it! `Suture.delete!(13)`

461.

setting ENV var `SUTURE_VERIFY_ONLY=13` * Is the recording wrong? Delete it! `Suture.delete!(13)` Only run this failure

462.

setting ENV var `SUTURE_VERIFY_ONLY=13` * Is the recording wrong? Delete it! `Suture.delete!(13)` Delete bad recordings

463.

Failure advice ☹

464.

### Fixing these failures #### Custom comparator If any comparison
is failing and you believe the results are equivalent, we suggest you look into creating a custom comparator. See more details here: https://github.com/testdouble/suture#creating-a-custom-comparator #### Random seed Suture runs all verifications in random order by default. If you're seeing an erratic failure, it's possibly due to order-dependent behavior somewhere in your subject's code. To re-run the tests with the same random seed as was used in this run, set the env var `SUTURE_RANDOM_SEED=74735` or the config entry `:random_seed => 74735`. To re-run the tests without added shuffling (that is, in the order the calls were recorded in), then set the random seed explicitly to nil with env var `SUTURE_RANDOM_SEED=nil` or the config entry `:random_seed => nil`.

465.

### Fixing these failures #### Custom comparator If any comparison
is failing and you believe the results are equivalent, we suggest you look into creating a custom comparator. See more details here: https://github.com/testdouble/ suture#creating-a-custom-comparator

466.

Comparing Results

467.

Default Comparator

468.

==

469.

or

470.

) ( Marshall.dump Marshall.dump == ) (

471.

What about ActiveRecord?!

472.

.attributes == AR AR .attributes

473.

None

474.

!=

475.

!=

476.

!=

477.

Custom Comparators p q r s t

478.

What if Calculator had many other fields? class Calculator attr_reader
:created_at, :memory_val, :total # … end

479.

Suture.verify :tally, subject: ->(calc, n) { calc.new_tally(n) calc.total }, comparator:
->(recorded, actual) { recorded.total == actual.total }

480.


481.


482.


483.


484.


485.

Classes also exist!

486.

class CalcPare < Suture::Comparator def call(left, right) if super then
return true end left.total == right.total end end Suture.verify :tally, subject: ->(calc, n) { calc.new_tally(n) calc.total }, comparator: CalcPare.new

487.

class CalcPare < Suture::Comparator def call(left, right) if super then
return true end left.total == right.total end end Suture.verify :tally, subject: ->(calc, n) { calc.new_tally(n) calc.total }, comparator: CalcPare.new

488.

class CalcPare < Suture::Comparator def call(left, right) return true if
super left.total == right.total end end Suture.verify :tally, subject: ->(calc, n) { calc.new_tally(n) calc.total }, comparator: CalcPare.new

489.


490.


491.


492.

Returning to the error message

493.

#### Random seed Suture runs all verifications in random order
by default. If you're seeing an erratic failure, it's possibly due to order-dependent behavior somewhere in your subject's code. To re-run the tests with the same random seed as was used in this run, set the env var `SUTURE_RANDOM_SEED=74735` or the config entry `:random_seed => 74735`. To re-run the tests without added shuffling (that is, in the order the calls were recorded in), then set the random seed explicitly to nil with env var `SUTURE_RANDOM_SEED=nil` or the config entry `:random_seed => nil`.

494.


495.


496.

Discoverable configuration

497.

# Configuration This is the configuration used by this test
run: ``` { :comparator => Suture::Comparator.new, :database_path => "db/suture.sqlite3", :fail_fast => false, :call_limit => nil, # (no limit) :time_limit => nil, # (no limit) :error_message_limit => nil, # (no limit) :random_seed => 74735 } ```

498.


499.


500.


501.


502.


503.


504.


505.

A sense of progress

506.

# Result Summary - Passed........12 - Failed........1 - with error..0
- Skipped.......0 - Total calls...13 ## Progress Here's what your progress to initial completion looks like so far: [••••••••••••••••••••••••••••••••••••••◍◌◌◌◌] Of 13 recorded interactions, 12 are currently passing. That's 92%!

507.

# Result Summary - Passed........12 - Failed........1 - with error..0
- Skipped.......0 - Total calls...13 ## Progress Here's what your progress to initial completion looks like so far: [••••••••••••••••••••••••••••••••••••••◍◌◌◌◌] Of 13 recorded interactions, 12 are currently passing. That's 92%!

508.

Judge a library by its messages

509.

Wait, why did verification fail? ❌

510.


511.


512.


513.

class Calculator attr_reader :total def new_tally(n) return if n.odd? #
^ FIXME later @total ||= 0 @total += n return end end

514.


515.


516.

class Calculator attr_reader :total def new_tally(n) @total ||= 0 return
if n.odd? # ^ FIXME later @total ||= 0 @total += n return end end

517.

end

518.

end ✅

519.

✂

520.

⚖ Compare

521.

Our mission

522.

Our mission Development

523.

Our mission Development Testing

524.

Our mission Development Testing Staging

525.

Our mission Development Testing Staging Production

526.

Our progress

527.

✅Development Our progress

528.

✅Development ✅Testing Our progress

529.

✅Development ✅Testing ❓Staging Our progress

530.

✅Development ✅Testing ❓Staging ❓Production Our progress

531.

Pure function ❄

532.

class Controller def show calc = Calculator.new @result = Suture.create
:add, old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], call_both: true end end

533.


534.


535.

:add, old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], call_both: true end end Calls :new & :old

536.

:add, old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], call_both: true end end Calls :new & :old ✅

537.

You will find surprising inputs & outputs

538.

Mutation ☣

539.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true } @result = calc.total

540.


541.


542.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true } @result = calc.total ❌

543.

Another huge error message

544.

The results from the old & new code paths did
not match for the seam (Suture::Error::ResultMismatch) :tally and Suture is raising this error because the `:call_both` option is enabled, because both code paths are expected to return the same result. Arguments: ``` [<Calculator:@total=4>, 2] ``` The new code path returned: ``` 2 ``` The old code path returned: ``` 4 ``` Here's what we recommend you do next: 1. Verify that this mismatch does not represent a missed requirement in the new code path. If it does, implement it! 2. If either (or both) code path has a side effect that impacts the return value of the other, consider passing an `:after_old` and/or `:after_new` hook to clean up your application's state well enough to run both paths one-after-the-other safely. 3. If the two return values above are sufficiently similar for the purpose of your application, consider writing your own custom comparator that relaxes the comparison (e.g. only checks equivalence of the attributes that matter). See the README for more info on custom comparators. 4. If the new code path is working as desired (i.e. the old code path had a bug for this argument and you don't want to reimplement it just to make them perfectly in sync with one another), consider writing a one-off comparator for this seam that will ignore the affected range of arguments. See the README for more info on custom comparators. By default, Suture's :call_both mode will log a warning and raise an error when the results of each code path don't match. It is intended for use in any pre-production environment to "try out" the new code path before pushing it to production. If, for whatever reason, this error is too disruptive and logging is sufficient for monitoring results, you may disable this error by setting `:raise_on_result_mismatch` to false.

545.

Suture is raising this error because the `:call_both` option is
enabled, because both code paths are expected to return the same result. Arguments: ``` [<Calculator:@total=2>, 2] ``` The new code path returned: ``` 2 ``` The old code path returned: ``` 4 ```

546.


547.


548.


549.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total

550.


551.


552.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total protect from arg mutation

553.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total protect from arg mutation ☺

554.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total protect from arg mutation ❌

555.


556.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total calc never changes now!

557.


558.

{ my_calc.tally(m) my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total total is always nil

559.

{ my_calc.tally(m) calc = my_calc my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) calc = my_calc my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total

560.


561.


562.


563.

{ my_calc.tally(m) calc = my_calc my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) calc = my_calc my_calc.total }, args: [calc, n], call_both: true, dup_args: true } @result = calc.total ✅

564.


565.

Remember: every mode is optional!

566.

✂

567.

Fallback

568.

Make change safe for users

569.

New path errored? Try the old one! ♻

570.

Pure function ❄

571.


572.


573.

:add, old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], fallback_on_error: true end end

574.


575.

:add, old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], fallback_on_error: true end end Rescues :new with :old

576.

:add, old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], fallback_on_error: true end end Rescues :new with :old ✅

577.

Mutation ☣

578.


579.


580.

{ my_calc.tally(m) calc = my_calc my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) calc = my_calc my_calc.total }, args: [calc, n], fallback_on_error: true, dup_args: true } @result = calc.total

581.


582.

{ my_calc.tally(m) calc = my_calc my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(m) calc = my_calc my_calc.total }, args: [calc, n], fallback_on_error: true, dup_args: true } @result = calc.total ✅

583.

Faster than call_both

584.

Fewer side effects

585.

All errors are logged ✍

586.

Allow certain errors via expected_error_types

587.

✂

588.

Delete ✂

589.

Like stitches, remove once the wound heals ✂

590.

Pure function ❄

591.


592.

None

593.

Suture.delete_all!(:add)

594.

None

595.


596.


597.


598.


599.


600.


601.

:add, old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], ) fallback_on_error: true end end

602.

class Controller def show calc = Calculator.new @result = calc.new_add(
old: calc.method(:add), new: calc.method(:new_add), args: [ params[:left], params[:right] ], ) fallback_on_error: true end end

603.


604.


605.

Mutation ☣

606.

end

607.

None

608.

Suture.delete_all!(:tally)

609.

None

610.


611.


612.


613.


614.


615.


616.


617.


618.


619.

{ my_calc.tally(m) calc = my_calc my_calc.total }, new: ->(my_calc, m) { my_calc.new_tally(n) calc = my_calc my_calc.total }, args: [calc, n], fallback_on_error: true, dup_args: true } @result = calc.total

620.


621.


622.

calc = Calculator.new params[:nums].each {|n| calc.new_tally(n) } @result = calc.total

623.

calc = Calculator.new params[:nums].each {|n| calc.new_tally(n) } @result = calc.total

624.

We did it!

625.

Suture is ready to use!

626.

Suture is ready to use! github.com/testdouble/suture

627.

Suture is ready to use! 1.0.0

628.

Together, let's make refactors less scary

629.

One last thing…

630.

None

631.

None

632.

None

633.

None

634.

None

635.

None

636.

My homestay brother was also a programmer

637.

None

638.

None

639.

None

640.

None

641.

None

642.

None

643.

None

644.

None

645.

None

646.

None

647.

None

648.

None

649.

☺

650.

օ͞Μ΁ɺ

651.

օ͞Μ΁ɺ ͓࿩͢ΔػձΛ ͍͖ͨͩ͋Γ͕ͱ͏ʂ

652.

օ͞Μ΁ɺ ͓࿩͢ΔػձΛ ͍͖ͨͩ͋Γ͕ͱ͏ʂ ײँͷؾ࣋ͪͰ ͍ͬͺ͍Ͱ͢ʂ

653.

օ͞Μ΁ɺ ͓࿩͢ΔػձΛ ͍͖ͨͩ͋Γ͕ͱ͏ʂ ײँͷؾ࣋ͪͰ ͍ͬͺ͍Ͱ͢ʂ

654.

I'm @searls—tell me what you think !

655.

I'm in Kansai all month! justin@testdouble.com

656.

ɹ ΋͏Ұճ͋Γ͕ͱ͏ʂ

Surgical Refactors

Surgical Refactors

Want more?

Transcript