Write Small Things (Code)

Write Small Things
Mark Menard
@mark_menard

Enable Labs

Los Angeles Ruby Conf 2014
@mark_menard

Enable Labs

1

WiteSmallThings - February 8, 2014

Who is Mark Menard
Husband of Sylva!
Father of Ezra and Avi!
From and Resides inTroy, NY!
Owner of Enable Labs a boutique consultancy doing Web and Mobile
Development!
Has done for about ﬁve years!
Doing software development for a long time

@mark_menard

Enable Labs

2


‘The great thing about writing
shitty code that “just works,” is
that it is too risky and too
expensive to change, so it lives
forever.’!
-Reginald Braithwaite @raganwald

@mark_menard

Enable Labs

3


Introduction

@mark_menard

Enable Labs

4


What is meant by small?

@mark_menard

Enable Labs

5


It’s not about
total line count.

@mark_menard

Enable Labs

6


It’s not about
method count.

@mark_menard

Enable Labs

7


It’s not about
class count.

@mark_menard

Enable Labs

8


So, what do I mean by small things?
Small methods!

Small classes

@mark_menard

Enable Labs

9


Why should we strive for small
code?
•
•
•
•

We don’t know what the future will bring!
Raise the level of abstraction!
Create composable components!
Prefer delegation over inheritance

Enable Future Change
@mark_menard

Enable Labs

10


What are the challenges of small
code?
•
•

Dependency Management!
Context Management

@mark_menard

Enable Labs

11


The goal: Small units of
understandable code that
are amenable to change.

@mark_menard

Enable Labs

12


Our Three Main Tools
•
•
•

Extract Method!
Extract Class!
Composed Method

@mark_menard

Enable Labs

13


Methods

@mark_menard

Enable Labs

14


“The object programs that live
best and longest are those with
short methods.”!
! ! ! ! ! ! -Refactoring by Fields, Harvey, Fowler, Black
@mark_menard

Enable Labs

15


The ﬁrst rule of methods:

@mark_menard

Enable Labs

16


Do one thing. Do it well. Do only
that thing.

@mark_menard

Enable Labs

17


Use Descriptive Names

@mark_menard

Enable Labs

18


The fewer arguments the better.

@mark_menard

Enable Labs

19


Separate Queries from Commands

@mark_menard

Enable Labs

20


Don’t Repeat Yourself

@mark_menard

Enable Labs

21


Let’s Build a Command Line
Option Library

@mark_menard

Enable Labs

22


options = CommandLineOptions.new(ARGV) do
option :c
option :v
option :e
end
!

if options.has(:c)
# Do something
end
!

if options.has(:v)
# Do something else
end
!

if options.has(:e)
# Do the other thing
end

Enable Labs

!23

23

@mark_menard


describe CommandLineOptions do
!

describe 'options' do
!

let(:parser) { CommandLineOptions.new { option :c } }
!

it "are true if present" do …
!

it "are false if absent" do …
end
end

Enable Labs

!24

24

@mark_menard


CommandLineOptions
options
are true if present
are false if absent
!

Finished in 0.00206 seconds
2 examples, 2 failures

Enable Labs

!25

25

@mark_menard


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 :c
options << option_flag
option :v
end
option :e
!
end
end

Enable Labs

!26

26

@mark_menard


CommandLineOptions
options
are true if present
are false if absent
!


Enable Labs

!27

27

@mark_menard


Done!

@mark_menard

Enable Labs

28


# some_ruby_program -v -efoo
!

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

Enable Labs

!29

29

@mark_menard


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

Enable Labs

!30

30

@mark_menard


CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content (FAILED - 1)
can return the value (FAILED - 2)
return nil if not in argv (FAILED - 3)

!

Failures:

!

!

!

!

1) CommandLineOptions string options must have content
Failure/Error: expect(options.valid?).to be_false
NoMethodError:
undefined method `valid?' for #<CommandLineOptions:0x00000102cc8fa0>
# ./spec/command_line_options_spec.rb:26:in `block (3 levels) in <top (required)>'
2) CommandLineOptions string options can return the value
Failure/Error: expect(options.value(:e)).to eq("foo")
NoMethodError:
undefined method `value' for #<CommandLineOptions:0x00000102cca1c0>
3) CommandLineOptions string options return nil if not in argv
Failure/Error: expect(options.value(:e)).to be_nil
NoMethodError:
undefined method `value' for #<CommandLineOptions:0x00000102cc2a38>


Enable Labs

!31

31

@mark_menard


def valid?
options.each do |option_flag, option_type|
raw_option_value = argv.find { |arg| arg =~ /-#{option_flag}/ }
return false if raw_option_value.length < 3 && option_type == :string
end
end

Enable Labs

!32

32

@mark_menard


CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content
return nil if not in argv (FAILED - 2)

!
Failures:

!
NoMethodError:
undefined method `value' for #<CommandLineOptions:0x00000101cbb6f8>

!
2) CommandLineOptions string options return nil if not in argv
Failure/Error: expect(options.value(:e)).to be_nil
NoMethodError:
undefined method `value' for #<CommandLineOptions:0x00000101cba2a8>

!

Enable Labs

!33

33

@mark_menard


def value (option_flag)
return nil unless raw_option_value
option_type = options[option_flag]
return raw_option_value[2..-1] if option_type == :string
end

Enable Labs

!34

34

@mark_menard


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
!


Enable Labs

!35

35

@mark_menard


def valid?
return false if raw_option_value.length < 3 && option_type == :string
end
end
!

end

Enable Labs

!36

36

@mark_menard


Extract Method Refactoring
def print_invoice_for_amount (amount)
print_header
puts "Name: #{@name}"
puts "Amount: #{amount}"
end

Same level of abstraction

def print_invoice_for_amount (amount)
print_header
print_details (amount)
end

!

def print_details (amount)
puts "Name: #{@name}"
puts "Amount: #{amount}"
end

Move this to here
High level of abstraction
Low level of abstraction

@mark_menard

Enable Labs

37


!

!

def valid?
return false if option_type == :string && raw_value_for_option(option_flag).length < 3
end
end
raw_option_value = raw_value_for_option(option_flag)
end
private def raw_value_for_option (option_flag)
argv.find { |arg| arg =~ /-#{option_flag}/ }
end

Enable Labs

!38

38

@mark_menard


CommandLineOptions
boolean options
are true if present
are false if absent
string options
must have content
!


Enable Labs

!39

39

@mark_menard



!
!

!
!
!

!

!

attr_accessor :argv
@options = {}
@argv = argv
end
end
def option (option_flag, option_type = :boolean)
options[option_flag] = option_type
end
def valid?
end
end
end
end

end

Enable Labs

!40

40

@mark_menard


!

!

def valid?
end
end
end
end

Enable Labs

!41

41

@mark_menard


Done!

@mark_menard

Enable Labs

42


# some_ruby_program -v -efoo -i100
!

option :v
option :e, :string
option :i, :integer
end
!

verbose = options.value(:v)
expression = options.value(:e)
iteration_count = options.value(:i) || 1

Enable Labs

!43

43

@mark_menard


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

Enable Labs

!44

44

@mark_menard


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)

Enable Labs

!45

45

@mark_menard


let(:options) { CommandLineOptions.new { option :i, :integer } }
!

it "must have content" do
options.argv = [ "-i" ]
expect(options.valid?).to be_false
end

Enable Labs

!46

46

@mark_menard


def valid?
return false if option_type == :string &&
raw_value_for_option(option_flag).length < 3
end
end

Enable Labs

!47

47

@mark_menard


def valid?
return false if (option_type == :string || option_type == :integer)&&
end
end

Enable Labs

!48

48

@mark_menard


it "must be an integer" do
options.argv = [ "-inot_an_integer" ]
expect(options.valid?).to be_false
end

Enable Labs

!49

49

@mark_menard


def valid?
return false if (option_type == :string || option_type == :integer) &&
return false unless option_type == :integer &&
(Integer(raw_value_for_option(option_flag)[2..-1]) rescue false)
end
end

Enable Labs

!50

50

@mark_menard


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

Enable Labs

!51

51

@mark_menard



!
!

!
!
!

!

!
!

attr_accessor :argv
@options = {}
@argv = argv
end
end
end
def valid?
end
end
end
end

end

Enable Labs

!52

52

@mark_menard


def valid?
end
end

Enable Labs

!54

54

@mark_menard


Integer("foo") rescue false #=> false
"foo".to_i
#=> 0 !!!!!!!

Enable Labs

!55

55

@mark_menard


!

def valid?
case(option_type)
when :string
return false if raw_value_for_option(option_flag).length < 3
when :integer
return false unless (Integer(raw_value_for_option(option_flag)[2..-1]) rescue false)
end
end
end

Enable Labs

!56

56

@mark_menard


def valid?
case(option_type)
when :string
when :integer
return false unless (Integer(raw_value_for_option(option_flag)[2..-1]) rescue false)
when :boolean
end
end
end

Enable Labs

!57

57

@mark_menard


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

Enable Labs

!58

58

@mark_menard


def valid?
case(option_type)
when :string
return false unless string_option_valid?(raw_value_for_option(option_flag))
when :integer
return false unless integer_option_valid?(raw_value_for_option(option_flag))
when :boolean
end
end
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

Enable Labs

!59

59

@mark_menard


private def boolean_option_valid? (raw_value)
true
end

Enable Labs

!60

60

@mark_menard


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

Enable Labs

!61

61

@mark_menard


def valid?
return false unless send("#{option_type}_option_valid?", raw_value_for_option(option_flag))
end
end

Enable Labs

!62

62

@mark_menard


def valid?
return false unless option_valid?(option_type, raw_value_for_option(option_flag))
end
end

!
private def option_valid? (option_type, raw_value)
send("#{option_type}_option_valid?", raw_value)
end

Enable Labs

!63

63

@mark_menard


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

!
10 examples, 0 failures, 1 pending

Enable Labs

!64

64

@mark_menard


!
!


!
!
!
!
!
!
!
!
!
!
!

attr_accessor :argv
@options = {}
@argv = argv
end
end
def valid?
end
end
return extract_value_from_raw_value(raw_option_value) if option_type == :string
end
private def option (option_flag, option_type = :boolean)
end
private def option_valid? (option_type, raw_value)
send("#{option_type}_option_valid?", raw_value)
end
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
end

end

Enable Labs

!65

65

@mark_menard


end

!
def valid?
end
end

!
return extract_value_from_raw_value(raw_option_value) if option_type == :string
end

Enable Labs

!66

66

@mark_menard


Classes

@mark_menard

Enable Labs

67


How do we write small classes?
•
•
•
•
•
•
•

Write small methods!
Talk to the class!
Find a good name!
Isolate Responsibilities!
Find cohesive sets of variables/properties!
Extract Class!
Move method

@mark_menard

Enable Labs

68


What are the characteristics of a
well designed small class?
•
•
•
•
•
•

Single responsibility!
Cohesive properties!
Small public interface (preferably a handful of methods at the most)!
Implements a single Use Case if possible!
Primary logic is expressed in a composed method!
Dependencies are injected

@mark_menard

Enable Labs

69


describe StringOption do
let(:string_option) { StringOption.new('s', '-sfoo') }
!

it
it
it
it
end

"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"

Enable Labs

!70

70

@mark_menard


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)

Enable Labs

!71

71

@mark_menard


class StringOption
!

attr_reader :flag
!

def initialize (flag, raw_value)
@flag = flag
@raw_value = raw_value
end
!

end

Enable Labs

!72

72

@mark_menard


it "is valid when it has a value" do
expect(string_option.valid?).to be_true
end

Enable Labs

!73

73

@mark_menard


class StringOption


!
!

!

end

!

end

!
!
!

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

Enable Labs

!74

74

@mark_menard


class StringOption
!

!

@flag = flag
end
!

def valid?
end
!

raw_value[2..-1]
end
!

end

Enable Labs

!75

75

@mark_menard


StringOption.new("", raw_value).valid?
end

Enable Labs

!76

76

@mark_menard


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

Enable Labs

!77

77

@mark_menard


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

Enable Labs

!78

78

@mark_menard


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

Enable Labs

!79

79

@mark_menard


class StringOption < OptionWithContent
end
!

class IntegerOption < OptionWithContent
!

def valid?
super && real_value_is_integer?
end
!

private def real_value_is_integer?
(Integer(extract_value_from_raw_value) rescue false)
end
!

end

Enable Labs

!80

80

@mark_menard


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
is valid when it has a value

Enable Labs

!81

81

@mark_menard


Dependencies

@mark_menard

Enable Labs

83


How do we deal with
Dependencies?
•
•

Dependency Injection!
Depend on Abstractions

@mark_menard

Enable Labs

82


end

options[option_flag] = case (option_type)
when :boolean
return BooleanOption.new(option_flag, nil)
when :string
return StringOption.new(option_flag, nil)
when :integer
return IntegerOption.new(option_flag, nil)
end
end

option_class = "#{option_type}_option".camelize.constantize
options[option_flag] = option_class.new(option_flag, nil)
end

Enable Labs

!84

84

@mark_menard


How do we isolate abstractions?
Separate the “what”
from the “how”.

@mark_menard

Enable Labs

85


CommandLineOptions
boolean options
are true if present
are false if absent
string options
is valid when there is content (FAILED - 2)
integer options
must be an integer (FAILED - 5)

!
StringOption
has a flag

Enable Labs

!86

86

@mark_menard


def valid?
end
end

def valid?
options.values.all?(&:valid?)
end

Enable Labs

!87

87

@mark_menard


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

Enable Labs

!88

88

@mark_menard


end

options[option_flag].value
end

Enable Labs

!89

89

@mark_menard


NoMethodError:
undefined method `value' for #<StringOption:0x00000101b85b30 @flag=:e, @raw_value="-efoo">
# ./lib/command_line_options.rb:26:in `value'

Enable Labs

!90

90

@mark_menard


# OptionWithContent
def value
return nil if option_unset?
valid? ? extract_value_from_raw_value : nil
end

# IntegerOption
def value
return if option_unset?
Integer(extract_value_from_raw_value)
end

Enable Labs

!91

91

@mark_menard


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

!
OptionWithContent
has a flag
is valid when it has no raw value
can return it's value when present
returns nil if the flag has no raw value

Enable Labs

!92

92

@mark_menard


Done!

@mark_menard

Enable Labs

93



!

!
!
!
!
!

!
!
!
!

@options = {}
@argv = argv
populate_options_with_raw_values
end
def valid?
end
end
private
attr_reader :options, :argv
def populate_options_with_raw_values
options.each do |option_flag, option|
option.raw_value = raw_value_for_option(option_flag)
end
end
options[option_flag] = get_option_class(option_type).new(option_flag, nil)
end
def get_option_class (option_type)
"#{option_type}_option".camelize.constantize
end
def raw_value_for_option (option_flag)
end

end

Enable Labs

!94

94

@mark_menard


!

def valid?
end
!

end
Enable Labs

!95

95

@mark_menard


Then

@mark_menard

Enable Labs

96


some_ruby_program -v -efoo -i100 -afoo,bar,baz

Enable Labs

!97

97

@mark_menard


describe "array options" do
it "can return the value as an array" do
expect(CommandLineOptions.new([ "-afoo,bar,baz" ]) { option :a, :array }.value(:a)).to eq(["foo", "bar", "baz"])
end
end

class ArrayOption < OptionWithContent
def value
return nil if option_unset?
extract_value_from_raw_value.split(",")
end
end

Enable Labs

!98

98

@mark_menard


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
array options
can return the value as an array

!
OptionWithContent
has a flag
is valid when it has no raw value
can return it's value when present
returns nil if the flag has no raw value

Enable Labs

!99

99

@mark_menard


Done!

@mark_menard

Enable Labs

100


Enable Labs
Start Today

@mark_menard

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

Enable Labs

101


Write Small Things (Code)

More Related Content

What's hot

Similar to Write Small Things (Code)

More from Mark Menard

Recently uploaded

Write Small Things (Code)