I Am Not Myself

Vacation of Fluent NHibernate: Tuesday Conventions

Bobby Johnson — Fri, 30 Oct 2009 01:13:28 GMT

Well here we are on Thursday and I am finally posting Tuesday’s video. When I started doing this I had no idea how long it would take to produce one of these videos. I have a pretty good idea now. ;)

In this installment I cover conventions, both ClassMap conventions and AutoMap conventions. I slowly convert the ClassMap implementation over to AutoMap by leaning on default convention and then adding my own as needed. This demonstration should give you a firm understanding of how conventions work in Fluent NHibernate.

Vacation of Fluent NHibernate: Monday ClassMaps

Bobby Johnson — Tue, 27 Oct 2009 22:32:02 GMT

Hello Tuesday! Wait a minute this is Monday’s video. That’s right I spent so much time on Monday producing the Introduction video and planning the ClassMaps video, I didn’t get around to making Monday’s until Tuesday. But hey I am on vacation what are you expecting from me really?

So, today I am covering the topic of ClassMaps in Fluent NHibernate. I used Steve Bohlen’s Summer of NHibernate code from session 9 as a starting place. In this video you will see me get the code running on my machine, upgrade it to NHibernate 2.1.0 GA and then convert it over to using ClassMaps. The video clocks in at just over 30 minutes. Enjoy.

Vacation of Fluent NHibernate: Introduction

Bobby Johnson — Mon, 26 Oct 2009 22:32:14 GMT

Inspired by Steve Bohlen’s Summer of NHibernate screencast series, I thought I would spend some of my vacation creating an addendum to it called Vacation of Fluent NHibernate.

Links from the Screencast:

TDD Kata Calculator Demonstration

Bobby Johnson — Fri, 23 Oct 2009 00:04:18 GMT

While at Alliance, a couple team members and I got the bug to do Code Katas. We picked up on Roy Osherove’s TDD Kata and started doing it as a team every morning time boxing ourselves to half an hour.

The three of us would hit a conference room and throw an IDE up on the wall with a projector. One person would write tests, another would implement and the third would be the “Business” representative by reading the requirements and making judgment calls on any questions we had. Every morning we switched positions.

This worked out really well, one person would do something interesting one day and the others would pick up on it and start doing it as well. For example, when creating a list of delimiters we all started out using a List<char>() because we couldn’t remember how to add a element to an array and didn’t want to take the time out of our thirty minutes to look it up. But then John, started using a string to hold our delimiters simply appending any extra ones on that were need. He then performed the split by using “delimiters.ToCharArray()”.

Terry, sick of writing the same setup code for the unit tests for each test, implemented a extension method that wrapped it up nicely so that all our tests were a single clear line.

This was a great way to practice TDD and to learn from my peers. I’ve moved on now from Alliance, but I am going to miss those guys. Hopefully, I’ll be able to get something similar going at the new gig. And, eventually recruit Terry and John… Just kidding, Craig. 8)

This video is just me, but it represents all the things we came up with to improve the design of our earlier solutions. It is also a great demonstration of using ReSharper and xUnit. Be sure to watch it in full screen, so that you can actually see what is going on. Next time, I’ll try some thing bigger. Anyone have tips?

And before you ask, yes you can have my crazy color scheme. 8) Oh I used Camtasia Studio 6 to produce the video. Great tool easy to use. Wish I had $300 to buy a license. 8) Well I’ll try to produce as many as I can in my 30 days.

Using MSpec to Solve Kata Potter Part 1: The Specifications

Bobby Johnson — Tue, 20 Oct 2009 05:25:01 GMT

Kata Potter is an interesting problem intended to be used as a learning exercise in TDD. The problem is described like this:

Once upon a time there was a series of 5 books about a very English hero called Harry. (At least when this Kata was invented, there were only 5. Since then they have multiplied) Children all over the world thought he was fantastic, and, of course, so did the publisher. So in a gesture of immense generosity to mankind, (and to increase sales) they set up the following pricing model to take advantage of Harry's magical powers.

One copy of any of the five books costs 8 EUR. If, however, you buy two different books from the series, you get a 5% discount on those two books. If you buy 3 different books, you get a 10% discount. With 4 different books, you get a 20% discount. If you go the whole hog, and buy all 5, you get a huge 25% discount.

Note that if you buy, say, four books, of which 3 are different titles, you get a 10% discount on the 3 that form part of a set, but the fourth book still costs 8 EUR.

Potter mania is sweeping the country and parents of teenagers everywhere are queuing up with shopping baskets overflowing with Potter books. Your mission is to write a piece of code to calculate the price of any conceivable shopping basket, giving as big a discount as possible.

I have been working on solving this kata over the last couple weeks. One goal I had was to understand how Machine.Specifications (MSpec for short) fits in to the BDD development process. MSpec is a framework written by Aaron Jensen that sits on top of your current unit testing framework (as long as you happen to be using NUnit or XUnit). You can read Aaron’s introduction to MSpec here where he does a much finer job at explaining it that I can.

My goal with MSpec was to be able to define the acceptance criteria for Kata Potter before writing a single line of implementation code. MSpec also has the added benefit of allowing me to execute my acceptance criteria on the code as it evolves and report back on my progress. With MSpec I can express what the system under test must do to satisfy all the requirements.

So given MSpec’s utility I started out to write a set of requirements based on the Kata Potter description.

Given a cart containing a single book when the price is calculated it should return the full price of the book.
Given a cart containing two different books when the price is calculated it should return the price of both books with a 5% discount applied.
Given a cart containing three different books when the price is calculated it should return the price of all books with a 10% discount applied.
Given a cart containing four different books when the price is calculated it should return the price of all books with a 20% discount applied.
Given a cart containing five different books when the price is calculated it should return the price of all books with a 25% discount applied.

This covers the full set of books, but the kata gives us another example:

Given a cart containing four books where two are the same title when the price is calculated it should return price of three books discounted by 10% and the full price of the fourth.

Using MSpec I can express these requirements in an executable fashion like this:

using Machine.Specifications;

namespace Kata.Potter.CoreTests.Specifications
{
    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_a_book
    {
        It should_return_the_full_price_of_the_book;
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_two_different_books
    {
        It should_apply_a_five_percent_discount;
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_three_different_books
    {
        It should_apply_a_ten_percent_discount;
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_four_different_books
    {
        It should_apply_a_twenty_percent_discount;
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_five_different_books
    {
        It should_apply_a_twenty_five_percent_discount;
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_four_books_where_two_are_the_same
    {
        It should_apply_a_twenty_percent_discount_to_three_of_the_books;
    }
}

With out a single line of code implementing these specifications, I can even execute my tests. I get the following display in the ReSharper test runner:

Notice that the runner ignores all my tests currently returning the message that the specifications are “Not implemented”. As I write code to satisfy the requirements, the tests will being to go red and then green as each specification is implemented.

The next step in this process is to begin identifying collaborators in the system. Based on the requirements I know that I need objects that represent a Book, a Shopping Cart and a Calculator that calculates the price of all the books in the cart. I’ll begin by creating shell classes that I can use to wire up my specifications to implementation code.

public class Book
    {
        public Book(string title, decimal price)
        {
            Title = title;
            Price = price;
            IsDiscounted = false;
        }

        public string Title { get; private set; }
        public decimal Price { get; set; }
        public bool IsDiscounted { get; set; }
    }

    public class Cart
    {
        public Cart()
        {
            Books = new List<Book>();
        }

        public IList<Book> Books { get; private set; }

        public void AddBook(Book book)
        {
            Books.Add(book);
        }
    }

    public class PriceCalculator
    {
        public decimal CalculatePriceFor(Cart cart)
        {
            return 0;
        }
    }

With this simple implementation, I can now modify my MSpec specifications to exercise these objects. I’ll start with the first one to give you the feel of what it looks like.

[Subject("calculating discount prices")]
    public class when_calculating_the_price_of_a_book
    {
        private static Cart cart;
        private static PriceCalculator calculator;
        private static decimal price;

        Establish context = () =>
                                {
                                    cart = new Cart();
                                    cart.AddBook(new Book("Book 1", 8M));
                                    calculator = new PriceCalculator();
                                };
        Because of = () => price = calculator.CalculatePriceFor(cart);               

        It should_return_the_full_price_of_the_book = () => price.ShouldEqual(8);
    }

First, I establish my specification’s context by newing up my Cart and PriceCalculator classes and adding a single book to the cart. This establishes the environment that the test will run in which matches the name of the class pretty closely. I am calculating the price of a single book. Next, I clearly call out what action is performed to test against. I tell the calculator to calculate the price for the given cart. Finally, I make assertions on the state of my context objects. For this specification, all I need to do is validate that the calculated price is equal to the price of the book.

If I execute my specifications now, this spec will turn from ignored to red. I have now implemented the collaborators and weaved them into specifications to be validated. Here is what shows up in the ReSharper runner:

The next thing we need to do is fill in the rest of the specifications and make them all turn red as well. If I do this following the pattern of the test we already have I am going to create a lot of duplicated code. Each specification class will have the same private members and most of the context as well. So first I am going to pull those elements out into a base class and refactor my first specification like so:

    public class with_price_calculator
    {
        protected static Cart cart;
        protected static PriceCalculator calculator;
        protected static decimal price;
        protected static decimal correctPrice;

        Establish context = () =>
                            {
                                cart = new Cart();
                                calculator = new PriceCalculator();
                            };
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_a_book : with_price_calculator
    {
        Establish context = () =>
                                {
                                    cart.AddBook(new Book("Book 1", 8M));
                                };
        Because of = () => price = calculator.CalculatePriceFor(cart);               

        It should_return_the_full_price_of_the_book = () => price.ShouldEqual(8);
    }

One of the cooler features of MSpec is the way it chains delegates together during execution. Notice that my base class has an Establish statement and my specifcation class has one as well. The specification class inherits from the base class but it does not override the Establish statement. Instead MSpec will execute all the Establish statements in the inheritance chain from the “base-ist” to the “descended-ist”. I can now implement the remaining specification quickly like this:

    public class with_price_calculator
    {
        protected static Cart cart;
        protected static PriceCalculator calculator;
        protected static decimal price;
        protected static decimal correctPrice;

        Establish context = () =>
                            {
                                cart = new Cart();
                                calculator = new PriceCalculator();
                            };
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_a_book : with_price_calculator
    {
        Establish context = () =>
                                {
                                    cart.AddBook(new Book("Book 1", 8M));
                                };
        Because of = () => price = calculator.CalculatePriceFor(cart);               

        It should_return_the_full_price_of_the_book = () => price.ShouldEqual(8);
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_two_different_books : with_price_calculator
    {
        Establish context = () =>
        {
            cart.AddBook(new Book("Book 1", 8M));
            cart.AddBook(new Book("Book 2", 8M));
            correctPrice = 8*2 - (8*2*.05M);
        };

        Because of = () => price = calculator.CalculatePriceFor(cart);

        It should_apply_a_five_percent_discount = () => price.ShouldEqual(correctPrice);
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_three_different_books : with_price_calculator
    {
        Establish context = () =>
        {
            cart.AddBook(new Book("Book 1", 8M));
            cart.AddBook(new Book("Book 2", 8M));
            cart.AddBook(new Book("Book 3", 8M));
            correctPrice = 8 * 3 - (8 * 3 * .1M);
        };

        Because of = () => price = calculator.CalculatePriceFor(cart);

        It should_apply_a_ten_percent_discount = () => price.ShouldEqual(correctPrice);
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_four_different_books : with_price_calculator
    {
        Establish context = () =>
        {
            cart.AddBook(new Book("Book 1", 8M));
            cart.AddBook(new Book("Book 2", 8M));
            cart.AddBook(new Book("Book 3", 8M));
            cart.AddBook(new Book("Book 4", 8M));
            correctPrice = 8 * 4 - (8 * 4 * .2M);
        };

        Because of = () => price = calculator.CalculatePriceFor(cart);
        It should_apply_a_twenty_percent_discount = () => price.ShouldEqual(correctPrice);
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_five_different_books : with_price_calculator
    {
        Establish context = () =>
        {
            cart.AddBook(new Book("Book 1", 8M));
            cart.AddBook(new Book("Book 2", 8M));
            cart.AddBook(new Book("Book 3", 8M));
            cart.AddBook(new Book("Book 4", 8M));
            cart.AddBook(new Book("Book 5", 8M));
            correctPrice = 8 * 5 - (8 * 5 * .25M);
        };

        Because of = () => price = calculator.CalculatePriceFor(cart);

        It should_apply_a_twenty_five_percent_discount = () => price.ShouldEqual(correctPrice);
    }

    [Subject("calculating discount prices")]
    public class when_calculating_the_price_of_four_books_where_two_are_the_same : with_price_calculator
    {
        Establish context = () =>
        {
            cart.AddBook(new Book("Book 1", 8M));
            cart.AddBook(new Book("Book 2", 8M));
            cart.AddBook(new Book("Book 3", 8M));
            cart.AddBook(new Book("Book 3", 8M));
            correctPrice = (8 * 3 - (8 * 3 * .1M)) + 8;
        };

        Because of = () => price = calculator.CalculatePriceFor(cart);

        It should_apply_a_ten_percent_discount_to_three_of_the_books = () => price.ShouldEqual(correctPrice);
    }

Note that I have added another member to the base class to capture what I think the correct price should be to then use as an assert later on. Executing my specifications now show all red. I can continue implementing functionality using traditional TDD or by writing more specifications for each collaborator using the same techniques.

Next time, I will cover the actual implementation that solves the kata potter that I arrived at through this process.

SSDNUG Presents: Eric Lee on Anti-Patterns in Legacy Code November 12th

Bobby Johnson — Fri, 16 Oct 2009 15:46:48 GMT

The South Sound .NET Users Group is pleased to present Microsoft’s Eric Lee on the evening of November 12th from 7:00 PM – 9:00PM at Olympia Center in downtown Olympia. This presentation promises to be an enlightening evening with not only an outstanding member of the .NET community offering sage advice, but also honest upfront discussion from a developer with over 15 years of experience working in the belly of Microsoft’s most successful divisions.

About Eric’s presentation “Common Anti-Patterns in Legacy Code”:

One of the most dreaded phrases in software engineering are the words “legacy code”. You know what that means: old, nasty code that gives you ulcers and makes you tear our your hair. In this presentation we’ll swap horror stories, discuss ways to make legacy code a little more manageable, and learn some principles that will help you avoid writing legacy code of your own.

About Eric Lee:

I’ve worked for Microsoft for over fifteen years as a developer of testing tools and other applications in the Office division and in Microsoft Game Studios. I’ve inherited multiple legacy systems during my career and have had to suffer through the resulting pain. I’m sad to say I’ve probably also written a legacy system or two. As a result I have some opinions about the sorts of things that makes code either maintainable or a legacy nightmare.

View Larger Map

South Sound .NET Users Group Schedule Filling Up With Pure Awesomeness!

Bobby Johnson — Fri, 04 Sep 2009 15:32:35 GMT

So last week I threw up the bat signal to the internets in an effort to help my local user group find some speakers for the coming months. The response has been great and I have successfully booked some great speakers. I set a goal to book six months of “no wizard based demo” speakers and I am quickly achieving that goal.

Here is a sample of what is coming in the next few months. I have made up titles for the presentations based on discussions with the presenters, so they are subject to change once then have finalized their presentations. But you get the idea. This stuff is going to be a code monkeys dream come true.

October 8th	Jeff Olson	Introduction to TDD & Context/Specification Testing
November 12th	Eric Lee	Common Anti-Patterns in Legacy Code & How to Work Your Way Out of Them
December 10th	James Thigpen	Introduction to MVP in WinForms Applications
January 14th
February 11th	Jason Olson	Parallel Programming with Visual Studio 2010
March 11th
April 8th

I have also heard from Chris Tavares (Enterprise Library 5), Chris Bilson (Introduction to PowerShell), Ron Woan (Mr. Awesome) and Justin Bozonier and am working out dates with them.

Once again, if you are interested in coming to beautiful downtown Olympia, WA (where Kurt Kobain began his musical journey into depression) and speaking feel free to email me at bobby.johnson@gmail.com.

South Sound .NET Users Group Call For Speakers

Bobby Johnson — Wed, 26 Aug 2009 17:06:42 GMT

The amazing Camey has been organizing speakers for the South Sound .NET Users Group longer than I have been a participating member. She recently received the bouncing bundle of joy visit from the stork and needs some well deserved time off. She asked if I could take over the reigns and gather up some folks to come talk to us and I readily agreed.

So, if you read my blog, are local to Olympia, WA (I’m looking at you Seattle and Portland…) and are interested in presenting to a .NET Users Group have I got a deal for you! I have one slightly cramped room and a projector with your name on it.

We meet regularly each month on the second Thursday at the Olympia Center in downtown Olympia. Meetings start at 7:00 PM and run for two hours till 9:00 PM. We usually retire to the Fish Tail Brewing Company’s pub the Fish Bowl for a few pints and conversation afterward. Speakers always drink free.

We currently have the following dates available (which are filling up fast!):

October 8th	Jeff Olson	Introduction to TDD & Context/Specification Testing
November 12th	Eric Lee	Common Anti-Patterns in Legacy Code & How to Work Your Way Out of Them
December 10th	James Thigpen	Introduction to MVP in ASP.NET
January 14th
February 11th	Jason Olson	Parallel Programming with Visual Studio 2010
March 11th
April 8th

If you are interested at all please feel free to contact me bobby.johnson@gmail.com.

Explain Phishing to Your Grandma

Bobby Johnson — Tue, 11 Aug 2009 23:19:28 GMT

Excellent PSA that I found by way of The Consumerist. Original source.

Ward Cunningham on the Origin of the Term “Technical Debt”

Bobby Johnson — Tue, 11 Aug 2009 19:51:17 GMT

Presentation Patterns Wiki Available to the Public

Bobby Johnson — Mon, 10 Aug 2009 14:57:31 GMT

Jeremy Miller has been commissioned by Addison Wesley to write a book on Presentation Patterns. He has chosen to do this the Martin Fowler way by using a wiki engine and making it available to the public as he writes it. This book is targeted directly at the “How”s of writing desktop applications and rich clients using WPF and Silverlight. Here is a brief description from the site:

Inside of an enterprise application, the user interface layer can be very complex in its own right and is a huge source of potential bugs because of the element of human interaction. This book will present the design patterns that can be used to manage the complexity of user interface code. The book will discuss patterns for organizing the responsibilities of a single screen, coordinating the activities of multiple screens within an application, and architecting a structure that allows a desktop application to be efficiently extended over a longer lifecycle.

The Lounge’s James Avery on Bootstrapping Your Own Company

Bobby Johnson — Mon, 10 Aug 2009 14:40:43 GMT

James Avery is the owner operator of The Lounge Advertising Network, a small focused advertising network that targets Microsoft technologies. He has some great advice on how to breakout and get started working for yourself.