I created a repository on GitHub with the code so I can share my first attempt.

You can follow the commit comments to get an idea of the train of thought.

Or if u prefer, just keep reading

The Methodology

I used TDD and somehow BDD all the way. Started with an acceptance test and jumped in and out from the unit tests until the feature passed.

Why is a good idea to start with an acceptance test?

When you know where you want to go, what you want to achieve, is easier to keep the focus.

Having a way of identifying if the current feature is finished is a lot of power in your hands, so do the minimum necessary to make it work and then – once the test is passing – do refactoring as you see fit.

In the solution you will find three projects:

1. BowlingKata: Classes that implement the Kata
2. BowlingKata.Unit.Tests: Unit tests
3. BowlingKata.Acceptance.Test: Features that I’m looking for in a bowling game

Design Decisions (fast forward TDD)

As soon as I started to write a unit test for the BowlingGame class I wonder how am I going to design the solution.

My first test was for the method Roll(pins). And right there I had to assign responsibilities.

What should this method do? Do the “registration” only? Do the calculation as well? Is there any other class involved?

I decided on keep things simple and separate two clear responsibilities:

1. Keeping the number of pins knocked down on each ball (or frames later)
2. Calculating the score based on the information on each frame

First I installed a local server and then updated the projects to use some of the packages from the local server.

The references were updated. Solution builds fine.

So I decided to update the rake build script and add the  local source.  First roadblock ahead.

More than one source

Now, I run the rake script to get all the packages to make sure it works and I found that when installing the packages the source is not stored in the  packages.config file.

What a disappointment… but don’t let this drag you down… there’s still hope!

First I checked on twitter and confirmed that in the current version the source is not part of the packages config and I started a discussion on the codeplex nuget site to talk about it.

Now, I have to figure out how to identify the local packages…

Using a config file for the local packages

Because I can’t store the source of the packages in the packages.config file I decided to use another file, packages_local.config to store my local packages.

Then, I changed the rakefile task to do the following:

FileList["**/packages_local.config"].each do |file|
	cp file, "packages.config"
	sh "nuget install packages.config /OutputDirectory Packages /source #{local_feed}"
end

If you are wondering why I need to copy the local to “packages.config”, is because the command line only accepts “packages.config” as a configuration file. Yeah, I know….

Thank god for contributors!

Luckily, when I was writing this post I received an updated from the nuget discussion (look at the end) forum talking about using multiple sources.

In the update Dan Turner mentioned a fork he did of the command line project to add two things:

• Using multiple sources
• Using repositories.config (file left inside packages folder) to load all the packages.config

Awesome! So I cloned the fork, build the solution, grab the new nuget.exe and voila! It works!

Here is the final version of the rakefile:

desc "Setup dependencies for nuget packages"
task :dep do
	remote_feed = "https://go.microsoft.com/fwlink/?LinkID=206669"
	local_feed = "http://wpgbuild02:8090/dataservices/packages.svc"
	FileList["**/packages.config"].each do |file|
		sh %Q{nuget install #{file} /OutputDirectory Packages /Source "#{remote_feed};#{local_feed}"}
	end
end

I’m still using the FileList to get all the packages.config because the Packages folder is removed and not stored in the repository.

The drawback is that is not the official release, thus getting updates is going to be a problem. Hopefully they will merge them soon.

Hope it works for you, let me know if you have any questions.

It was fun to have a virtual audience.

I uploaded the code and slides to the presentations page.

Any feedback would be appreciated! Feel free to ask any questions.

Enjoy!

The course would take place at New Media Manitoba and if you’d like to attend here is the link to register.

Why you should attend?

RoR is a full MVC web development framework that would show you that developing web applications can be intuitive, professional, secure, easy and fun!

What is so great about Rails? Here are some reasons:

• It’s based on ruby, so you get all the power of a dynamic language.
• Automatic dependencies and library management using Gems
• Automatic relational mapping to databases
• Behaviour Driven Development
• Test Driven Development
• Database versioning, migrations and seeding
• Automatic REST implementation
• Rake DSL
• Support for multiple view engines (like haml)
• Huge base of libraries (gems) and users around the world

Who should attend?

Any developer with basic knowledge of a programming language can learn RoR.

What do I get?

In this course you will build the confidence and real hands on knowledge to start developing high quality RoR applications. You will learn:

• Ruby scripting
• Rails MVC architecture.
• Package management with Gems.
• How to apply Behaviour Driven Development, and Test Driven Development.
• Persistence mapping with ActiveRecord.
• RESTful services.
• Manage source versioning with Git.
• Automated deployment with Capistrano.

Are you sure it’s a course for me?

Of course, it does not matter if you are a .NET, Java or Eiffel developer, RoR would open your mind to new concepts, technologies and tools that would complement and improve your daily tasks.

Any more questions, please contact me at amir@barylko.com.

Hope to see you there!

You can read about it at http://www.prairiedevcon.com/. It would be two complete days of sessions with four tracks and many cool speakers!!!!

I will do two presentations:

Real World Behaviour Driven Development

Behaviour Driven Development drives you process towards keeping the focus on the stakeholder’s goals while discovering new features to achieve those goals.
But… what does it mean in a .NET project to use BDD? What do I have to change? What tools are available? Can I use it for project with actual deadlines? How the quality will be improved?
We are going to see a real world example from start to finish using BDD and TDD while answering all those questions. After the session you will have the foundation to apply BDD with confidence on any .NET project.
Track: Developer Foundation
Style: Dojo (Bring your laptop and code with me!)

Test Driven Development Patterns for .NET Developers

Test Driven Development is a methodology that will help us to discover our model while improving the quality of our software.
We are going to see different patterns to help us deal with day to day problems like constructor initialization, exception testing, combinatorial tests, database testing, and many others.
Track: Developer Foundation
Style: Lecture

Hope to see you there!!!

One of many great things about blogging is that you get feedback from other developers. My good friend Sebastian (@paraseba) suggested to use a Chain-of-Responsibility instead of a Composite to find the an active snapping strategy. If u have no idea what I’m talking about, please read the previous post about “Implementing a Snapping Strategy“.

CoR Pattern

In the Design Patterns book, the authors describe the Chain of Responsibility pattern like this:

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

In our case this means that we should give the opportunity to each strategy to do the snapping and if no snapping is available should call the “chained” strategy to see if the point should be snapped.

The solution it’s working, good time to refactor (Red, Green, Refactor) to add more flexibility to our strategies.

Let’s explore what changes do we need to do in order to be able to chain the strategies.

Chained Strategies

I don’t think we should modify the interface, no one needs to know which pattern are we implemented, so I am going to create a new abstract class called ChainedSnappingStrategy.

This class will be the base implementation for all the other strategies with two responsibilities:

• Call the next strategy in the chain if no snapping was applied
• If it’s the end of the chain, return the same point.

Our hierarchy updated will look something like this:

I added a new abstract method called SnapImpl to implement in each concrete class the snapping (same as we have now).

The Snap method should call the implementation first and then check if the point was snapped or not, if not should go to the next strategy. Here is the code:

   1: public abstract class ChainedSnappingStrategy : ISnappingStrategy

   2: {

   3:     public ISnappingStrategy Next { get; set; }

   4:

   5:     public Point Snap(Point point, IDrawingContext context)

   6:     {

   7:         var result = this.SnapImpl(point, context);

   8:

   9:         if (this.Next != null && result == point)

  10:         {

  11:             result = this.Next.Snap(point, context);

  12:         }

  13:

  14:         return result;

  15:     }

  16:

  17:     protected abstract Point SnapImpl(Point point, IDrawingContext context);

  18: }

And voila, our strategies are chained!

For the past eight months I’ve been working on a WPF  desktop application that has a tool to draw. Very similar to most drawing application, you select the Drawing tool in the ribbon/toolbox and then you are able to draw on the canvas until you close the shape or cancel the tool.

The new requirement

Now, we need to draw using snapping. Snapping means that when you are drawing close to a particular point (considering a distance) the mouse will move but the drawing line not, will stay snapped to the point.

In this case we need to consider three cases:

1. Snapping on the X axis (horizontal axis)
2. Snapping on the Y axis (vertical axis)
3. Snapping when the line has an 90 degree angle with the previous line

The solution

Where should I add the snapping?

So I started by writing a test  (Yes, full TDD) that checks when I’m close to the X axis (3 pixels or less) then the drawing tool should snap. My test failed gloriously and I was ready to start my implementation in order to make the test pass… now… the question is… who is responsible for snapping?

The Drawing Tool

Let’s review the drawing tool interaction to understand how it works using MVVM.

• The Canvas receives a mouse move event and passes that information to the DrawingTool
• The DrawingTool raises a LineMoved event
• The view model receives the event and notifies the view
• The view shows the line ending on the new point

A sequence diagram should look something like this:

Who is responsible for snapping?

The DrawingTool does not know about snapping, but it should, because is raising the event… However considering the SRP (single responsibility principle) makes more sense to delegate this decision to another class, behold the ISnappingStrategy.

I decided to inject the strategy into the DrawingTool constructor (via IoC) and the DrawingTool will query the strategy for each point before raising the event, thus the event will contain the point decided by the strategy.

Let’s look at the new sequence diagram with the strategy added to the interaction:

Why a strategy? Is that the GOF pattern?

Indeed it is, why? Because I wanted to encapsulate the algorithm I’m going to use to snap, snapping to X axis has different rules than snapping to the previous line when having a 90 degree angle. Please refer to the GOF book “Design Patterns” or Google for more examples and diagrams.

Snapping Strategy Hierarchy

I have so far one interface ISnappingStrategy and three concrete strategies that implement the interface:

Each strategy when called will return the snapped point or, if no snapping is required the same point.

So far, so good…. now I have implemented them, and each one passes the unit tests. However I don’t want to use just one of the them, I want to use all of them combined. I’d like to use first SnapToX and if does not snap, then SnapToY, etc, etc.

Enters the Composite Strategy

The Composite pattern is another GOF pattern and the goal is to treat a group of objects like they where a single instance. In this case, I want to use multiple snapping strategies like they were just one strategy.

Here is the idea, let’s create the Composite with a collection of strategies, and when called the Composite will iterate thru them until it finds a new snapping point or, if no snapping should happen, return the same point.

So, with the Composite, the new hierarchy looks like:

And the code for the composite snapping would be:

   1: public Point Snap(Point point, IDrawingContext context)

   2: {

   3:     var found = this._strategies.Find(s => s.Snap(point, context) != point);

   4:

   5:     return found == null ? point : found.Snap(point, context);

   6: }

The cherry on top

Now we need to configure all this, luckily we can use Binsor to configure our Windsor container and it will look something like this:

   1: component "SnapToX", ISnappingStrategy, VectorSnappingStrategy:

   2:   x = 1

   3:   y = 0

   4:

   5: component "SnapToY", ISnappingStrategy, VectorSnappingStrategy:

   6:   x = 0

   7:   y = 1

   8:

   9: component "SnapToPrevious", ISnappingStrategy, PreviousLineSnappingStrategy

  10:

  11: component "SnappingStrategy", ISnappingStrategy, CompositeSnappingStrategy:

  12:   strategies = [@SnapToX, @SnapToY, @SnapToPrevious]

  13:

  14: component "DrawTool", IDrawTool, DrawTool:

  15:   snapping = @SnappingStrategy

Neat eh?

First of all, I would say that you have to be sure that you would like to be an architect, and for that we have to agree on an architect definition.

An architecture in software development can be considered a collection of different components, each one with a particular role, and the interaction between them through interfaces.

Therefore, an architect is responsible for defining the best architecture in order to solve the problem at hand. In order to do that the architect should have technical roots and technical acuity to grasp technical issues and collaborate with the team to solve them. The architect will have the global view of the system and would be responsible of identifying the major issues that have to be addressed to avoid failure.

An architect has to be close the developers and able to answer questions and provide guidance to the rest of the team. He has to be fond of writing code and familiar with the technology the team is using. A good architect will be a combination of being a excellent technologist, strategist and politician.

The difference between the team leader (or lead developer) and the architect is the scope and the responsibility. The architect has a broader scope that includes interaction between different components, security, response time, etc.

Many times the architect role is considered a “promotion” or the next step in the hierarchy for a lead developer. But that may be a mistake because unfortunately not all the great developers or leads have the broad talents required to be an architect.

So, what should we do to achieve such a worthy goal?

Here is a (mixed) list of subjects to learn and practice (not exclusive, just a starting point):

• Different architectures: Which well known architectures are available?
• Security: How to secure applications and systems, which options are available, benefits, etc.
• Concurrency: How to run process in parallel? Implementation, Benefits, drawbacks….
• Communication and Services: Why be service oriented? What kind of services are available?
• Testing: TDD, functional testing, how to write scripts to test web or desktop apps.
• Storage: Which databases or alternative methods of storage are available?
• Development methodologies: Which ones are available? Why should I use one instead of the other?
• Agile planning and management: How does it work? What is the difference with classic management?
• Source Control Management: SVN, CVS, GIT…
• Continuous Integration: What? Why? When
• Development platforms: Rails? J2EE? .NET? GWT?
• Politics: How to be politically correct and identify managers and customer needs.
• Communication: How to communicate with your team, managers and customers effectively.
• Requirements: What should they look like? When is enough?

Sometimes, architects specialize in one technology or framework (i.e: Web Services Architect, .NET Architect, Testing Architect). I think is natural to have more experience in a particular technology than other but that doesn’t mean that you should ignore the rest. Not always the job you are working on will help you to develop or to grow towards being and architect. That, I’m afraid to say is up to each of us.

As any software professional you have to research, read books, blogs and try to meet others with the same goals. Keep your information up to date, find tendencies, success stories, antipatterns (patterns to identify failure) and guidelines.

Here are some books I like (see the link for the full information) and think can be helpful:

• Patterns of Enterprise Application Architecture
• Design Patterns
• Manage It!
• Enterprise Integration Patterns
• Refactoring to Patterns
• Java Concurrency in Practice
• Enterprise Recipes with Ruby and Rails
• Software Architecture in Practice
• Documenting Software Architecture, Views and Beyond

And here some blogs that I like:

• ScottGu’s
• Haacked
• James Gosling: on the Java Road
• Ayende @ Rahien
• The Planetarium
• StackOverflow

There is no certified recipe, you will find all kind of architects with many strengths and weaknesses. As with any other role, try to find architects that inspire you, people that you respect that will help you to keep your spark alive. Follow them in their blogs, books and conferences. They would lead you to other great professionals for sure.

Here are some of mine:

• Martin Fowler
• Bertrand Meyer
• James Gosling
• Scott Meyers
• Kent Beck
• Scott Guthrie

As a closing remark, keep in mind that is very important to work supporting your team and whatever you do don’t become a “Seagull architect“.