Stefano Ricciardi

Book Review: Version Control With Git

2014-08-10T12:55:13+00:00

Your first encounter with GIT as a version control tool may be quite intimidating, especially if all you had been using so far was something simpler like Subversion, TFS or, God forbid, Visual Source Safe. "Version Control with GIT" by Jon Loeliger, Matthew McCullough (published by O'Reilly) leads you on a journey to become a master of the tool. But the path is not short and easy. If you need quick gratification, then you might have to look elsewhere.

Do I Need a Book on GIT?

There a plenty of GIT related resources online, and more get added the more it is adopted even outside of the open source world. If your use of GIT is just only to share your own pet projects on GitHub or to occasionally fork an open source repository, make a few changes and submit a pull request, then probably a brief list of commands with some basic concepts will get you covered.

On the other hand, if to use GIT on a daily basis at work, or work on a complex open source project with dozens of contributors and hundreds of commits, then you need to go a bit deeper and understand the nuts and bolts.

What's In The Book

After touching briefly on the installation process, the first dozen of chapters deal exclusively with one (local) repository: the object model, the index file, commits, branches, diffs and the all important concept of merging. Sometimes the description is so accurate that you can almost visualize the software data structures underlying the design concepts the author is guiding you through; but this is not just a technical curiosity to entertain the reader: everything that is discussed has got practical implications on your usage of the tool (e.g. which merge algorithm you should choose, or whether to opt for a 'rebase' versus a 'cherry-pick').

The book then devotes a couple of chapters covering how to interact with remote repositories, and then tackles more advanced topics like repository management, patching, hooks, submodules, interacting with SVN and a few other tip and tricks. It finally mentions GitHub in the last chapter.

The Good and the Bad

If you need detailed information about GIT, then this is the deal (short of reading the source code I guess). Every aspect of the tool is explained (sometimes in excruciating detail) and the authors go to a great length to provide tips and gotchas on commands (especially when you might easily shoot yourself in the foot). However this is not a quick read and it will take time to digest it.

What's missing, maybe, it's a 'quick start' chapter at the beginning to get you going if you need to be up and running in a short amount of time (say you have landed a new job where GIT is in use and you have little or no experience). That would help with the transition while giving you more time to go through the details. Unfortunately, the reader will have to look for such a compendium elsewhere.

Firefox, Fiddler and HTTPS

2014-01-17T09:39:23+00:00

Today I was debugging some interaction between one of our products and Twitter 1.1 API protected by OAuth 1.0a . As it happens, I was using Fiddler to have a look at tokens being passed back and forth.

As I finished my debug session, I forgot to turn off Fiddler session and wanted to check my emails on gmail. I was getting warnings by Firefox about google SSL certificate chain not being valid. Strange. Then I moved to Facebook and there I also had all kind of problems. After adding an exception for Facebook.com to the SSL trust (!) I was able to open the site, but as text only without any additional resource (images, css): you can imagine what Facebook site looked like. I could not even browse to support.mozilla.org because Firefox did not even trust that side (ironically enough...)!

After a white it dawned on my that Fiddler might be the culprit: surely enough, after turning off Fiddler everything went back to normal.

So the moral of the story is: if you see sudden problems with Firefox and HTTPS, be sure that you don't have Fiddler running in the background causing havoc. :)

UPDATE: Eric in the comments suggests how to configure Firefox to accept Fiddler's certificate (see http://fiddler2.com/blog/blog/2013/04/01/configuring-firefox-for-fiddler)

Dependency Injection for Dummies

2011-11-08T10:10:31+00:00

Antonio Vidal has translated this post into Spanish: you can find it here.

Dependency injection is a very simple concept: if you have an object that interacts with other objects the responsibility of finding a reference to those objects at run time is moved outside of the object itself.

What does it mean for an object to "interact" with other objects? Generally it means invoking methods or reading properties from those objects. So if we have a class A that invokes method Calculate on class B, we can say that A interacts with B.

In the following example we show class A interacting with class B. We can equally say that A depends on class B to fulfill a responsibility. In this case, it not only invokes its method Calculate but it also creates a new instance of that class.

class A
{
  private B _b;

  public A
  {
    _b = new B();
  }
   
  public int SomeMethod()
  {
    return (_b.Calculate() * 2);
  }
}

In the following example, on the other side, the responsibility of getting a reference to an implementation of a class of type B is moved outside of A:

class A
{
  private B _b;
  public A(B b) 
  {
    _b = b; 
  }
  public int SomeMethod()
  {
    return (_b.Calculate * 2);
  } 
}

In this case we say that a dependency (B) has been injected into A, via the constructor. Of course, you can also inject dependencies via a property (or even a regular method), like in the following example:

class A
{
  private B _b;

  public B B 
  { 
     get { return _b; }
     set { _b = value; }
  }

  public int SomeMethod()
  {
    if (_b != null)
        return _b.RetrieveValue() * 2;}
    else 
        // HANDLE THIS ERROR CASE
        return -1;
  } 
}

So this is all there is about dependency injection. Everything else just builds on this core concept.

Like for example Inversion Of Control (IoC) tools which helps you wiring together your objects at run time, injecting all dependencies as needed. So what exactly is Inversion of Control and how does it relate to Dependency Injection (DI)?

I like to associate IoC to the Hollywood Principle: "Don't call us, we'll call you". IoC is a design principle where reusable generic code controls the execution of problem-specific code: it is a characteristic of many frameworks, where the application is built extending or customizing a common skeleton; you put your own classes at specific points and the framework will call you when needed.

You can use an IoC container as a framework to perform Dependency Injection on your behalf: you tell the container which are the concrete implementation classes for your dependencies and the container will make sure that your constructors or setters will be called with the right objects.

Therefore, IoC containers are just a convenience to simplify how dependency injection is handled. But even if you don't use one you could still manually perform dependency injection.

(If you want to have a look at how an IoC container works you can jump to my mini tutorial on Ninject).

Why is the concept of dependency injection important? Because by applying it, you simplify your design (separating the responsibility of using an object from the responsibility of retrieving that object) and your code becomes much easier to test, since you can mock out the dependencies substituting them with fake (stub) objects. But that is the subject for another post.

Why Functional Programming Matters in F#

2011-07-16T18:46:12+00:00

Building Reduce and Map from the Ground Up with F#

Today I've found myself reading again the excellent paper Why Functional Programming Matters, where the author describes the core activity of programming in a functional fashion in terms of "glueing functions together".

It's been a while since I last played around with F#. So I decided this would be a good time to refresh some of the core concepts by translating some of the examples from his paper into F#.

Reduce

The paper starts off describing how a reduce function could be devised, extrapolating a common behavior from a certain set of functions. Let's first consider a function to sum all the items in a list:

let add a b = a + b
  
let rec sum l =
    match l with
    | [] -> 0
    | h::t -> add h (sum t)

Nothing too fancy going on here. Let's now consider a similar function that instead multiplies together all the items in a list:

let mul a b = a * b 
    let rec product l =
        match l with
        | [] -> 1
        | h::t -> mul h (product t)

If you compare the structure of the two functions sum and product you can see that the two are very similar. The are only two differences between the two:

The value being returned when an empty list is matched (0 vs 1).
The function being applied between the head of the list and the application of the recursive function to the remaining of the list (add vs mul)

It's easy, then, to extrapolate a more general reduce function, as follows:

let rec reduce f a l =
        match l with 
        | [] -> a
        | h::t -> f h ((reduce f a) t)

Let's consider all the pieces step by step:

reduce is a (recursive) function accepting a function f, a value a and a list l.
f is the function that we want to apply between two elements of the list (sum or mul in the two examples above)
a is the value that we want to return when f is applied to the empty list (0 or 1 respectively), and
l is the actual list we want to operate on.

Let's try this new function in the interactive window:

> reduce;;
val it : (('a -> 'b -> 'b) -> 'b -> 'a list -> 'b)
> reduce add 0 [1;2;3];;
val it : int = 6
> reduce mul 1 [1;2;3];;
val it : int = 6

As you see, the compiler infers the types involved in reduce as follows:

('a -> 'b -> 'b) is the description of f: a function that takes two arguments of type 'a and 'b and returns one item of type 'b (note that 'a and 'b may in some cases represent the same type, as with add and mul).
'b is a parameter of the same type as the one returned by f.
'a listis a list of items the same type as the first argument of f.
'b is finally the return type of the whole reduction process

There's an interesting special case: when 'b is 'a list. That is, when f has the following form: ('a -> a' list -> a' list). A function receiving an item and a list and returning another list. Can you think of any function like that? What about concatenating an item and a list?

let cons a l = a::l

Let's see how the F# interactive interprets the new function we've just created and an example of usage:

> cons;;
val it : ('a -> 'a list -> 'a list)
> cons 1 [2; 3];;
val it : int list = [1; 2; 3]
>

And we now consider cons as our f function, first parameter of the reduce, we can write for example:

let append a b = reduce cons b a
    let copy l = reduce cons l []

where append concatenates two lists and copy simply replicates any given list:

> append;;
val it : ('a list -> 'a list -> 'a list)
> append [1;2] [3;4];;
val it : int list = [1; 2; 3; 4]
>  copy;;
val it : ('a list -> 'a list)
> copy [1;2;3];;
val it : int list = [1; 2; 3]
>

Code Snippets for the Dispose Pattern

2011-05-25T15:08:34+00:00

I thougth I'd just share a couple of Visual Studio C# code snippets to implement disposable classes, based on the well known .NET dispose pattern.

You can download it from here or simply copy and past it from the listing below. Feel free to rename the shortcut to whatever you like :)

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Base class disposable implementation.</Title>
      <Shortcut>bdisp</Shortcut>
      <Description>
        Code snippet to create a scheleton implementation
        of the IDisposable pattern for a base class.
      </Description>
      <Author>Stefano Ricciardi</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>ClassName</ID>
          <ToolTip>Name of the class.</ToolTip>
          <Default>ClassName</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[
    public class $ClassName$: IDisposable
    {
        private bool _disposed = false;
            
        //Implement IDisposable.
        public void Dispose()
        {
          Dispose(true);
          GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
          if (!_disposed)
          {
            if (disposing)
            {
              // Free other state (managed objects).
            }
            // Free your own state (unmanaged objects).
            // Set large fields to null.
            _disposed = true;
          }
        }

        // Use C# destructor syntax for finalization code.
        ~$ClassName$()
        {
          // Simply call Dispose(false).
          Dispose(false);
        }
    }            ]]>
      </Code>
    </Snippet>
  </CodeSnippet>
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Base class disposable implementation.</Title>
      <Shortcut>ddisp</Shortcut>
      <Description>
        Code snippet to create a scheleton implementation of the
        IDisposable pattern	for a derived class.
      </Description>
      <Author>Stefano Ricciardi</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>DerivedClassName</ID>
          <ToolTip>Name of the derived class.</ToolTip>
          <Default>Derived</Default>
        </Literal>
        <Literal>
          <ID>BaseClassName</ID>
          <ToolTip>Name of the base class.</ToolTip>
          <Default>Base</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[
  public class $DerivedClassName$: $BaseClassName$
  {
      private bool _disposed = false;

      protected override void Dispose(bool disposing)
      {
          if (!_disposed)
          {
              if (disposing)
              {
                  // Release managed resources.
              }
              // Release unmanaged resources.
              // Set large fields to null.
              // Call Dispose on your base class.
              
              _disposed = true;
          }
            
          base.Dispose(disposing);
      }
      // The derived class does not have a Finalize method
      // or a Dispose method without parameters because it inherits
      // them from the base class.
  }
]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Reading Technical Books with Kindle DX

2011-04-26T19:50:00+00:00

Take-Away

If you are in a hurry, here's the take-away:

Pros:

You can carry lots of technical books with you, without breaking your shoulder.
The e-ink is easy on your eyes, pretty much like real paper.
Most books in native (mobi) format show code listings nicely and are fully searchable.
Getting a new book is just one click away.

Cons:

Kindle DX does not reflow PDF content, therefore you cannot increase the font size of all those technical papers. You can only zoom in and then use navigation keys to move around.
No Wi-Fi means you need a cable to upload a book or paper you just downloaded from the net outside Amazon Store (or pay a fee to get it delivered via e-mail).
Only black and white (a few charts might benefit from being rendered in their original color).
Getting a new book is just one link away.

Overall: it's a pleasure to read from it, you can stop printing all those 4-6 pages white papers and fit them in your Kindle. PDF rendering is excellent and images are crisp. Too bad that the prices for many e-books are pretty much the same as their paper equivalent.

A Few Pictures Are Worth A Thousand Words

If you are still with me, then let’s see a few examples of how some native (mobi) and PDF books and technical papers are rendered. A word of caution: the quality of the photos themselves is barely tolerable and I apologize for it. On some photos you can see a distinct barrel distortion due to the point and shoot camera I used. You should be able to get an idea anyway.

The first book I am showing is Don’t Make Me Think!. This is a typical example of technical book with mixed graphic and text. As you can see image is pretty readable.

The second image is from a free PDF version of the famous book Syntax and Semantics of Programming Languages. This is one of the best PDF experience you can get, since the font size and margins are pretty about perfect for the dimensions of the DX.

Compare instead to the smaller font used in C# in Depth (great book by the way): this are just a bit too small for my taste, even though I managed to read almost half the book this way.

Eventually the editor finally released a mobi version, where I could set a bigger font size, as shown in the following picture. Note that I am showing exactly the same portion as above, so that you can get a feeling of the difference between PDF and mobi: PDF is usually better looking, while mobi is usually easier to read. In the mobi version you can also see that the two code snippets are rendered differently: the Listing 9.9 is “normal” text with a different font than regular text, while the Listing 9.10 is actually a picture. Probably that was the only way to insert those arrows to highlight specific code sections, but unfortunately the listing itself is much less readable (and zooming into the picture doesn’t seem to help).

Conclusions

Overall, I can say I am pretty much satisfied with the Kindle DX. I cannot say how it compares to a tablet (be it the iPad2 or any of Android tablets that are popping out recently), since I don’t have one, so this is not yet another “Kindle vs iPad” post (I am sure your favorite search engine can help you there).

I wanted a device optimized for reading (with as few distractions as possible) and Kindle DX delivered as expected. The battery lasts weeks and weeks if you turn 3G off when you don’t need it, so you can be assured that even on a long travel you don’t risk to run out of batteries. I only have a few wishes I hope Amazon will consider for next versions:

A complete tree-like folder structure. Right now you can only have one level of folders to structure all of your digital content. I am bit compulsive when it comes to organizing my files, so I would like to have the freedom to create any reasonable folder structure as I see fit.
Wi-fi (as found for example in the Kindle 3) would simplify downloading content from your PC without resorting to the micro-USB cable. This would be especially useful for items downloaded from the net (technical papers, Prag Prog magazine issues, etc.).
Touch UI. Although I don’t use the internal dictionary too often for technical documents, I surely have to when reading some fiction (Gulliver’s Travels had a lot of weird words! :)) Being able to simply touch a word instead of moving the cursor to it through the page would certainly save seconds.

A New Journey

2011-03-08T21:40:00+00:00

It was exactly 2 years ago.

I was embarking on the biggest change in my career as a software developer. Coming from about 10 years of development for Motorola, in an embedded environment, almost exclusively based on a closed proprietary OS, almost exclusively in a procedural language (C), I was moving to a modern VM-based environment (.NET), using an object oriented programming language (C#) always on the move (C# 3.0 had just been released), in a small sized company. I have learned a lot in these past two years in ORS, having the pleasure to work with a bunch of very talented developers, where I could practice being the worst on several occasions.

Now, after two years, it's time for a new journey: I have recently joined Deltatre, a fast growing company in the sport IT business that is behind many big sport web sites (think uefa.com or fifa.com). I will be part of the core infrastructure team, reporting to the chief software architect, helping shaping the engine that delivers match events to a group of diverse client applications.

Not only is this a very exciting professional opportunity, but luckily enough the office is located at a walking distance from my home (I have literally reduced my commuting time by more than one order of magnitude!). This will leave me more time for my family, and I especially look forward to spending more time with my two kids.

Photo by chiaralily.

Ninject Mini Tutorial - Part 2

2011-02-04T14:17:43+00:00

Go to Part 1

Controlling the Life Cycle of your Objects

In the previous post we did not concern ourselves with the lifecycle of the object returned from Ninject kernel. Ninject provides the following 4 built-in lifecycles (scopes):

Transient (default)
Singleton (only one instance)
Thread (one instance per thread)
Request (one instance per web request).

You can create custom scopes if needed.

Singleton:

using (IKernel kernel = new StandardKernel())
{
    kernel.Bind<ITaxCalculator>()
        .To<TaxCalculator>()
        .InSingletonScope()
        .WithConstructorArgument("rate", .2M);

    var tc1 = kernel.Get<ITaxCalculator>();
    var tc2 = kernel.Get<ITaxCalculator>();

    Assert.Same(tc1, tc2);
}

Transient:

using (IKernel kernel = new StandardKernel())
{
    kernel.Bind<ITaxCalculator>()
        .To<TaxCalculator>()
        .InTransientScope() 
        .WithConstructorArgument("rate", .2M);

        var tc1 = kernel.Get<ITaxCalculator>();
        var tc2 = kernel.Get<ITaxCalculator>();

        Assert.NotSame(tc1, tc2);
}

More Details on Injection Patterns

With Ninject you can inject:

Constructor parameters
Properties
Methods

Before considering each one in turn, we just need to introduce the [Inject] attribute which may be used to tag constructors, properties and methods requiring injection. Obviously, by tagging constructors, properties or methods, your objects cease to be POCOs.

Constructor Injection

We have already seen an example of constructor injection in Part I when the kernel auto-magically injected an implementation of ITaxCalculator to the Sale Area constructor. In that case, even if we didn't tag the constructor with the [Inject] attribute, the kernel was able to perform the required binding. How?

That was actually a special case: when there is only one constructor available, the tagging is not needed. On the other hand, if there's more than one constructor defined, then then kernel can inject a dependency to only one constructor that needs to have the [Inject] attribute:

public class Sale3
{
    private readonly ITaxCalculator taxCalculator;

    public Sale3() { }

    [Inject]
    public Sale3(ITaxCalculator taxCalculator)
    {
        this.taxCalculator = taxCalculator;
    }

    // other stuff

}

Properties Injection

Instead of passing in the dependencies through the constructor, you can also inject them as properties. Injecting properties is pretty straightforward:

public class Sale2 
{ 
    [Inject] 
    public ITaxCalculator TaxCalculator { get; set; } 
    
    // implicit default constructor and other stuff... 


    public decimal GetTotal() 
    { 
        decimal total = 0M; 
        foreach (var item in lineItems) 
        { 
            total += TaxCalculator.CalculateTax(item.TotalPrice) 
                    + item.TotalPrice; 
        } 
        
        return total; 
    } 
}

Usage (note that we never explicitely set the TaxCalculator):

using (IKernel kernel = new StandardKernel())
{
    kernel.Bind<ITaxCalculator>()
                  .To<TaxcCalculator>()
                  .WithConstructorArgument("rate", .2M);

    var lineItem1 = new SaleLineItem("Gone with the wind", 10M, 1);
    var lineItem2 = new SaleLineItem("Casablanca", 5M, 2);

    var sale = kernel.Get<Sale2>(); // property injection!

    sale.AddItem(lineItem1);
    sale.AddItem(lineItem2);

    Assert.Equal(24M, sale.GetTotal());
}

There's an important caveat: if you have 2 or more properties injected, the order in which each dependency is injected is not predictable. This might complicate your design, if those dependencies are coupled somehow (e.g. dependency A needs dependency B). For this kind of situations, constructor or method injection is usually preferred.

Methods Injection

Finally, it's also possible to tag methods for injection. As with constructor parameters, its possible to inject more than one value at once.

public class Sale4
{
    private ITaxCalculator taxCalculator;

    // other stuff


    // method injection, will be called by the kernel

    [Inject]
    public void SetTaxCalculator(ITaxCalculator taxCalculator)
    {
        this.taxCalculator = taxCalculator;
    }

    public decimal GetTotal()
    {
        decimal total = 0M;
        foreach (var item in lineItems)
        {
            total += taxCalculator.CalculateTax(item.TotalPrice) 
                  + item.TotalPrice;
        }

        return total;
    }
}

Usage (note that we never explicitely call the SetTaxCalculator):

using (IKernel kernel = new StandardKernel())
{
    kernel.Bind<ITaxCalculator>()
          .To<TaxCalculator>()
          .WithConstructorArgument("rate", .2M);

    var lineItem1 = new SaleLineItem("Gone with the wind", 10M, 1);
    var lineItem2 = new SaleLineItem("Casablanca", 5M, 2);

    var sale = kernel.Get<Sale4>(); // method injection!

    sale.AddItem(lineItem1);
    sale.AddItem(lineItem2);

    Assert.Equal(24M, sale.GetTotal());
}

Go to Part 1

Ninject Mini Tutorial - Part 1

2011-01-21T14:12:23+00:00

What Is Ninject

There are several Inversion of Control (IoC) containers for .NET to pick from (such as Castle Windsor, Structure Map and Microsoft Unity, just to name just a few). Ninject is one of the newest entries in the arena, but it’s now sufficiently stable at version 2.0.

Ninject tries to focus on “simplicity and ease of use”, removing features that are not deemed necessary (to the point that XML configuration is not offered out-of-the box).

In this and following posts we’ll explore some example of how to use Ninject. I assume that you are somehow familiar with the basic concepts of Inversion of Control and Dependency Injection; if that’s not the case, you should consider having a look at this wikipedia entry (better yet, take some time and read Martin Fowler famous post on the subject).

Setup

Installing Ninject is quite easy: you simply download the pre-built DLLs it from here. Since Ninject is open source, you can also get the sources from github and build it on your own.

On my Windows machine, I have copied the DLLs on C:\Ninject.

UPDATE: nowadays you would obviosly use NuGet.

Getting your Feet Wet With Ninject

Once you have Ninject DLLs somewhere on your hard-drive, in order to get started you only need to reference them (typically you only need to reference NInject.dll ). As we said, no XML configuration is required.

Let’s see a few basic examples (the complete source code with unit tests I present in this series are available on github).

"Hello, Ninject"

Suppose we have a fairly simple service to calculate the taxes for a given amount, defined in an ITaxCalculator interface:

decimal CalculateTax(decimal gross)

and a trivial implementation TaxCalculator as follows:

public class TaxCalculator : ITaxCalculator
{
    private readonly decimal _rate;

    public TaxCalculator(decimal rate)              
    {
        _rate = rate;
    }

    public decimal CalculateTax(decimal amount)
    {
        return Math.Round(_rate * amount, 2);
    }
}

Now, one or more classes might need to use an ITaxCalculator implementation to fulfill their responsibility (such as calculating the total price for a shopping cart). We can say that an implementation of ITaxCalculator is a dependency to them.

Like many IoC containers, Ninject uses a central object (which it calls the kernel) to provide concrete implementations of dependencies at run-time. The Standard Kernel is the default implementation of such an object. Let's see it in action:

using (IKernel kernel = new StandardKernel())
{
    kernel.Bind<ITaxCalculator>()
          .To<TaxCalculator>()
          .WithConstructorArgument("rate", .2M);

    var tc = kernel.Get<ITaxCalculator>();
    Assert.Equal(20M, tc.CalculateTax(100M));
}

As you can see, through a fluent interface we are instructing the kernel how to bind (resolve) requests for a ITaxCalculator to a TaxCalculator class (a concrete implementation), passing to its constructor a given tax rate (20% in this case).

The example continues showing how a client can retrieve an implementation of the service through the kernel (via the Get() method) and use it.

Some Magic

You might argue that the little example above is far from impressing. So let's now see Ninject performing something more clever.

Suppose we have a Sale class modeling a ongoing transaction on a ecommerce site. Such a class in our example depends on a ITaxCalculatorto compute the final price of the shopping cart.

public class Sale
{
    private readonly ITaxCalculator taxCalculator;

    public Sale(ITaxCalculator taxCalculator)
    {
        this.taxCalculator = taxCalculator;
    }

    // more stuff....

    public decimal GetTotal()
    {
	     // use the tax calculator to calculate the total
    }
}

We might create the sale in the obvious way, based on the preceding example:

kernel.Bind<ITaxCalculator>()
          .To<TaxCalculator>()
          .WithConstructorArgument("rate", .2M);
var sale = new Sale(kernel.Get<ITaxCalculator>());>

More interestingly, it's possible to let Ninject to find out how a Sale should be built based on the binding information it has received:

kernel.Bind<ITaxCalculator>()
          .To<TaxCalculator>()
          .WithConstructorArgument("rate", .2M);
var sale = kernel.Get<Sale>();

Ninject is smart enough to build a Sale class for us taking care of fulfilling the dependencies behind the scenes. This an example of autowiring, a most convenient feature of many IoC containers.

Go to Part 2

Project Euler Problem 18 in F#

2011-01-10T13:18:39+00:00

2011 brings us yet another Project Euler problem to tackle: this time is Problem 18 one of the most interesting that I have solved so far:

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.

3
7 4
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom of the triangle below:

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

NOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)

Analysis

This problem is easily solved resorting to dynamic programming, which we can loosely describe as decomposing the overall problem into easier sub-problems and combining their solutions to find the final answer.

In our case, if we consider the number associated with each node of the triangle as a cost, the overall problem can be expressed as finding the path with maximum cost from the upper vertex to the bottom row. A generic sub-problem would be the cost to reach the bottom row from a generic node at position $i,j$.

Given the cost $$c_{i,j}$$ of passing through a given node and the cost $C_{i,j}$ of reaching the bottom row from that particular node, we can define the following truth:

$$C_{i,j} = c_{i,j} + max(C_{i+1,j}, C_{i+1,j+1})$$

or, in other words, from each node $i,j$ the cost of reaching the bottom is equal to the cost of the node itself plus the maximum path between one of the two adjacent nodes from the row below.

Let's confirm why this is the case with the help of the following figure: consider for example the first node from the left in the fourteenth (last-but-one) row (having cost 63): from there you can move to the bottom either going to node 04 or node 62. Clearly, if we want to pick the highest cost, we need to pick 62 (and we mark this choice with a grey line). The overall cost to reach the bottom from that node is thus 63 + max (04, 62) = 125.

Let's consider now the second node from that row (66). From there, we have to choose between node 62 and 98: the highest cost path from there is thus 66 + max(62, 98) = 164. We can continue for all the nodes in the row to find the highest cost path from each node; the solution to such sub-problems is indicated in gray close to each node.

Having solved all sub-problems for row 14, we can now consider the row immediately above. In the following figure, I have replaced row 14 with the solutions of the sub-problems that we had just solved; the row above is row 13. Please note how we dont care about row 15 anymore: its contribution to the overall problem is already captured in each sub-problems' solution for row 14! Hence, we proceed in a similar way to solve the sub-problems for the row 13 just as we did for row 14:

We continue to follow a similar pattern moving upwards row after row, until we reach the tip of the triangle, always considering two rows at a time.

Solution

let a = Array2D.zeroCreate<int> 15 15

a.[0,0] <- 75
a.[1,0] <- 95
a.[1,1] <- 64
a.[2,0] <- 17
a.[2,1] <- 47
a.[2,2] <- 82
a.[3,0] <- 18
// other initializations omitted for clarity
// full listing available on Github
// (https://github.com/stefanoric/YAPEFSHARP)
a.[14,10] <- 38
a.[14,11] <- 53
a.[14,12] <- 60
a.[14,13] <- 04
a.[14,14] <- 23 

let costs = Array2D.zeroCreate<int> 15 15

// costs for bottom row is the same as bottom row values
Array2D.blit a 14 0 costs 14 0 1 15 |> ignore

let max a b = if a > b then a else b

for i in 13 .. -1 .. 0 do
    for j in 0 .. i do
        costs.[i,j] <- a.[i,j] + max costs.[i+1,j] costs.[i+1, j+1]
        
let result () =
    costs.[0,0]

Most of the code for this solution is needed just to initialize the two dimensional array containing the triangle. For reading convenience, I have skipped most of the uninteresting rows, but you can find the complete solution on Github.

So, we have a matrix (2D array) for the cost of each nodes and another matrix for the solutions of the sub-problems associated to each node. Trivially, the costs and the solutions coincide for the bottom row (note the handy Array2D.blit function to copy a whole row from one matrix to the other).

Then, with a loop we move backward from the last-but-one row up to the tip of the triangle calculating the sub-problems solutions as explained above.