KyorCode: September 2011

Info:

280 pages
published 15-09-2010
ISBN: 978-93435-658-6
Author: Jonathan Rasmusson
Available here

After flying through this book, which implies it is a very pleasant reading, I have found a very broad basis to start developing in an agile way. I’m sure that after you have read this book you will come to the same conclusion. Even I you are an experienced agile developer, there are some really good pointers, tips & tricks in the book. All supported by amusing pictures.

The book is also boiled down into a story of “The master samurai” and “The apprentice”, at the end of each chapter they kind of review what you saw in that chapter and provoke some questions about it and a more practical insight into the matter.

The book walks the whole end-to-end process of developing in an agile way. Starting up by gathering requirements, analyze them, creating an iteration plan, monitoring that plan, execution styles and delivering production ready software. As a small bonus, the book goes scratches the surface of a few concepts that are very common in development.

Unit testing: creating an armor for yourself that your code works
TDD: Test driven development, creating the tests first relying on the validation of your user stories, prove they fail and then create the code to make them pass the tests and of course Refactor the code afterwards.
Refactoring as a good continuous practice
Continuous integration concepts

Albeit, this a must have book for your collection, I’m putting it up on my front row.

Regards,
Kyor

As first post I'm was inspired by this post. I thought about what Anoop said and started thinking about possible variations.

But lets start with the basics, right. If you stranded on this page I assume you know a wee bit about programming or a lot more then I do. (Just to note that I'm always open for tips, hints, criticism, ...)

A basic switch case in c# looks like this:

var str = "Toad";
            switch (str)
            {
                case "Bird" :
                    Console.WriteLine("It's a bird!");
                    break;
                case "Toad" :
                    Console.WriteLine("It's a toad!");
                    break;
                default:
                    Console.WriteLine(string.Format("I don't know a {0}.",str));
                    break;
            }

Nothing really special about it, when you have read through Anoop’s post you can alter a switch case to be the following:

public class SwitchCase : Dictionary<string, Action>
   {
       public Action DefaultAction
       {
           get;
           set;
       }
  
       public SwitchCase(Action defaultAction)
       {
           DefaultAction = defaultAction;
       }
  
       public void Eval(string param)
       {
           if (ContainsKey(param))
           {
               this[param]();
           }
           else
           {
               if (DefaultAction == null)
                   throw new NullReferenceException("Default action may not be null.");
               DefaultAction();
           }
       }
   }

Usage:

var sc = new SwitchCase(() => Console.WriteLine("The default action"))
                         {
                             {"Case1", () => Console.WriteLine("Case 1")},
                             {"Case2", () => Console.WriteLine("Case 2")},
                             {"Case3", () => Console.Write("Case 3")}
                         };
  
            sc.Eval("Case1");

Or converting this into a generic becomes:

public class ActionSwitchCase<TTkey> : Dictionary<TTkey, Action>
    {
        public Action DefaultAction
        {
            get;
            set;
        }
  
        public ActionSwitchCase(Action defaultAction)
        {
            DefaultAction = defaultAction;
        }
  
        public void Eval(TTkey key)
        {
            if (ContainsKey(key))
            {
                this[key]();
            }
            else
            {
                if (DefaultAction == null)
                    throw new NullReferenceException("Default action may not be null.");
                DefaultAction();
            }
        }
    }

Which you could use as:

var asc = new ActionSwitchCase<string>(() => Console.WriteLine("Default!"))
                                        {
                                            {"Case1",() => Console.WriteLine("Case 1")},
                                            {"Case2",() => Console.WriteLine("Case 2")},
                                            {"Case3",() => Console.WriteLine("Case 3")}
                                        };
  
            asc.Eval("Case1");

While actually putting it a bit further is applying it to functions, creating the following class:

public class FuncSwitchCase<TTKey, TInpuType, TResultType> :
        Dictionary<TTKey, Func<TInpuType, TResultType>>
    {
        public Func<TInpuType, TResultType> DefaultFunction
        {
            get;
            set;
        }
  
        public FuncSwitchCase(Func<TInpuType, TResultType> defaultFunc)
        {
            DefaultFunction = defaultFunc;
        }
  
        public TResultType Eval(TTKey key, TInpuType param)
        {
            TResultType output;
  
            if (ContainsKey(key))
                output = this[key].Invoke(param);
            else
            {
                if (DefaultFunction == null)
                    throw new NullReferenceException("Default function may not be null.");
                output = DefaultFunction(param);
            }
  
            return output;
        }
    }

Which then could be used as:

Func<string,string> f1 = (x) => x + "function 1";
            Func<string, string> f2 = (x) => x + "function 2";
            Func<string, string> df = (x) => x + "default";
  
            var fsc = new FuncSwitchCase<string, string, string>(df)
                          {
                              {"Case1", f1},
                              {"Case2", f2}
                          };
  
            Console.WriteLine(fsc.Eval("Case1","To hell with..."));

This opens a few doors in create switch cases. And credits to Anoop’s post putting down the idea.

Regards,
Kyor

KyorCode

Thursday, September 8, 2011

Bookreview: The Agile Samurai–How agile master deliver great software

Thursday, September 1, 2011

An other view on a Switch Case