TDD Basics : Obvious Implementation

Problem Statement


Given two variables a and b, exchange the values assigned to them.

Objective


Learn when to use Obvious Implementation instead of Fake it Till You Make it or Triangulation.

Problem Domain Analysis


In this phase, we define the problem clearly.

Before exchange, the initial values are : a = 1 and b = 2
After exchange, the final values are : a = 2 and b = 1

alt text

Solution Domain Analysis


It's very easy to exchange values in Ruby. Here is the irb session that shows how to swap the values of a and b using just one line.

 $irb
 > a = 1
 => 1 
 > b = 2
 => 2 
 > a,b=b,a
 => [2, 1] 
 > a
 => 2 
 > b
 => 1 

Let's solve the problem in a way that allows implementing it in any language. This means we can implement the solution in languages that requires more work to swap values. Let a = 1, b = 2, here is an experiment for exchanging the values in the irb session:

$irb
 > a = 1
 => 1 
 > b = 2
 => 2 
 > a = b
 => 2 
 > b = a
 => 2 
 > a
 => 2 
 > b
 => 2 

This means we cannot do the following:

a = b
b = a

alt text

Because both a and b values end up with the value of 2. Our objective in this phase is to create a model and test the model to make sure that it works. Here is a model that fixes the above problem:

new value of a = original value of b
new value of b = original value of a

This means we need to preserve the old value of a. Let's consider the following model:

t = a
a = b
b = t

alt text

Let's test this model in the irb session:

 > a = 1
 => 1 
 > b = 2
 => 2 
 > t = a
 => 1 
 > a = b
 => 2 
 > b = t
 => 1 
 > a
 => 2 
 > b
 => 1 

The revised model works.

Algorithm Description

  1. Save the original value of 'a' in a temporary variable 't'.
  2. Assign to 'a' the original value of 'b'.
  3. Assign to 'b' the original value of 'a' that is stored in 't'.

Steps


Step 1

class Exchange
  attr_reader :a, :b

  def initialize(a, b)
    @a = a
    @b = b
  end

  def perform

  end
end

describe Exchange do
  it 'should swap the values of the given two variables' do
    e = Exchange.new(1, 2)
    e.perform

    expect(e.a).to eq(2)
  end
end

This test fails.

Step 2

Implementing our algorithm makes our test pass.

def perform
  t = @a
  @a = @b
  @b = t
end

Discussion


We did not use Fake It Till You Make It in this case because the implementation was obvious, so we just typed in the correct implementation. Fake It Till You Make It and Triangulation are helpful when you the solution is not obvious and you need to take small steps to learn more about the problem.

This problem is small. For big problems, you want to decompose it into smaller problems and solve the smaller problems first and combine the solution to smaller problems to solve the big problem. This divide and conquer strategy becomes necessary when the problem is unfamiliar or complex. Obvious Implementation is also called as Right Solution.

Summary


In this article you learned when it's ok to take big steps and not use Triangulation or Fake It Till You Make It. You can also see that the test code to the production code seems to be reasonable.


Related Articles

tdd


Ace the Technical Interview

  • Easily find the gaps in your knowledge
  • Get customized lessons based on where you are
  • Take consistent action everyday
  • Builtin accountability to keep you on track
  • You will solve bigger problems over time
  • Get the job of your dreams

Take the 30 Day Coding Skills Challenge

Gain confidence to attend the interview

No spam ever. Unsubscribe anytime.