Managing complexity

Managing Complexity
Sam Goldman
@nontrivialzeros
github.com/samwgoldman

Monday, December 17, 12

What is Complexity?
• Lines of code?
• Duplication?
• Coupling?
• LOC/Method?
• # Methods/Class?
• # Features?

Noticing Complexity
• Feature development costs increase
• Bugs increase superlinearly with code size
• “Boring bugs” keep happening
• New dev onboarding takes weeks
• Local changes have unexpected, non-local
effects


Reasoning about
Complexity
• How can you compare two solutions?
• Lots of guidelines, e.g., SOLID
• Lots of cargo culting
• We need to do better than a gut check
• Patterns are still good


Factorization
• Large numbers factorized by primes
• 288 = 2 × 2 × 2 × 2 × 2 × 3 × 3
• Some large numbers can’t be factorized
• 195845982777569926302400511
• Fundamental theorem of arithmetic
• No efﬁcient algorithm

Probabilistic Factors

• Take binary random variables A, B, and C
• P(A) has two possible conﬁgurations
• P(A, B) has 4
• P(A, B, C) has 8
• Joint conﬁgurations grow exponentially



• Distributions factorized by independence
• P(A, B) = P(A)P(B) if A, B are independent
• Let A and B each have 100 discrete values
• Not independent: 10000 conﬁgurations
• Independent: 200 conﬁgurations


OOP

• Software is factorized by encapsulation
• Controlling dependencies is key
• Conversely: Discover independencies


Tell, Don’t Ask

• Depending on collaborators’ states breaks
encapsulation
• Depend on behaviors, not state
• Law of Demeter


Asking
Questionnaire = Struct.new(:questions) do
def render(html)
html.form
questions.each do |question|
html.fieldset {
case question
when ShortAnswerQuestion
html.label(:for => question.id) { html.text question.prompt }
html.input(:type => "text", :id => question.id, :name => question.id)
when MultipleChoiceQuestion
html.label { html.text question.prompt }
html.ul {
question.choices.each do |choice|
html.li {
html.label(:for => choice.id) { html.text choice.title }
html.input(:type => "radio", :id => choice.id, :name => choice.id)
}
end
}
end
}
end
end
end
end


Telling

Questionnaire = Struct.new(:questions) do
def render(html)
html.form do
questions.each do |question|
html.fieldset { question.render(html) }
end
end
end
end


Telling
ShortAnswerQuestion = Struct.new(:id, :prompt) do
def render(html)
html.label(:for => id) { html.text prompt }
html.input(:type => "text", :id => id, :name => id)
end
end

MultipleChoiceQuestion = Struct.new(:id, :prompt, :choices) do
def render(html)
html.label { html.text prompt }
html.ul {
choices.each do |choice|
html.li { choice.render(html) }
end
}
end
end

Choice = Struct.new(:id, :title) do
def render(html)
html.label(:for => id) { html.text title }
html.input(:type => "radio", :id => id, :name => id)
end
end


Mocks

• How can we write assertions when objects
hide their internal state?
• We need to assert that objects are sending
the right messages to one another


Mocks

describe Questionnaire do
it "renders every question" do
question1 = mock
question2 = mock
questionnaire = Questionnaire.new([question1, question2])
builder = stub

question1.should_receive(:render).with(builder).ordered

questionnaire.render(builder)
end
end


Mocks Aren’t Stubs
describe ArrearsReport do
it "displays customers who owe money" do
report = ArrearsReport.new

foo_customer = stub(:in_arrears? => true)
bar_customer = stub(:in_arrears? => false)

result = report.run([foo_customer, bar_customer])
result.should eq([foo_customer])
end
end
question1 = mock
question2 = mock
builder = stub


end
end


Mocks Aren’t Stubs
describe ArrearsReport do
it "displays customers who owe money" do
report = ArrearsReport.new

foo_customer = stub(:in_arrears? => true)
Stub Queries
bar_customer = stub(:in_arrears? => false)

result = report.run([foo_customer, bar_customer])
result.should eq([foo_customer])
end
end
question1 = mock
question2 = mock
builder = stub
Mock Actions

end
end


Values

• SmartLogic’s Nerdword project
• Services: Player, Pouch, Board
• Values: Move, Direction, Position


Values

module Direction
HORIZONTAL = "Horizontal".freeze
VERTICAL = "Vertical".freeze

def self.opposite(direction)
if direction == HORIZONTAL
VERTICAL
else
HORIZONTAL
end
end
end


Values
Position = Struct.new(:col, :row) do
def shift(offset, direction)
if direction == Direction::HORIZONTAL
Position.new(col + offset, row)
else
Position.new(col, row + offset)
end
end

def previous(direction)
shift(-1, direction)
end

def next(direction)
shift(1, direction)
end
end


Values

Move = Struct.new(:word, :position, :direction) do
def each_position
word.length.times do |i|
yield position.shift(i, direction)
end
end
end


Values

• We happily depend on Array, Date, String...
• Create values in your domain
• Separate services from values
• Better messages, better factors
• Don’t stub values


Abstractions
• RemoteFile, not S3
• PaymentProcessor, not Braintree
• Wrap services around 3rd party code
• “Ports and Adapters”
• Write integrated tests for wrapper services
• “Test double” wrapper services elsewhere
• ActiveRecord?

Acceptance Tests
• “How does the client know it works?”
• Write acceptance tests your client would
understand
• Write acceptance tests your client would
want to read
• Write as few acceptance tests as possible


Integration Tests

• “How do we know if it works?”
• Ports and Adapters is a good factorization
• Write as few integration tests as you need
• You don’t need as many as you think


Thank you

@smartlogic
facebook.com/smartlogic
github.com/smartlogic


Managing complexity

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (15)

Destacado

Destacado (6)

Similar a Managing complexity

Similar a Managing complexity (20)

Más de SmartLogic

Más de SmartLogic (20)

Managing complexity