• A style of Code Construction
  

• New Ruby tricks
  
• New libraries
  
• Just a collection of techniques
  

• The opposite of timid code
  

• Examples, then themes
  

• cowsay.rb
  
• An interface to the "cowsay" program
  
• http://github.com/avdi/cowsay
  

$ echo "Mooo" | cowsay
 ______
< Mooo >
 ------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |

$ echo "Ontogeny Recapitulates Phylogeny" | cowsay -e "00"
 __________________________________
< Ontogeny Recapitulates Phylogeny >
 ----------------------------------
        \   ^__^
         \  (00)\_______
            (__)\       )\/\
                ||----w |

• Debian/Ubuntu
  

  sudo apt-get install cowsay
  

• Mac OS X
  

  sudo port install cowsay
  

require 'lib/cowsay'
cow = Cowsay::Cow.new
puts cow.say "Baaa"                  # => nil
# >>  ______
# >> < Baaa >
# >>  ------
# >>         \   ^__^
# >>          \  (oo)\_______
# >>             (__)\       )\/\
# >>                 ||----w |
# >>                 ||     ||

• Contrived for the sake of example
  
• Examples drawn from real production code
  

if options[:out]
  options[:out] << output
end

command = "cowsay"
if options[:strings] && options[:strings][:eyes]
  command << " -e '#{options[:strings][:eyes]}'"
end

@post.try(:comments).first.try(:author).try(:email)

• AKA #andand(), #ergo()
  
• Cleaner, but doesn't get to the root of the problem
  
• Still interrupting flow to do a nil check
  

@io_class.popen(command, "w+") do |process|
  results << begin
               process.write(message)
               process.close_write
               result = process.read
             rescue Errno::EPIPE
               message
             end
end

destination = case options[:out]
              when nil  then "return value"
              when File then options[:out].path
              else options[:out].inspect
              end
@logger.info "Wrote to #{destination}"

if $? && ![0,172].include?($?.exitstatus)
  raise ArgumentError, 
        "Command exited with status #{$?.exitstatus.to_s}"
end

• Lives in fear
  
• Constantly second-guessing itself
  
• Randomly mixes input gathering, error handling, and business logic
  
• Imposes cognitive load on the reader
  

• Says exactly what it intends to do
  
  • Without provisos or digressions
    
• Has a consistent narrative structure
  

• Gather input
  
• Perform work
  
• Deliver results
  
• Handle errors
  
• In that order!
  

• True duck typing is a confident style
  
• Duck typing doesn't ask "are you a duck?"
  
• Or even "can you quack?"
  
• Treat the object like a duck. If it isn't it will complain
  
• Sometimes an object just needs help discovering its duck nature
  

• Coerce
  
• Reject
  
• Ignore
  

• #to_s, #to_i, #to_sym, Array()
  
• Decorators
  

• Use #to_s, #to_i, Array() liberally
  
• Ruby standard libs do this
  

  require 'pathname'
  path = Pathname("/home/avdi/.emacs")
  open(path) # => #<File:/home/avdi/.emacs>
  

• Prefer Array() to to_a
  

  Object.new.to_a                 
  # => [#<Object:0xb78a665c>] 
  # !> default `to_a' will be obsolete
  

• The "arrayification operator"
  

  Array([1,2,3])                # => [1, 2, 3]
  Array("foo")                  # => ["foo"]
  Array(nil)                    # => []
  
  # Gotcha:
  Array("foo\nbar")             # => ["foo\n", "bar"]
  

• Before
  

  messages = case message
             when Array then message
             when nil then []
             else [message]
             end
  

• After
  

  messages = Array(message)
  

• When there is no consistent interface
  
• Decorator Pattern
  
• Wraps an object and adds a little extra
  
• The Candidate
  

  destination = case options[:out]
                when nil  then "return value"
                when File then options[:out].path
                else options[:out].inspect
                end
  @logger.info "Wrote to #{destination}"
  

require 'delegate'
# ...
class WithPath < SimpleDelegator
  def path
    case __getobj__
    when File then super
    when nil then "return value"
    else inspect
    end
  end
end

destination = WithPath.new(options[:out]).path
# ...
@logger.info "Wrote to #{destination}"

• Dynamically #extend objects
  

  obj.extend(MyMethods)
  

• Dynamically add methods
  

  def obj.foo
     # ...
  end
  

• Confident Code is Assertive
  
• Preconditions: state your demands up-front
  
• Part of Design by Contract
  
• A complement to TDD/BDD
  
• No DbC framework needed
  
• Assertions don't have to be spelled "assert()"
  

def say(message, options={})
  if options[:cowfile] && options[:cowfile] =~ /^\s*$/
    raise ArgumentError, "Cowfile cannot be blank"
  end
  # ...
  if options[:cowfile]
    command << " -f #{options[:cowfile]}"
  end
  # ...
end

def assert(value, message="Assertion failed")
  raise Exception, message, caller unless value
end

# ...

options[:cowfile] and 
  assert(options[:cowfile].to_s !~ /^\s*$/)

• Assertions are documentation
  
• FailFast
  http://fail-fast.rubyforge.org/

• Guard Clause
  
• Null Object
  

• Short-circuit on nil message
  

  def say(message, options={})
    return "" if message.nil?
    # ...
  

• Avoids special cases later in method
  
• Return from beginning or end of method
  

"A Null Object is an object with defined neutral ("null") behavior." (Wikipedia)

• Responds to any message with nil (or itself)
  
• Should be in the standard library
  

class NullObject
  def method_missing(*args, &block)
    self
  end

  def nil?; true; end
end

def Maybe(value)
  value.nil? ? NullObject.new : value
end

• if statement
  

  if options[:out]
    options[:out] << output
  end
  

• Null Object
  

  Maybe(options[:out]) << output
  

• Returning self lets us nullify chains of calls
  Example coming up later.

• nil is overused in Ruby code
  
• It means too many things
  
  • Error
    
  • Missing Data
    
  • Flag for "default behavior"
    
  • Uninitialized variable
    
• Nils propagate
  
• Nil checks are the most common form of timid code
  

post_id = params[:post_id]
post    = Post.find(post_id.to_i)
post.date     # =>
# ~> -:4: undefined method `date' for nil:NilClass (NoMethodError)

{}[:width]                      # => nil
{}[:width] || 40                # => 40
{:width => nil}[:width] || 40   # => 40
{:width => false}[:width] || 40 # => 40
{:width => 29}[:width] || 40    # => 29

{}.fetch(:width)                     # => 
# ~> -:7:in `fetch': key not found (IndexError)
{}.fetch(:width) { 40 }         # => 40
{:width => nil}.fetch(:width) {40} # => nil
{:width => false}.fetch(:width) {40} # => false
{:width => 29}.fetch(:width) {40}    # => 29

• Default error
  

  opt = {}.fetch(:required_opt)         # => 
  # ~> -:1:in `fetch': key not found (IndexError)
  

• Custom error
  

  opt = {}.fetch(:required_opt) do
    raise ArgumentError, "Missing option!"
  end
  # ~> -:2: Missing option! (ArgumentError)
  

• Using ||
  

  width = options[:width] || 40
  command << " -W #{width}"
  

• Using #fetch
  

  width = options.fetch(:width) {40}
  command << " -W #{width}"
  

• A more explicit default
  
• One less conditional
  

• Where did that nil come from?
  

  @logger.info "Something happened" # => 
  # ~> -:3: undefined method `info' for nil:NilClass (NoMethodError)
  

@logger = :no_logger_set
# ...
@logger.info "Something happened" # => 
# ~> -:3: undefined method `info' for :no_logger_set:Symbol (NoMethodError)

def initialize(logger=NullObject.new)
  @logger = logger
end

class NullObject
  def initialize
    @origin = caller.first
  end
  # ...
end

# $? is either nil or a Process::Status object
def check_child_exit_status!(status=$?)
  status ||= OpenStruct.new(:exitstatus => 0)
  unless [0,172].include?(status.exitstatus)
    raise ArgumentError, 
          "Command exited with status #{status.exitstatus.status}"
  end      
end

• PIE Principle
  Program Intently and Expressively
• Avoid digressions for error/input handling
  

• Programming without IF
  http://programmingwithoutifs.blogspot.com/
• Conditionals are essential
  
• Reserve conditionals for business logic
  
• Minimize conditionals for error, input handling
  
• Isolate error/input handling from program flow
  

if post.published?
  # ...
end

if post
  # ...
end

def slug(text)
  Maybe(text).downcase.strip.tr_s('^a-z0-9', '-')
end

slug("Confident Code")          # => "confident-code"
slug(nil)                       # => #<NullObject:0xb780863c>

• A style exemplified by jQuery
  

  // From "jQuery in Action"
  $("div.notLongForThisWorld").fadeOut().
      addClass("removed");
  

• Single object operations are implicitly one-or-error
  
• Iteration is implicitly 0-or-more
  
• Chains of enumerable operations are self-nullifying
  
• Cowsay#say uses an iterative style…
  

def say(message, options={})
  # ...
  messages = Array(message)
  message.map { |message|
    # ...
  }
  # ...
end

cow.say(nil) # => ""

• Use *args
  

  def say(*messages) # ...
  

• Use #compact to get rid of nils
  

  msgs = ["moo", nil, "belch"]
  cow.say(*msgs.compact)
  

• Moving on…
  

• Put the happy path first
  
• Put error-handling at the end
  
• Or in other methods.
  

def foo
  # ...
rescue => error
  # ...
end

• Bouncer Method
  
• Checked Method
  

• Method whose job is to raise or do nothing
  

  def check_child_exit_status
    result = yield
    status = $? || OpenStruct.new(:exitstatus => 0)
    unless [0,172].include?(status.exitstatus)
      raise ArgumentError, 
            "Command exited with status #{status.exitstatus}"
    end
    result
  end
  

# Before:
@io_class.popen(command, "w+") # ...
# ...
if $? && ![0,172].include?($?.exitstatus)
  raise ArgumentError, 
        "Command exited with status #{$?.exitstatus.to_s}"
end

# After:
check_child_exit_status {
  @io_class.popen(command, "w+") # ...
}

def checked_popen(command, mode, fail_action)
  check_child_exit_status do
    @io_class.popen(command, "w+") do |process|
      yield(process)
    end
  end
rescue Errno::EPIPE
  fail_action.call
end

# Before:
@io_class.popen(command, "w+") do |process|
  results << begin
               # ...
             rescue Errno::EPIPE
               message
             end
end

# After:
checked_popen(command, "w+", lambda{message}) do |process|
  # ...
end

• It has a coherent narrative structure
  
• It has lower complexity
  
• It's not necessarily shorter
  

• Fewer paths == fewer bugs
  
• Easier to debug
  
• Self-documenting
  "Write code for people first, the computer second"

• A style, not a set of techniques
  
• PIE: Program Intently and Expressively
  
• Consistent Narrative structure
  
• Handle input, perform work, deliver output, handle errors.
  
• State your demands up-front
  
• Terminate nils with extreme prejudice
  
• Avoid digressions
  
• Isolate error handling from the main flow
  

• Caliper
  http://getcaliper.com/
• Caliper for the Cowsay project
  http://getcaliper.com/caliper/project?repo=git://github.com/avdi/cowsay.git