Flash Cards Kata and the transformation priority premise

I began the new year by resolving to complete the PCL (Peter Siebel's) book. Around the same time, another interesting post by Uncle Bob appeared on the WWW. A discussion on the TDD yahoogroups spurred me to try a Kata - two-sided Flash Cards.

Looked easy enough to test my new-found Lisp skills. Although I was not consciously choosing the next test / step based on the transformation priority, I was curious to know if I had been doing it all along without knowing it.

This innocuous looking kata had me stuck initially - what is the right first step? Trash-canned the first couple of attempts. The third attempt was slow but I succeeded. I did it again in C# just to see if the language had any bearing on my method. This time I was faster because I was familiar with the trail now.

  1. I am not wiser with regard to the priority premise - I found I used a bunch of transformations that were not part (bold) of the original list (shown in blue below). As a result, their priorities are unknown. This was the proverbial rain on my parade.
  2. Also in the C# variant, I found a couple of tests where I needed multiple transformations to get to the next green & I could not figure out a smaller test.
Note: Check the "speaker notes" in case things get dense especially with the Lisp one. Use the menu button at the bottom-right to get to the presentation link

Attempt#1 Flash Cards Kata in Lisp

TEST User should be asked a question
  • {} => statement
TEST A right ans should be confirmed
  • P5 (statement->statements) adding more unconditional statements.
TEST A wrong ans should be corrected
  • P6 (unconditional->if) splitting the execution path
TEST Diff card and a right ans
  • P4 (constant->scalar) replacing a constant with a variable or an argument
TEST Diff card and a wrong ans
  • constant => expr
TEST Multiple cards
  • {} => loop (statement)
TEST Answers are case insensitive
  • exprX => exprY
TEST Answers can have leading/trailing whitespace
  • value => expr
Attempt#2 Flash Cards Kata in C#
TEST User is asked the question
  • P2 nil -> constant
TEST User is asked another question (triangulate)
  • {} => statement *** Play()
  • constant => field *** LastQuestionAsked
  • void => statement *** Ask() - is there a smaller step here?
TEST A correct ans is confirmed
  • P2 nil -> constant
TEST A wrong ans is corrected
  • P5 (unconditional->if) splitting the execution path *** Play()
  • P4 (statement->statements) adding more unconditional statements
  • nil => expr *** User.WhoAnswers
  • field assignment *** User.ctor
  • constant => field *** User.LastConfirmationReceived
  • void => statement *** User.Notify
TEST A diff question and a right answer
  • P4 constant => scalar arg
TEST A diff question and a wrong ans
  • constant => expression
TEST Two cards
  • {} => statements
TEST Multiple cards
  • {} => loop
  • P4 (statement->statements) adding more unconditional statements *** User
  • field assignment *** User.ctor
TEST Case insensitive answers
  • exprX => exprY
TEST Trim leading/trailing spaces
  • value => expr