Let's Do Some Upfront Design - WindyCityRails 2014

Let’s Do Some Upfront Design
Windy City Rails 2014
Mark Menard
@mark_menard !
Enable Labs
Enable Labs @mark_menard
LetsDoSomeUpfrontDesign-WindyCityRails2014 - September 4, 2014

Who likes TDD?

Rename Method
Inline Method
Replace Method with Method Object
Extract Class
Who likes refactoring?
Rename Class
Replace Temp with Query
Extract Method
Move Method

Extract Method
Move Method
Replace Method with Method Object
Extract Class
Enable Labs 5 @mark_menard

A Tale of a Refactoring

# some_ruby_program -v -efoo

# some_ruby_program -v -efoo
!
options = CommandLineOptions.new(ARGV) do
option :v
option :e, :string
end
!
if options.has(:v)
# Do something
end
!
if options.has(:e)
some_value = options.value(:e)
# Do something with the expression
end

describe CommandLineOptions do
!
describe "boolean options" do
let(:options) { CommandLineOptions.new { option :c } }
it "are true if present" do …
it "are false if absent" do …
end
!
describe "string options" do
let(:options) { CommandLineOptions.new { option :e, :string } }
it "must have content" do …
it "can return the value" do …
it "return nil if not in argv" do …
end
end
9

CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content
can return the value
return nil if not in argv
!
Finished in 0.00236 seconds
5 examples, 0 failures

class CommandLineOptions
!
attr_accessor :argv
attr_reader :options
!
def initialize (argv = [], &block)
@options = {}
@argv = argv
instance_eval &block
end
!
def has (option_flag)
options.include?(option_flag) && argv.include?("-#{option_flag}")
end
!
def option (option_flag, option_type = :boolean)
options[option_flag] = option_type
end
!
def valid?
options.each do |option_flag, option_type|
return false if option_type == :string && raw_value_for_option(option_flag).length < 3
end
end
!
def value (option_flag)
raw_option_value = raw_value_for_option(option_flag)
return nil unless raw_option_value
option_type = options[option_flag]
return raw_option_value[2..-1] if option_type == :string
end
!
private def raw_value_for_option (option_flag)
argv.find { |arg| arg =~ /-#{option_flag}/ }
end
!
end

# some_ruby_program -v -efoo -i100
!
options = CommandLineOptions.new(ARGV) do
option :v
option :e, :string
option :i, :integer
end
!
verbose = options.value(:v)
expression = options.value(:e)
iteration_count = options.value(:i) || 1

describe "integer options" do
it "must have content"
it "must be an integer"
it "can return the value as an integer"
it "returns nil if not in argv"
end

CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content
integer options
must have content (PENDING: No reason given)
must be an integer (PENDING: Not yet implemented)
can return the value as an integer (PENDING: Not yet implemented)
returns nil if not in argv (PENDING: Not yet implemented)

CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content
is valid when there is content
integer options
must have content
must be an integer
can return the value as an integer
!
Pending:
CommandLineOptions integer options returns nil if not in argv
# Not yet implemented
# ./spec/command_line_options_spec.rb:61
!
Finished in 0.00291 seconds
10 examples, 0 failures, 1 pending

class CommandLineOptions !
attr_accessor :argv
attr_reader :options !
def initialize (argv = [], &block)
@options = {}
@argv = argv
instance_eval &block
end !
def has (option_flag)
options.include?(option_flag) && argv.include?("-#{option_flag}")
end !
def valid?
options.each do |option_flag, option_type|
return false unless option_valid?(option_type, raw_value_for_option(option_flag))
end
end !
def value (option_flag)
raw_option_value = raw_value_for_option(option_flag)
return nil unless raw_option_value
option_type = options[option_flag]
return extract_value_from_raw_value(raw_option_value) if option_type == :string
end !
private def option (option_flag, option_type = :boolean)
options[option_flag] = option_type
end !
private def option_valid? (option_type, raw_value)
send("#{option_type}_option_valid?", raw_value)
end !
private def string_option_valid? (raw_value)
extract_value_from_raw_value(raw_value).length > 0
end !
private def integer_option_valid? (raw_value)
extract_value_from_raw_value(raw_value).length > 0 && (Integer(extract_value_from_raw_value(raw_value)) rescue false)
end !
private def boolean_option_valid? (raw_value)
true
end !
private def extract_value_from_raw_value (raw_value)
raw_value[2..-1]
end !
private def raw_value_for_option (option_flag)
argv.find { |arg| arg =~ /-#{option_flag}/ }
end !
end

Oooooof! !
!
This class is getting big…

So… let’s extract a class and move
some methods.

describe StringOption do
let(:string_option) { StringOption.new('s', '-sfoo') }
!
it "has a flag"
it "is valid when it has a value"
it "can return it's value when present"
it "returns nil if the flag has no raw value"
end

CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content
integer options
must have content
must be an integer
!
StringOption
has a flag (PENDING: No reason given)
is valid when it has a value (PENDING: Not yet implemented)
can return it's value when present (PENDING: Not yet implemented)
returns nil if the flag has no raw value (PENDING: Not yet implemented)

class StringOption
!
attr_reader :flag
!
def initialize (flag, raw_value)
@flag = flag
@raw_value = raw_value
end
!
end

class CommandLineOptions
!
private def string_option_valid? (raw_value)
extract_value_from_raw_value(raw_value).length > 0
end
!
end
class StringOption
!
attr_reader :flag, :raw_value
!
@flag = flag
end
!
def valid?
extract_value_from_raw_value.length > 0
end
!
private def extract_value_from_raw_value
raw_value[2..-1]
end
!
end

Ow, ow, ow, ow… ow!

The Extract Class and Move Method
refactorings are VERY expensive.

class StringOption
!
!
@flag = flag
end
!
def valid?
end
!
raw_value[2..-1]
end
!
end

class IntegerOption
!
!
@flag = flag
end
!
def valid?
extract_value_from_raw_value.length > 0 && real_value_is_integer?
end
!
raw_value[2..-1]
end
!
private def real_value_is_integer?
(Integer(extract_value_from_raw_value) rescue false)
end
!
end

class BooleanOption
!
!
@flag = flag
end
!
def valid?
true
end
!
def value
!!raw_value
end
end

class Option
!
!
@flag = flag
end
!
end
!

class StringOption < Option
!
def valid?
end
!
raw_value[2..-1]
end
!
end

class IntegerOption < Option
!
def valid?
extract_value_from_raw_value.length > 0 && real_value_is_integer?
end
!
raw_value[2..-1]
end
!
private def real_value_is_integer?
(Integer(extract_value_from_raw_value) rescue false)
end
!
end

class BooleanOption < Option
!
def valid?
true
end
!
def value
!!raw_value
end
end

CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content
integer options
must have content
must be an integer
returns nil if not in argv
!
StringOption
has a flag
is valid when it has a value
can return it's value when present
returns nil if the flag has no raw value
Duplication!

All code is an impediment to change.

Including your tests!

Can we avoid this churn?

Do some upfront design!

But that’s not agile… right?

Sequence Diagrams!
Collaboration Diagrams!
Mental Experiments!
Playing with Code / Exploratory Tests

Container Cost Calculations
• Bunker Charge (fuel charge)!
• Taxes!
• Carrier Surcharges

class ShipmentCostCalculator
def initialize (type: type, shipment: shipment)
@type = type
@shipment = shipment
end
!
def calculate
cost = 0
itinerary = shipment.itinerary
carrier = shipment.carrier
!
# Calculate bunker charge
!
distance = itinerary.segments.sum(&:distance_in_km)
cost += carrier.bunker_charge_per_km * distance
!
# Calculate taxes
!
cost += itinerary.segments.select { |s| s.taxable? }.sum(&:tax_fee)
!
# Calculate surcharges
!
cost += carrier.surcharges.sum(&:charge)
cost
end
end

@type = type
end
!
def calculate
cost = 0
!
!
!
# Calculate taxes
!
!
!
cost
end
end
What

@type = type
end
!
def calculate
cost = 0
!
!
!
# Calculate taxes
!
!
!
cost
end
end
How

@type = type
end
!
def calculate
cost = 0
!
!
!
# Calculate taxes
!
!
!
cost
end
end
What
How

attr_reader :shipment, :itinerary, :carrier
!
def initialize (shipment: shipment)
@itinerary = shipment.itinerary
@carrier = shipment.carrier
end
!
def calculate
calculate_bunker_charge +
calculate_tax_charge +
calculate_surcharge
end
!
def calculate_bunker_charge
carrier.bunker_charge_per_km * distance
end
!
def calculate_tax_charge
itinerary.segments.select { |s| s.taxable? }.sum(&:tax_fee)
end
!
def calculate_surcharge
carrier.surcharges.sum(&:charge)
end
!
end
What
How

Processor Coordinator
Coordinator Coordinator
Coordinator
Processor
Processor
Processor
Processor
Processor
Processor
Processor Coordinators
vs Processors
Processor
Processor

How What
What What
How
How
What
How
How
How
How
How Coordinators
vs Processors
How
How

What How

Coordinator Processor

So, how do I build that without the
churn?

So, how do I build that without the churn?
1. Identify a top level Coordinator and give it a descriptive name based
on the use case.

end

on the use case.!
2. Write a failing top level feature spec that runs everything without test
doubles using real data.

require 'spec_helper'
!
describe "shipment cost calculation feature" do
before(:each) do
setup_itineraries
setup_carrier_charges
end
!
describe "basic shipment" do
let(:shipment) { build(:basic_shipment) }
!
it "should correctly calculate shipment charge" do
calculator = ShipmentCostCalculator.new(shipment: shipment)
expect(calculator.calculate).to eq(1200)
end
end
!
# more scenarios...
!
end

attr_reader :shipment
!
def initialize (shipment:)
end
!
def calculate
end
end

on the use case.!
doubles using real data.!
3. Write a failing coordinator spec using test doubles for the top level
coordinator.!
1. Identify other collaborators and inject them using test doubles.

!
describe "shipment cost calculation" do
!
let(:shipment) { double }
let(:bunker_charge_calculator) {
double("bunker_charge_calculator", :calculate => 1)
}
!
let(:shipment_cost_calculator) {
ShipmentCostCalculator.new(shipment: shipment)
}
!
before(:each) do
expect(BunkerChargeCalculator).to receive(:new).and_return(bunker_charge_calculator)
end
!
it "uses a bunker charge calculator" do
expect(bunker_charge_calculator).to receive(:calculate).once.with(shipment)
shipment_cost_calculator.calculate
end
!
end

on the use case.!
3. Write a failing coordinator spec using test doubles for the top level
coordinator.!
1. Identify other collaborators and inject them using test doubles.!
4. Make the top level Coordinator pass the spec.

attr_reader :shipment, :bunker_charge_calculator
!
def initialize (shipment:,
bunker_charge_calculator: BunkerChargeCalculator.new)
!
@bunker_charge_calculator = bunker_charge_calculator
end
!
def calculate
bunker_charge_calculator.calculate(shipment)
end
!
end

!
!
let(:shipment) { double }
let(:bunker_charge_calculator) { double("bunker_charge_calculator", :calculate => 1) }
!
let(:shipment_cost_calculator) {
ShipmentCostCalculator.new(shipment: shipment)
}
!
before(:each) do
expect(BunkerChargeCalculator).to receive(:new).and_return(bunker_charge_calculator)
expect(TaxChargeCalculator).to receive(:new).and_return(tax_charge_calculator)
expect(SurchargeCalculator).to receive(:new).and_return(surcharge_calculator)
end
!
it "uses a bunker charge calculator" do
expect(bunker_charge_calculator).to receive(:calculate).once.with(shipment)
end
!
it "uses a tax charge calculator" do
expect(tax_charge_calculator).to receive(:calculate).once.with(shipment)
end
!
it "uses a surcharge calculator" do
expect(surcharge_calculator).to receive(:calculate).once.with(shipment)
end
!
it "returns the sum of bunker charge, tax charge, and shurcharges" do
expect(shipment_cost_calculator.calculate).to eq(6)
end
end

attr_reader :shipment, :bunker_charge_calculator
attr_reader :tax_charge_calculator, :surcharge_calculator
!
def initialize (shipment:,
bunker_charge_calculator: BunkerChargeCalculator.new,
tax_charge_calculator: TaxChargeCalculator.new,
surcharge_calculator: SurchargeCalculator.new)
!
@bunker_charge_calculator = bunker_charge_calculator
@tax_charge_calculator = tax_charge_calculator
@surcharge_calculator = surcharge_calculator
end
!
def calculate
bunker_charge_calculator.calculate(shipment) +
tax_charge_calculator.calculate(shipment) +
surcharge_calculator.calculate(shipment)
end
!
end

!
!
# . . .
it "returns the sum of bunker charge, tax charge, and shurcharges" do
expect(shipment_cost_calculator.calculate).to eq(6)
end
end

on the use case.!
2. Write a top level feature spec that runs everything without test
3. Write a coordinator spec using test doubles for the top level
coordinator.!
1. Identify other collaborators and inject them using test doubles.!
4. Make the top level Coordinator pass the spec.!
5. Repeat 2-3 for the identified collaborators until you can’t delegate
anymore.

Coordinator ?

Shipment
Cost
Calculator Surcharge
Calculator
Tax Charge
Calculator
Bunker
Charge
Calculator
Bunker Rate
Repository
Container
Weight
Calculator

I can’t delegate anymore!!
!
Now what do I do?

Triage and ! Enable Labs
Training
Two days on-site at your place of business.!
! !
First Day: Code Deep Dive!
!
• Code Review!
• OO Design Review!
• Testing Strategy Review!
• Hands-on Pairing!
!
Second Day: Training!
!
• Directly address issues identified on day one.
Get hands-on
mentoring and help
with your project.
Two days on-site
hands-on.

Small Code! Enable Labs
Workshop
Learn how to write
small beautiful
code.
Smaller classes and systems are easier to build and maintain. From
fundamentals through system design the Small Code Workshop
teaches:!
!
• Method Design!
• Naming Strategies!
• Class Design!
• Inheritance vs Composition!
• Exploratory Testing!
• Dependency Management!
• Directed Refactorings!
• … and more
Two to four days
on-site hands-on.

On the Project ! Enable Labs
Training
Work hand in hand!
with Enable Labs!
staff on your
projects.
You’ll work hands on with Enable Labs developers and trainers on
your project using your code. Our developers will focus on teaching
the fundamental principles of Small Code and good object oriented
design while moving your project forward.!
!
You get to define your objectives for the two weeks and our team will
focus on getting you and your team to a better place.!
!
We will focus on:!
!
• Immediate improvements to the design of your most difficult
components.!
• Improving your test suite design to assure it’s delivering maximum
value.!
• Teaching fundamentals of class naming, class design, separation
of concerns and more.
Level up in two
weeks while
working in your
code base.

Custom App! Enable Labs
Development
Full life-cycle
project
development
From idea to deployment our team can bring your vision to life. Using
a highly interactive process our team will work directly with your stake
holders to create your applications.
Fully co-located
cross functional
team
We use:!
!
• Test Driven Development!
• Client on-site!
• Pair Programming
We work with:!
!
• Ruby!
• Rails!
• AngularJS!
• iOS!
• Android!
• … and much more

Enable Labs
@mark_menard
http://www.enablelabs.com/
info@enablelabs.com
866-895-8189

Let's Do Some Upfront Design - WindyCityRails 2014

More Related Content

What's hot (13)

Viewers also liked (12)

Similar to Let's Do Some Upfront Design - WindyCityRails 2014 (20)

More from Mark Menard (12)

Recently uploaded (20)

Let's Do Some Upfront Design - WindyCityRails 2014