bookmark_borderThe difference between TDD and Test First Development

Recently I promoted to do TDD, instead of “Tests First” development. Some people asked me what the difference is between them. In both cases we write tests first right?

So what is the difference?

I believe the difference is this:

Test First decribes your solution. TDD describes the problem

The difference could probably be explained best when using the coderetreat I had organized at the beginning of this year. Within this session I had experienced a great example to tell the difference between Tests first and TDD. To clarify the difference in this blog, we will be writing an implementation of Conway’s Game Of Life. It has the following rules:

  1. Any live cell with fewer than two live neighbours dies, as if caused by under-population.
  2. Any live cell with two or three live neighbours lives on to the next generation.
  3. Any live cell with more than three live neighbours dies, as if by overcrowding.
  4. Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

And it looks like this:

Image
Game Of Life in Action – Image from Wikipedia

Your assignment:

Write code that implements to the four rules above. It should be possible to apply these on an infinite grid

Test First describes your solution:
So the rules talk about “cells” and in your mind you’re already trying to solve this puzzle. In fact, I bet you’re already thinking about some array to put this matrix of cells into. Using a matrix we can easily determine neigbours and solve this puzzle…

We start with the first rule: “Any live cell with fewer than two live neighbours dies, …“.

We know it needs neighbours, so we need some boilerplate for that right?

The first test looks like this:

public class CellTest {

  @Test
  public void mustReturnTrueWhenAlive() {
    Cell cell = new Cell(1,0);
    Assert.assertTrue(cell.isAlive());
  }

}

Since we’re doing TDD (atleast we think it is, we’re actually doing Tests First…), we need to create this Cell class to make it compile.

public class Cell {

  private long x, y;

  public Cell(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public boolean isAlive() {
    return true;
  }
}

Before we can do anything with counting the number of neighbours, we need to determine what a neighbour is. Since adjecent cells are counted as neighbours, we start writing tests for this:

@Test
public void mustReturnTrueWhenNextToAnotherCell() {
  Cell cell = new Cell(1,0);
  Cell adjecent = new Cell(1,1);
  Assert.assertTrue(cell.isAdjecent(adjecent));
}

@Test
public void mustReturnFalseWhenNotNextToAnotherCell() {
  Cell cell = new Cell(1,0);
  Cell adjecent = new Cell(3,3);
  Assert.assertFalse(cell.isAdjecent(adjecent));
}

And along with it the code:

public class Cell {

  private long x, y;

  public Cell(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public boolean isAlive() {
    return true;
  }

  public boolean isAdjecent(Cell adjecent) {
    long diffX = Math.abs(adjecent.getX() - x);
    long diffY = Math.abs(adjecent.getY() - y);
    return diffX == 1 || diffY == 1;
  }

  public long getX() {
    return x;
  }

  public long getY() {
    return y;
  }
}

Wait, stop, halt!

If the above sounds familiar, then I’ve got news: This is not TDD

Lets get back to the original question, what did we try to implement? Ah, it was the question:

“Any live cell with fewer than two live neighbours dies, as if caused by under-population”,

So where is the corresponding test for that?…

In fact, we have already three tests and a bunch of code, and we still are not able to answer that question.

What we’ve done so far is write tests first in order to prove a solution we already had in our minds. We did not let the tests guide us to a design. In fact, we already had a design in our heads and made the tests conform to those.

Lets do it in TDD, for real

So how is it done ? – Test Driven Development

With a clean slate, we start over. And we start with the first rule:

“Any live cell with fewer than two live neighbours dies, as if caused by under-population”

So we create a test (we call it Test, because we do not think about Cells yet, in fact, we are only thinking about this very question).

@org.junit.Test
public void anyLiveCellWithFewerThanTwoLiveNeighboursDies() {
   int neighbours = 1;
   Assert.assertTrue(neighbours < 2);
}

So what does this do, it basically returns true when neighbours is lower than two. We do not call methods yet, we simply have our implementation within the test itself. In this phase, we already had Red (non compiling), Green (compiling and green test). On to refactor. How to get it more descriptive? We could do something like this:

@org.junit.Test
public void anyLiveCellWithFewerThanTwoLiveNeighboursDies() {
  int neighbours = 1;
  boolean shouldDie = neighbours < 2;
  Assert.assertTrue(shouldDie);
}

Do we need to do anything else? Certainly! But the essential rule is there already. It is one simple statement, no neighbour checking yet. And in fact, we will not need it to implement the four rules! Lets continue. I am serious, we will not modify the above code yet. We have yet to implement the other rules. Lets pick the second:

“Any live cell with two or three live neighbours lives on to the next generation.”

We have actually two cases here, for two and three live neighbours. Lets start with two:

@org.junit.Test
public void anyLiveCellWithTwoNeighboursLivesOn() {
  int neighbours = 2;
  boolean shouldLiveOn = neighbours == 2;
  Assert.assertTrue(shouldLiveOn);
}

Not that much different is it? How about we add the third test for the second rule:

@org.junit.Test
public void anyLiveCellWithThreeNeighboursLivesOn() {
  int neighbours = 3;
  boolean shouldLiveOn = neighbours == 3;
  Assert.assertTrue(shouldLiveOn);
}

The total test class looks like this now:

public class Test {

  @org.junit.Test
  public void anyLiveCellWithOneThanTwoLiveNeighboursDies() {
    int neighbours = 1;
    boolean shouldDie = neighbours < 2;
    Assert.assertTrue(shouldDie);
  }

  @org.junit.Test
  public void anyLiveCellWithTwoNeighboursLivesOn() {
    int neighbours = 2;
    boolean shouldLiveOn = neighbours == 2;
    Assert.assertTrue(shouldLiveOn);
  }

  @org.junit.Test
  public void anyLiveCellWithThreeNeighboursLivesOn() {
    int neighbours = 3;
    boolean shouldLiveOn = neighbours == 3;
    Assert.assertTrue(shouldLiveOn);
  }
}

We have done some little TDD cycles already. We started describing the problem domain, and we added the minimum amount of code to make this work. We did not yet start write any production code yet. Now one of the most important steps in TDD should be taken: Refactor. (Remember it is Red – Green – Refactor!)

With the third test, we clearly see duplication. The shouldLiveOn can be extracted to a method. Lets do that:

import org.junit.Assert;

public class Test {

  @org.junit.Test
  public void anyLiveCellWithOneThanTwoLiveNeighboursDies() {
    int neighbours = 1;
    boolean shouldDie = neighbours < 2;
    Assert.assertTrue(shouldDie);
  }

  @org.junit.Test
  public void anyLiveCellWithTwoNeighboursLivesOn() {
    int neighbours = 2;
    Assert.assertTrue(shouldLiveOn(neighbours));
  }

  @org.junit.Test
  public void anyLiveCellWithThreeNeighboursLivesOn() {
    int neighbours = 3;
    Assert.assertTrue(shouldLiveOn(neighbours));
  }

  private boolean shouldLiveOn(int neighbours) {
    return neighbours == 3 || neighbours == 2;
  }
}

We could refactor out the neighbours var to a constant, which should give us even smaller tests.

At this point we have now our first method which could eventually be moved out of the test class into some other class (we have yet to think of a name for). As you can see, the design of our code is being driven by the tests. So this may like trivial and like ‘cheating’. In fact, as I see it we are actually answering the real questions. We tend to write code for stuff we cannot possibly be sure of that it is correct. Did you see any line say that the Game of Life in this situation should be on a 2D grid? What if it would be 3D? What if we did not know yet if it would be 2D or 3D?

This sounds a lot like real-life isn’t it? Where your customer does not always know exactly what he wants.

Another good thing is, we can implement all rules like this. Eventually we end up with a test class that contains several methods. From there on we can think of a logical way to group them. Methods grouped together will form classes. We tend to group methods logically. When we define the problem domain we know better what classes should exist. Again, our tests drive the design. Instead of the other way around.

Here is an impression how the four rules implemented might look like:

package com.fundynamic.coderetreat;

import org.junit.*;

public class Test {

  public static final int StarvationThreshold = 1;
  public static final int OverpopulationThreshold = 4;
  public static final int MinimumRevivalThreshold = 3;
  public static final int MaximumRevivalThreshold = 3;

  @org.junit.Test
  public void liveCellShouldDieIfLessNeighboursThanStarvationThreshold() {
    int amountNeighbours = StarvationThreshold;
    Assert.assertEquals(false, livesOnToNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void liveCellShouldDieIfNeighboursEqualToStarvationThreshold() {
    int amountNeighbours = StarvationThreshold;
    Assert.assertEquals(false, livesOnToNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void liveCellShouldLiveIfTwoNeighbours() {
    int amountNeighbours = StarvationThreshold +1;
    Assert.assertEquals(true, livesOnToNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void liveCellShouldLiveIfThreeNeighbours() {
    int amountNeighbours = 3;
    Assert.assertEquals(true, livesOnToNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void liveCellShouldDieIfFourNeighbours() {
    int amountNeighbours = 4;
    Assert.assertEquals(false, livesOnToNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void liveCellShouldDieIfEightNeighbours() {
    int amountNeighbours = 8;
    Assert.assertEquals(false, livesOnToNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void deadCellShouldReviveIfMinimumRevivalThreshold() {
    int amountNeighbours = MinimumRevivalThreshold;
    Assert.assertEquals(true, revivesInNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void deadCellShouldReviveIfMaximumRevivalThreshold() {
    int amountNeighbours = MaximumRevivalThreshold;
    Assert.assertEquals(true, revivesInNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void deadCellShouldNotReviveIfLessNeighboursThanMinimumRevivalThreshold() {
    int amountNeighbours = MinimumRevivalThreshold -1;
    Assert.assertEquals(false, revivesInNextGeneration(amountNeighbours));
  }

  @org.junit.Test
  public void deadCellShouldNotReviveIfMoreNeighboursThanMaximumRevivalThreshold() {
    int amountNeighbours = MaximumRevivalThreshold +1;
    Assert.assertEquals(false, revivesInNextGeneration(amountNeighbours));
  }

  private boolean livesOnToNextGeneration(int amountNeighbours) {
    return amountNeighbours > StarvationThreshold && amountNeighbours < OverpopulationThreshold;
  }

  private boolean revivesInNextGeneration(int amountNeighbours) {
    return amountNeighbours == MinimumRevivalThreshold;
  }
}

But you did not even get to any cell? How is this any good?

It is true that cells play a role in the Game of Life eventually. But they do not play a role in answering the four questions. In fact, what are cells? We might be talking about squared cells or triangled or circled cells. Perhaps the requirement is to write a 3d version of a cell. Or you might want to use hexagons. If you put the rules logic into a cell, it gets very hard to modify your code because you have put too much responsibility in one class.

TDD prevents you from doing this. It prevents you from doing ‘design upfront’.

Also, if you started with using Cells and the matrix and all that. I would wonder how you would implement the last rule (reviving cells). How would you solve this problem?

Bottom line

Writing tests before your production code (test first) is not the same as TDD. TDD is about how your tests drive your design. Only then you can say if you are doing TDD or actually are just writing tests proving your own solution you have thought about before-hand.

It is hard to not think ahead of your design, and instead trust on our tests to let the design emerge itself. This requires practice. Practicing this can be done in coderetreats for instance.

 

Disclaimer about design…

TDD works great on a lot of levels in your architecture. This does not mean you can just do everything with TDD. Good architectural design requires thinking. You can’t just ‘do TDD’ and magically have a perfect design emerging. However, TDD will give you surprisingly elegant results. Especially, the more specific your problem (with a clear scope) the better TDD yields results.

bookmark_borderFirst coderetreat of 2012 in Amsterdam – Retrospective

At the end of 2011 I started organizing a coderetreat. It started on twitter around October. I’ve also posted about it in my last mini blog. The original event can be found here.

If anyone was interested, they could sign up (max 25 people) for free. All you needed to do was bring your best humor and if possible a laptop with your preferred dev environment set up. (Its not hard to organize one, check here if you’re interested)

If you want to know more about what a coderetreat is, click here. Even better: join a coderetreat somewhere near you and experience it. It is way better than just reading about it 🙂

Honing the craft together
Coderetreat

Lets start with a management summary:

It was awesome!

It reminded me of my experience with the bowling game kata last year. Since you’re repeating the exercise over and over again, you will find different approaches. Even better, because you’re switching pairs, you will have a different mindset literally to approach the problem presented by the coderetreat. Instead of writing a bowling game, you will be working on Conway’s Game Of Life.

The most notable things of that day where:

  • In the very first session we where let ‘free’. We could approach this problem how we wanted. Me and my pair where able to implement the first three rules. However we where not able to implement the fourth rule. Our design was not easy enough to revive dead cells. (gosh, this reminds me of the bowling game code kata first attempt…)
  • The second session we got to choose from different constraints. I picked the “no conditionals” one, because I can get my methods under 4 lines without pain. Programming without no conditions is a whole different story though.
  • The third session with ‘only check in within 2 minutes, else revert everything’ was an eye opener! It really forced you into thinking how to make all (baby) steps. Hence, I am using this at work now and it really works. I commit 10 times more often. Although I don’t make the 2 minute mark yet at work (5 minutes is easy though now).
  • The fourth session was fun, as we where able to implement *all rules* (opposed to the first session), but without the code we had implemented in the first session! We totally isolated the behaviour (this session was called “tdd as if you meant it”) and it blew our minds.

Will I attend more coderetreats? You bet! Just need to take a look at the list of events and pick an appropiate one. If I attend one, I will let you know (on twitter surely, perhaps on this blog).

If you want to know how it looked like, click here to see som pictures of the coderetreat.

I loved the coderetreat, and I’ll surely organize one again in the future. I would recommend anyone who loves his profession to join a coderetreat and practice. You’ll learn new things for sure!

How hard can it be, right? 😉

bookmark_borderExperiencing a Code Kata – Become a better developer while having fun!

Recently I have been experimenting with a Code Kata, and in this post I’d like to share my experiences with it.

Code Kata?

Code Kata’s have been around for a while, but it really came into my attention while reading Chapter 6 from the book The Clean Coder by Robert C Martin. This chapter makes an anology that at your work you’re a performer like a musician and outside work you (should be, like a musician) practicing. (Of course, you will learn while at work, but that is not the point).

But what is a Kata?

I have played the piano for around 6 years (followed lessons) and played it much less after that (in fact, I don’t really play at all anymore). In those six years I had to practice etudes as well as more famous pieces. I did not understand why I had to practice Etudes, until much later.

So what has an Etude to do with Kata’s? Lets look at the description of an Etude (at wikipedia):

“an instrumental musical composition, most commonly of considerable difficulty, usually designed to provide practice material for perfecting a particular technical skill”

Without going into detail of a Kata itself, it is used to practice and perfect a set of techniques. Repetition and practice until you’re able to perfectly perform a Kata (or an Etude if you will) will help you further when you need to improvise or apply it in different forms. A lot of Etudes, techniques, are used in real pieces. A lot of Code Kata’s are actually dealing with real world problems.

Its not all about the solution!

So if I practice enough code kata’s I will become good at any problem I might face when writing software?

Not quite.

Code Kata’s are flexible; meaning you must set yourself a goal you want to achieve by doing a kata. When doing an etude you don’t have a lot of options. Your main goal is getting better with your fingers to play a series of notes or transitions. With a Code Kata you could practice your typing. Or perhaps practice all short-cuts of your IDE. Or heck, learn a new IDE while doing one. Perhaps you want to learn a new language. Perhaps you want to get better at TDD. Or you simply want to get to the solution and find the most efficient way to do so.

Atleast, I found doing a code kata much more fun than doing an etude 🙂

Bowling Game Kata

The Bowling Game Kata is a Kata that challanges you to write a class (Game) that simulates a bowling ball game. You can roll balls and give the amount of pins knocked down. At the end you can call the score() method and you should get the correct score. It takes all rules into account, gutter, spares, strikes and the tenth frame where you can have 3 rolls instead of 2. The perfect game has 300 points. The worst game 0.

My initial thought: How hard can this be? I mean come on, I’ve dealt with harder things than a bowling game scoring system. Since I did not do any Code Kata before I set my goal to find the solution to this kata while doing TDD. I also did not want to look too much ahead in Uncle Bob’s (very nice) presentation (with solution). So I stopped when the game interface was given (roll() and score()) and I went ahead. Again, how hard could it be?

I have tried this Bowling Game Kata three times, and for each attempt I have written my experiences. All in all it was a very good experience and I recommend to try it out yourself. I believe if you want to get better, you need to practice. And only if you tried this multiple times, only then you know how it is.

So instead of talk the talk, let me walk the talk…

First attempt – Deception

Goal: Get it working, while doing TDD.

I set up a simple project and started with the GameTest. The first two tests where easy to do (0 pins, and all ones). But as soon as I got into Spares my first thought was to create a Frame class. Because a Frame represents a ‘turn’ where you can only roll 2 balls. The Frame class was born, along with its unit test. And I thought it felt good. I even added more ‘cheating’ detection. So you cannot roll 3 balls in one frame, or you cannot say you rolled 2 pins and then 9 (making 11 in one frame). I felt great and got unit tests working like nothing could stop me. Until the ‘perfect game’ test came around and my model just fell apart.

There was no way I could make it fit, without bending my entire model/solution.

So there I was, totally excited and thinking “just one more test and I’m done”.. and I got this.

Eventually I fixed it, I made my Frame class more flexible so I could set the maximum rolls and added flags. I then could create a TenthFrame class and set its flags so it would score differently. I also had created tests for the TenthFrame and even used an Abstract test class so I did not have duplicate code. Even so, I felt like this was wrong. I was bending my design just to work for one exception in the rules.

When I got all my unit tests passing, even the perfect score game, I just felt a great deception. My design sucked. Also, it took me almost 4 to 6 hours to get it working. Way too long for a code kata right?

Lessons learned
– TDD cycles where not strict enough; so…
– TDD cycles where slow, I had to switch mouse/keyboard to rerun the unit test(s)
– I made design decisions too early and later got ‘stuck’ and had to bend the design to make it work completely
– Finding the solution the first time takes time
– I made much more stuff than I had to (over-engineering?)

Trivia
– Time taken: roughly 6 hours.
– Amount of unit tests: 33

Second attempt – No need to bend the universe

Goal: Get it working, while doing TDD. Take lessons learned from first attempt. Aka: Tighter TDD cycles, get faster at TDD cycles, etc.

I started this kata late in the evening. I spent a fraction of the time compared to the first attempt: ~ 45 minutes(!). The later half hour mainly refactoring and keeping green bars. The actual solution was there within an hour. I did not have to bend my design, I could keep everything within the Game class!

Something little, but practical I learned about the IDE I used (Eclipse) is to short-key the ‘rerun last test’, so my TDD cycles where shorter.

I also noticed I understood the scoring of the bowling game much better. I don’t play this game very much, and when I do, the computer does all the scoring for me. So I guess the first attempt at the Kata took also longer because I had to understand the scoring rules.

Design wise I found that I still use “frames”, but not as a separate class. I do not have any cheating detection (so I can roll 12 pins and it won’t complain), but the scoring will utterly fail in that respect. Building these checks in would not be a problem though, because the spare/strike detection is now so easy.

Lessons learned
– Faster TDD cycle by using shortcut for re-running tests
– TDD cycles where stricter, but could be even more tightened
– Commenting out tests when more than one breaks really helps you get focussed on getting one thing to work (so leave one test breaking), instead of fixing all tests at once.
– No cheating detection, no over-engineering
– Of the time consumed, I spent more time refactoring relatively to the first attempt, than thinking / finding the solution.
– I could refactor a lot of code, and make it much more cleaner. And safely due the tests.

Trivia
– Time taken: roughly 45 minutes (!!)
– Amount of unit tests: 7

Third attempt – The only way to go fast is to go well

Goal: Tighten the TDD cycle. Get it done in 30 minutes or less.
This time I started fresh on a Sunday morning. Since I know the solution and I knew the design choices I made earlier (I know what works, and what does not work) things went very quick. I finished it within 30 minutes. I had the same amount of unit tests and the greatest thing was that the last test (perfect game) worked immediately. I did not had to change anything to make it work.

Once I had the last test working, I checked the code a bit and called it done. This time I also wanted to check my solution against the original presentation Uncle Bob made, to see if I missed anything or not. I figured that some of my tests where faulty:

– If you roll only ones, you can only roll 20 times and not 21 times. (i had a weird if statement to fix this up, but now it seemed that this was flawed).
– The perfect game was in my case 21 strikes, while you can only roll 12 times in that case. When I changed my test, it still worked.

It struck me that I was approaching this technically (21 rolls is maximum), and not from a functional point of view (ie 20 is max when only ones).

I also found that my TDD cycles where still to wide. I could do run the cycles close to each line of code, but I tend to write 2 or 3 lines before re-running my tests. Especially the first tests where suffering from this, later tests went better.

Lessons learned
– TDD cycles can be shortened
– Functional point of view caught errors in my tests
– Shortest kata ever (under 30 minutes)
– Latest test worked, design was good. Design was even better after fixing the test for ‘only ones’, so I could remove weird if statements.

Trivia
– Time taken: < 30 minutes
– Amount of unit tests: 5

Retrospective

So, after 3 attempts, do these Code Kata’s work for me? It surely learned me a few lessons. In short:
– The first time you do a Kata, it is slow. And you’re focussed on the solution. This could throw you off, but you have to persist…
– Later attempts are going much faster, and your focus shifts to other techniques. Mine was mainly speeding up my TDD cycle.
– I have learned a few things to speed up my TDD cycle, which I can apply in real world stuff as well. Which is good!
– Over-engineering will bite you, one way or another. Your design will be toast.
– I have learned that even in my last example I was approaching the solution too technical. As a Developer I still did not approach it entirely functionally. This meant that even though I thought I was done, I wasn’t. I do plan to use Acceptance tests (using JBehave) for this. That will be covered in a next blog.
– Above all, doing a Code Kata is fun!

I would advice to other developers to do Code Kata’s and get better at what they are doing. There are tons of areas where you can improve. In short, yes I do believe in them and I think you should give them a go, if you haven’t already!

Find more about Code Kata’s:
http://codekata.pragprog.com/
http://stackoverflow.com/questions/44533/your-favorite-code-kata
http://www.codinghorror.com/blog/2008/06/the-ultimate-code-kata.html

If you really want light-weight warm up exercises, you might want to go to: http://codingbat.com/