Lambada Calculus - Erik Öjebo.se

Quick Tip: Copying Files that do not Exist in the Target Folder with XCOPY

webmaster@erikojebo.se — Wed, 25 Jan 2012 13:22:46 +0100

Here is how you can copy only the files that do not already exist in the target directory from a given source directory. It will also copy all files that are newer in the source directory than in the target directory.

C:\>xcopy c:\temp\testcopy\source c:\temp\testcopy\target /e /d

Lazy Regex in Visual Studio

webmaster@erikojebo.se — Thu, 19 Jan 2012 16:37:22 +0100

For some reason everyone who implements a regex engine feels the need to tweak the syntax so that nobody feels at home. Worst of all regex implementations is the Visual Studio one.

Here is a little reminder of the VS lazy regex syntax.

/*

| Posix | Visual studio |
|-------+---------------|
| .*?   | .@            |
| .+?   | .#            |

*/

Inheritance is not an "is a" Relationship

webmaster@erikojebo.se — Wed, 28 Dec 2011 23:43:06 +0100

One of the popular ways to explain inheritance in object oriented programming is that is represents an "is a" relationship. This can be true, but often it isn't.

An example that Robert C. Martin likes to use is that in the real world a square is a rectangle, but it makes no sense to model that relationship with inheritance in an object oriented system.

I came across another example the other day when working one of my hobby projects. The project is an ORM and I was adding basic convention support. You can specify your own conventions by implementing an IConvention interface. However, often you might not want to redefine all conventions. Instead you want to override only the ones you need to.

To enable this there is a DefaultConvention class. You can derrive from this class and override the conventions you need to modify. So, inheritance is used as a means to solve a problem, but if you think of that inheritance relationship as an "is a" then it makes no sense.

An overriding convention is NOT a default convention. It is actually the opposite of that.

So, be careful when thinking about inheritance and think of it as a programming specific mechanism for coupling classes rather than a model of an "is a" relationship from the real world.

Getting a ListBoxItem to stretch horizontally in Silverlight

webmaster@erikojebo.se — Tue, 29 Nov 2011 08:05:53 +0100

When you specify an ItemTemplate for a ListBox in silverlight, you can't get it to stretch horizontally in an easy way. Setting the HorizontalAlignment of the container in the template to stretch has no effect. What you have to do is to specify an ItemContainerStyle for the ListBox and set the HorizontalContentAlignment to Stretch:



<ListBox ItemsSource="{Binding Users}" SelectedItem="{Binding SelectedUser, Mode=TwoWay}">
   <ListBox.ItemContainerStyle>
       <Style TargetType="ListBoxItem">
           <Setter Property="HorizontalContentAlignment" Value="Stretch" />
       </Style>
   </ListBox.ItemContainerStyle>
   <ListBox.ItemTemplate>
     <DataTemplate>
       <Border BorderThickness="1" BorderBrush="#CECECE" Padding="5" CornerRadius="3" 
               Background="{Binding Background}">
             <!-- Your stuff here -->
       </Border>
     </DataTemplate>
   </ListBox.ItemTemplate>
</ListBox>

Removing the Suck from XML with Gosu.Commons: DynamicXmlParser

webmaster@erikojebo.se — Thu, 17 Nov 2011 22:56:02 +0100

Ever been bored by writing yet another XML parser? Been annoyed by all the string conversions? Let's take a look at the DynamicXmlParser in Gosu.Commons.

So, let's say we have an XML document containing a book catalog:


<?xml version='1.0'?>
    <Catalog>
        <Book Id='123'>
            <Title>XML Developer's Guide</Title>
            <Author FirstName='Matthew' LastName='Gambardella' />
            <Price>44.95</Price>
            <PublishDate>2000-10-01</PublishDate>
            <IsBetaRelease>false</IsBetaRelease>
            <BookType>Ebook</BookType>
        </Book>
        <Book Id='456'>
            <Title>Build Awesome Command-Line Applications in Ruby</Title>
            <Author FirstName='David' LastName='Copeland' />
            <Price>20.00</Price>
            <PublishDate>2012-03-01</PublishDate>
            <IsBetaRelease>true</IsBetaRelease>
            <BookType>Hardcover</BookType>
        </Book>
    </Catalog>

We want to cram that XML document into our domain objects:


public class Author
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public override string ToString()
    {
        return FirstName + " " + LastName;
    }
}

public class Book
{
    public string Id { get; set; }
    public Author Author { get; set; }
    public decimal Price { get; set; }
    public bool IsBetaRelease { get; set; }
    public BookType BookType { get; set; }
}

public enum BookType
{
    Ebook, Paperback, Hardcover
}

So, usually we start hacking away with an XmlDocument or XDocument, try to dig our way down into the document models and then convert the strings into the correct datatype to be able to store them in our objects.

That code is kind of boring. Instead, let's take advantage of the dynamic features of C# 4 to do away with that stuff. Gosu.Commons has an XML parser that does just that: DynamicXmlParser.

Here is what the code looks like when using the DynamicXmlParser:


var parser = new DynamicXmlParser();

var xmlCatalog = parser.Parse(xml);

// Access the child elements of the catalog just as an ordinary collection property
foreach (var xmlBook in xmlCatalog.Books)
{
    var book = new Book
        {
            // Read attributes or element values as properties on an element
            // Values are automatically and implicitly converted to the appropriate type
            Id = xmlBook.Id, // int
            Author = new Author
                {
                    FirstName = xmlBook.Author.FirstName, // string
                    LastName = xmlBook.Author.LastName, // string
                },
            Price = xmlBook.Price, // decimal
            IsBetaRelease = xmlBook.IsBetaRelease, // bool
            BookType = xmlBook.BookType // BookType enum
        };

    Console.WriteLine("Book id: {0}, Author: {1}, Price: ${2}, IsBetaRelease: {3}, Book type: {4}", book.Id, book.Author, book.Price, book.IsBetaRelease, book.BookType);
}

Thanks to dynamic we can use ordinary property access syntax to find child elements of our catalog. Attributes or values of an element can be accessed the same way.

Accessing child element collections

If you expect there to be multiple child elements with a given element name, those elements can be accessed as a collection property. In the example there are multiple Book elements in the catalog, so you can access them through xmlCatalog.Books.

In the example, the Book elements are accessed by adding a plural 's' to the element name, i.e. "Books". However this kind of access work with other plural forms as well:

[Test]
public void Collections_can_be_accessed_with_multiple_kinds_of_pluralization()
{
    var xml = @"
<Bag>
    <Car />
    <Glas />
    <Glas />
    <Category />
    <Category />
    <Category />
    <Octopus />
    <Octopus />
    <Octopus />
    <Octopus />
</Bag>
";
    var parser = new DynamicXmlParser();

    var bag = parser.Parse(xml);

    Assert.AreEqual(1, bag.Cars.Count); // ...s
    Assert.AreEqual(2, bag.Glasses.Count); // ...es
    Assert.AreEqual(3, bag.Categories.Count); // ...ies
    Assert.AreEqual(4, bag.OctopusElements.Count);  // worst case, just postfix the word Elements
}

As the example shows, you can use a couple of differend pluralization forms. If none of them match your specific scenario, just use the element name and postfix it with 'Elements'.

Automatic conversions

If you try to set a typed variable or property to a value read from the parsed XML document that value is automatically, implicitly converted to the type of the variable or property that you are trying to assign to. The requirement is that the type you are assigning to has a defined conversion in the parser.

Currently, default conversions exist for int, double, float, decimal, bool, TimeSpan, DateTime and enums. New conversions can easily be added and just as easily you can override the default conversions with your own.

Here is an example of how to change the default conversion for boolean values so that it accepts "0" or "1" instead of "false" and "true":

[Test]
public void Conversion_can_be_customized_for_any_type()
{
    var xml = @"<User Username='SomeName' Password='secret' IsAdmin='1' />";

    var parser = new DynamicXmlParser();

    parser.SetConverter(x =>
    {
        if (x == "1")
            return true;

        return false;
    });

    var user = parser.Parse(xml);

    Assert.IsTrue((bool)user.IsAdmin);
}

Implicit conversions can be done when using the value in a context where the expected type can be inferred, such as assigning to a variable or using the value in a method call. If you want to convert the value when the expected type cannot be inferred you can use an explicit cast.

An example of this is shown in the example above where the value is used in an assertion. If the value was not explicitly cast in the call to Assert.IsTrue, then no conversion would be triggered and the value returned would actually be an instance of the class DynamixXmlElement.

Namespaces

Every now and then you have to parse an XML document where someone has been so kind as to use the wonderful concept of XML namespaces. How do you tackle that one with this dynamic-schynamic thingie? The answer is quite simple, just add an alias for the namespace and which URI it represents. You can then access the properties and collections just as before, by prefixing the property name with the namespace alias.

[Test]
public void Elements_in_different_namespaces_can_be_accessed_by_prefixing_element_name_with_namespace()
{
    var xml =
        @"<?xml version='1.0' encoding='UTF-8' ?>
<!--  Here comes some XML -->
<Book xmlns='http://www.somesite.org/xml/DefaultNamespace' 
      xmlns:NS='http://www.somesite.org/xml'>
    <Title>The title</Title>
    <NS:Author>
        <NS:FirstName>Steve</NS:FirstName>
        <NS:LastName>Sanders</NS:LastName>
    </NS:Author>
</Book>
";p
        var _parser = new DynamicXmlParser();
        
        _parser.SetNamespaceAlias("http://www.somesite.org/xml", "NS");

        var book = _parser.Parse(xml);

    Assert.AreEqual("The title", (string)book.Title);
    Assert.AreEqual("Steve", (string)book.NSAuthor.NSFirstName);
    Assert.AreEqual("Sanders", (string)book.NSAuthor.NSLastName);
}

Conclusion / Show me teh codez!

There you have it. Thanks to Microsoft for adding some dynamic love and care to C#.

Gosu.Commons is an open source project of mine that is up at GitHub. Feel free to poke around or even contribute. If you just want to use the thing, Gosu.Commons is also available on NuGet. To add a reference, just open the package manager console and type:

PM> Install-Package Gosu.Commons

Changing Character Encoding for File in Emacs

webmaster@erikojebo.se — Tue, 15 Nov 2011 15:42:22 +0100

Character encoding is a pain... If you find yourself wanting to change the encoding of a file, here is how to do it in emacs:

C-x RET f utf-8 RET

When you then save the file, it is written with the specified encoding. If you can't remember the exact name of the encoding type:

C-x RET f TAB

This will give you a list of all available encodings in the help buffer.

Emacs replace-regexp-fu

webmaster@erikojebo.se — Mon, 14 Nov 2011 16:48:59 +0100

The time has come to take a deeper look at the super useful emacs function replace-regexp.

The scenario:

Let's say you have an XML document that looks something like this:

<Person FirstName='Steve' LastName='Smith' Phone='555-12345' Title='Mr.' BirthDate='1950-01-01' />

and you want to turn it into C# code, like this:


var p = new Person
{
   FirstName = "Steve",
   LastName = "Smith",
   Phone = "555-12345",
   Title = "Mr.",
   BirthDate = DateTime.Parse("1950-01-01"),
}

So, perfect time to put our regex skills to the test. Since emacs is my editor of choice, replace-regexp is what I'll use to get the job done. The regex for extracting the values we are interested in will look something like this:

<Person FirstName='\(.*?\)' LastName='\(.*?\)' Phone='\(.*?\)' Title='\(.*?\)' BirthDate='\(.*?\)' />

Note that you have to escape the parens to create a capture group and not be literal. This is kind of backwards compared to most other regex implementations, but comes in handy when performing search & replace on Lisp code :)

The replace string will look like this:

var p = new Person
{
   FirstName = "\1",
   LastName = "\2",
   Phone = "\3",
   Title = "\4",
   BirthDate = DateTime.Parse("\5")
}

Ok, so mission accomplished. However, a week later the format is extended to include the address of the person as well:


<Person FirstName='Steve' LastName='Smith' Phone='555-12345' Title='Mr.' BirthDate='1950-01-01'>
  <Address PostalCode='12345' State='Florida' City='Jacksonville' Street='Some street' />
</Person>

and the desired C# code:

var p = new Person
{
   FirstName = "Steve",
   LastName = "Smith",
   Phone = "555-12345",
   Title = "Mr.",
   BirthDate = DateTime.Parse("1950-01-01"),

   Address = new Address
   {
     PostalCode = "12345",
     State = "Florida",
     City = "Jacksonville",
     Street = "Some street"
   }
}

Multi-line time! The new regex now includes line breaks. To enter these, you can either write the expression outside of the mini-buffer and yank it in when executing the replace-regex command, or you can enter a newline in the minibuffer by typing C-q C-j. Here is the regex:

<Person FirstName='\(.*?\)' LastName='\(.*?\)' Phone='\(.*?\)' Title='\(.*?\)' BirthDate='\(.*?\)'>
  <Address PostalCode='\(.*?\)' State='\(.*?\)' City='\(.*?\)' Street='\(.*?\)' />
</Person>

and the replace expression:

var p = new Person
{
   FirstName = "\1",
   LastName = "\2",
   Phone = "\3",
   Title = "\4",
   BirthDate = DateTime.Parse("\5"),

   Address = new Address
   {
     PostalCode = "\6",
     State = "\7",
     City = "\8",
     Street = "\9"
   }
}

Still quite straight forward, as long as you get the newlines right in the search expression.

Ok, so yet another week goes by, and now there is one small addition to the format: there should be a "MiddleName" attriute added to the person element:


<Person FirstName='Steve' MiddleName='F.' LastName='Smith' Phone='555-12345' Title='Mr.' BirthDate='1950-01-01'>
  <Address PostalCode='12345' State='Florida' City='Jacksonville' Street='Some street' />
</Person>

Here is the matching C# code:

var p = new Person
{
   FirstName = "Steve",
   MiddleName = "F."
   LastName = "Smith",
   Phone = "555-12345",
   Title = "Mr.",
   BirthDate = DateTime.Parse("1950-01-01"),

   Address = new Address
   {
     PostalCode = "12345",
     State = "Florida",
     City = "Jacksonville",
     Street = "Some street"
   }
}

Only a minor change, so the regex should only need a small tweak. However, adding this field brings us up to 10 match groups. If we continue with the same pattern and just add the tenth group and reference, like this:


var p = new Person
{
   FirstName = "\1",
   MiddleName = "\2",
   LastName = "\3",
   Phone = "\4",
   Title = "\5",
   BirthDate = DateTime.Parse("\6"),

   Address = new Address
   {
     PostalCode = "\7",
     State = "\8",
     City = "\9",
     Street = "\10"
   }
}

The output from the replace will then be:


var p = new Person
{
   FirstName = "Steve",
   MiddleName = "F.",
   LastName = "Smith",
   Phone = "555-12345",
   Title = "Mr.",
   BirthDate = DateTime.Parse("1950-01-01"),

   Address = new Address
   {
     PostalCode = "12345",
     State = "Florida",
     City = "Jacksonville",
     Street = "Steve0"
   }
}

If you take a closer look at the Street value, you see that it is actually "Steve0" which is not remotely what you would have wanted it to be. Instead of referencing the 10:th capture group it is actually a reference to the 1:st capture group immediately followed by a zero. The reason for this is that emacs only allows a single digit following the backslash.

What to do now? We'll have to bring out the big guns. It's Lisp time!

Emacs lets you embed lisp code within your replace expression, by escaping it with "\,". A useful function for this case is match-string which takes an integer specifying the capture group number to reference. The new expression will then be:

var p = new Person
{
   FirstName = "\,(match-string 1)",
   MiddleName = "\,(match-string 2)",
   LastName = "\,(match-string 3)",
   Phone = "\,(match-string 4)",
   Title = "\,(match-string 5)",
   BirthDate = DateTime.Parse("\,(match-string 6)"),

   Address = new Address
   {
     PostalCode = "\,(match-string 7)",
     State = "\,(match-string 8)",
     City = "\,(match-string 9)",
     Street = "\,(match-string 10)"
   }
}

Tada! Now we're up and rolling again.

For the fun of it, let's say that another week goes by and yet another attribute is added, this time it is NickName:

<Person FirstName='Steve' MiddleName='F.' LastName='Smith' NickName='Stevenizzle' Phone='555-12345' Title='Mr.' BirthDate='1950-01-01'>
  <Address PostalCode='12345' State='Florida' City='Jacksonville' Street='Some street' />
</Person>

Since we've removed the limitation of 9 capture groups we can just modify the regex to add the new capture group and reference.

<Person FirstName='\(.*?\)' MiddleName='\(.*?\)' LastName='\(.*?\)' NickName='\(.*?\)' Phone='\(.*?\)' Title='\(.*?\)' BirthDate='\(.*?\)'>
  <Address PostalCode='\(.*?\)' State='\(.*?\)' City='\(.*?\)' Street='\(.*?\)' />
</Person>

var p = new Person
{
   FirstName = "\,(match-string 1)",
   MiddleName = "\,(match-string 2)",
   LastName = "\,(match-string 3)",
   NickName = "\,(match-string 4)",
   Phone = "\,(match-string 4)",
   Title = "\,(match-string 5)",
   BirthDate = DateTime.Parse("\,(match-string 6)"),

   Address = new Address
   {
     PostalCode = "\,(match-string 7)",
     State = "\,(match-string 8)",
     City = "\,(match-string 9)",
     Street = "\,(match-string 10)"
   }
}

As you can see, since we reference the groups by reference this means that we need to increment a bunch of numbers. This is a typically boring thing to do. Since we're already in the regex mindset, let's go regex on our regex and add 1 to all the numbers that need incrementing. Fortunately we already know how to embed lisp in our replace expression, so all we need to do is to hack away at some lovely lisp code.

The search expression:

\([0-9]+\)

and the replace expression:

\,(+ 1 (string-to-number (match-string 1)))

By applying this regex and the replace expression above, from the second row referencing match group 4 and downwards, we get this beauty:

var p = new Person
{
   FirstName = "\,(match-string 1)",
   MiddleName = "\,(match-string 2)",
   LastName = "\,(match-string 3)",
   NickName = "\,(match-string 4)",
   Phone = "\,(match-string 5)",
   Title = "\,(match-string 6)",
   BirthDate = DateTime.Parse("\,(match-string 7)"),

   Address = new Address
   {
     PostalCode = "\,(match-string 8)",
     State = "\,(match-string 9)",
     City = "\,(match-string 10)",
     Street = "\,(match-string 11)"
   }
}

which in turn gives us the final result:


var p = new Person
{
   FirstName = "Steve",
   MiddleName = "F.",
   LastName = "Smith",
   NickName = "Stevenizzle",
   Phone = "555-12345",
   Title = "Mr.",
   BirthDate = DateTime.Parse("1950-01-01"),

   Address = new Address
   {
     PostalCode = "12345",
     State = "Florida",
     City = "Jacksonville",
     Street = "Some street"
   }
}

So with the ability to embed Lisp code into your regexes, you are only limited by your imagination and possibly your Lisp skills :)

Search and Replace with Unprintable Characters in Emacs

webmaster@erikojebo.se — Fri, 10 Jun 2011 22:34:13 +0200

Lately I've found myself doing a lot of search & replace to restructure text. Quite often this involves changing whitespace in some way.

For example, to include a newline character in the text to find, or in the replacement string, you simply enter a newline by using the chord C-q C-j.

Here are a few useful whitespace chords:
Tab: C-q C-i
Linefeed: C-q C-j
Carriage return: C-q C-m

Keyboard Rectangle Selection in Visual Studio

webmaster@erikojebo.se — Thu, 19 May 2011 08:35:28 +0200

Rectangle selection is one of the most time-saving tricks when editing large chunks of code, but the benefit is more or less lost if you have to reach for the mouse to do it.

In Visual Studio you can hold down the alt button and use your mouse to select a rectangle of text. You can also use Control + Shift + arrow key to do this with the keyboard. If those shortcuts do not work on your machine, go to Tools->Options->Environment->Keyboard and add shortcuts for the following commands:

Edit.LineDownExtendColumn
Edit.LineUpExtendColumn
Edit.CharLeftExtendColumn
Edit.CharRightExtendColumn

Cleaner Test Setup using Builders

webmaster@erikojebo.se — Thu, 03 Feb 2011 20:35:05 +0100

One of the most common causes for messy test code is setup code that reduces
the signal to noise ratio and makes you lose focus on the parts of the test
code that actually are important. I've recently taken a liking to the builder
pattern as a way to reduce this problem.

In this post I'm going to compare a few different ways to write your setup
code, to illustrate the pros and cons of the different styles.

To start off, let's look at some classic object construction code:

var comment1 = new Comment();
comment1.Body = "Comment 1 body";
comment1.Date = new DateTime(2011, 1, 2, 3, 4, 5);

var comment2 = new Comment();
comment2.Body = "Comment 2 body";
comment2.Date = new DateTime(2011, 1, 2, 3, 4, 5);

var post = new Post();
post.Title = "Title";
post.Body = "Body";
post.Date = new DateTime(2011, 1, 2, 3, 4, 5);
post.AddComment(comment1);
post.AddComment(comment2);

It doesn't get more basic than that, but there is a quite a lot of noise. The
first step toward reducing that noise is to use the object initializer
syntax:

var comment1 = new Comment
    {
        Body = "Comment 1 body",
        Date = new DateTime(2011, 1, 2, 3, 4, 5)
    };

var comment2 = new Comment
    {
        Body = "Comment 2 body",
        Date = new DateTime(2011, 1, 2, 3, 4, 5)
    };

var post = new Post
    {
        Title = "Title",
        Body = "Body",
        Date = new DateTime(2011, 1, 2, 3, 4, 5)
    };

post.AddComment(comment1);
post.AddComment(comment2);

I'd say that the this syntax makes the important information stand out a bit
more. Another way is to use a constructor with named parameters and default
values:

var comment1 = new Comment(
    body: "comment 1 body",
    date: new DateTime(2011, 1, 2, 3, 4, 5));

var comment2 = new Comment(
    body: "comment 2 body",
    date: new DateTime(2011, 1, 2, 3, 4, 5));

var post = new Post(
    title: "Title",
    body: "Body",
    date: new DateTime(2011, 1, 2, 3, 4, 5));

post.AddComment(comment1)
post.AddComment(comment2);

This approach is a bit more compact than the object initializer way. Apart
from the syntax, a major problem with both object initializers and
constructors with named arguments is that they force you to modify the
entities you want to create so that they work well with the test setup
code. In the case above that is not a real problem, but it becomes a problem
if you, for example, want to use certain default values when creating
instances for your tests that you do not want to use in the production
code. This is where the builder pattern comes in to the picture.

A builder is a class whose sole purpose is to facilitate creation of instances
of a specific class. In this case we would probably use a PostBuilder and a
CommentBuilder. These classes can have all the helper methods you need so that
you can easily get instances for your test cases.

Here is an example:

var post = new PostBuilder()
    .WithTitle("Title")
    .WithBody("Body")
    .WithDate(new DateTime(2011, 1, 2, 3, 4, 5))
    .WithComment(new CommentBuilder()
        .WithBody("comment 1 body")
        .WithDate(new DateTime(2011, 1, 2, 3, 4, 5))
        .Build())
    .WithComment(new CommentBuilder()
        .WithBody("comment 2 body")
        .WithDate(new DateTime(2011, 1, 2, 3, 4, 5))
        .Build())
    .Build();

This style of programming has been quite popular in the .NET space for the
last two years or so. A fluent interface using daisy chaining of method calls
and method names chosen to give a prose like reading experience. However, this
style easily gets quite verbose and has fallen out of favor. The reason is
simple, all those "With":s in the example above clutter up the code rather
than makeing it easier to read. A slightly more compact version could look
something like this:

var post = new PostBuilder()
    .Title("Title")
    .Body("Body")
    .Date(new DateTime(2011, 1, 2, 3, 4, 5))
    .Comment(new CommentBuilder()
        .Body("comment 1 body")
        .Date(new DateTime(2011, 1, 2, 3, 4, 5))
        .Build())
    .Comment(new CommentBuilder()
        .Body("comment 2 body")
        .Date(new DateTime(2011, 1, 2, 3, 4, 5))
        .Build())
    .Build();

Now we're getting somewhere. There is less noise, but there are still a couple
of builder instantiations scattered around the code. The syntax could be
cleaned up a bit by introducing a nicer way to create the builders. Below is
an example with a static class which has properties for the different kinds of
builders. The factory class is called Build to make the code read a little
nicer.

var post = Build.Post
    .Title("Title")
    .Body("Body")
    .Date(new DateTime(2011, 1, 2, 3, 4, 5))
    .Comment(Build.Comment
        .Body("comment 1 body")
        .Date(new DateTime(2011, 1, 2, 3, 4, 5))
        .Build())
    .Comment(Build.Comment
        .Body("comment 2 body")
        .Date(new DateTime(2011, 1, 2, 3, 4, 5))
        .Build())
    .Build();

Better. Two problems remaining are the duplication of the word Comment in
the call to the Comment method, and that annoying call to Build for the
comments. These problems could be addressed by creating a version of the
Comment method that takes a lambda operating on a builder as an argument:

var post = Build.Post
    .Title("Title")
    .Body("Body")
    .Date(new DateTime(2011, 1, 2, 3, 4, 5))
    .Comment(c => c
        .Body("comment 1 body")
        .Date(new DateTime(2011, 1, 2, 3, 4, 5)))
    .Comment(c => c
        .Body("comment 2 body")
        .Date(new DateTime(2011, 1, 2, 3, 4, 5)))
    .Build();

I'd say this is even better. The only noise remaining is the duplication of
Date/DateTime when setting the date for a comment or a post and the "c => c" part
of the lambda. The implementation of the PostBuilder class now looks like
this:

public class PostBuilder
{
    private readonly Post _post = new Post();
    
    public PostBuilder Title(string title)
    {
        _post.Title = title;
        return this;
    }

    public PostBuilder Body(string body)
    {
        _post.Body = body;
        return this;
    }

    public PostBuilder Date(DateTime date)
    {
        _post.Date = date;
        return this;
    }

    public Post Build()
    {
        return _post;
    }
    
    public PostBuilder Comment(Action initializer)
    {
        var builder = new CommentBuilder();
        initializer(builder);
        
        var comment = builder.Build();
        _post.AddComment(comment);

        return this;
    }
}

I usually find myself using the same DateTime constructor, over and over
again. This cries out for refactoring. Now we can reap the benefits of using a
builder class, since we easily can add any helpers we need. In this case by
allowing the date to be set using the standard six double values for year,
month, day, hour, minute and second:

var post = Build.Post
    .Title("Title")
    .Body("Body")
    .Date(2011, 1, 2, 3, 4, 5)
    .Comment(c => c
        .Body("comment 1 body")
        .Date(2011, 1, 2, 3, 4, 5))
    .Comment(c => c
        .Body("comment 2 body")
        .Date(2011, 1, 2, 3, 4, 5))
    .Build();

Much better! The builder now contains the following method:

public PostBuilder Date(
    int year, int month, int day, 
    int hour, int minute, int second)
{
    _post.Date = new DateTime(year, month, day, hour, minute, second);
    return this;
}

Ok, so now the setup code looks nice and tight, but the builder class contains
a nasty form of duplication. For each property that is to be exposed through
the builder there is a matching method:

public PostBuilder Title(string title)
{
    _post.Title = title;
    return this;
}

public PostBuilder Body(string body)
{
    _post.Body = body;
    return this;
}

This code is extremely tedious to write, especially if you have a large
application with a lot of entities. LISP eats this kind of duplication for
breakfast, as do Ruby, but it is often quite hard to remove in statically
typed languages which have no pre-processor or macro facilities.

Fortunately, C# 4 includes the dynamic keyword which opens up new
possibilities for the static folks. All the dumb builder methods which set the
property with the same name as the method on the entity could easily be
replaced with a method missing hook:

public class DynamicBuilder : DynamicObject 
    where T : class, new()
{
    protected readonly T Entity = new T();

    // This method is called when you invoke a method that does not exist
    public override bool TryInvokeMember(
        InvokeMemberBinder binder, object[] args, out object result)
    {
        // Remember to return self to enable daisy chaining
        result = this;

        // Get the property on the entity that has the same name
        // as the method that was invoked
        var property = typeof(T).GetProperty(binder.Name);

        var propertyExists = property != null;

        if (propertyExists)
        {
            property.SetValue(Entity, args[0], null);
        }

        return propertyExists;
    }

    public T Build()
    {
        return Entity;
    }
}

Sweet! Now you can throw away most of your boring builder code, except for the
helpers that are tailor made for the specific entity type that your are building.

The post builder now looks like this:

public class DynamicPostBuilder : DynamicBuilder
{
    public DynamicPostBuilder Date(
        int year, int month, int day,
        int hour, int minute, int second)
    {
        Entity.Date = new DateTime(year, month, day, hour, minute, second);
        return this;
    }

    public DynamicPostBuilder Comment(Action initializer)
    {
        var builder = new DynamicCommentBuilder();
            
        initializer(builder);
            
        var comment = builder.Build();
        Entity.AddComment(comment);

        return this;
    }
}

The only downside to this is that you lose refactoring support and
intellisense, which can be a big deal for many .NET developers. However, if
you use TDD, the refactoring support should not be an issue, since you will
instantly know what was broken when something is renamed.

The code for adding a comment looks suspiciously like a bit of code that might
get repeated in other builders. So there is another chance to, for example,
introduce a convention that would allow that code to be pushed down and
handled in the method missing hook of the base class. Only inconsistency and
lack of imagination set the limits in this case.

To use the builder you have to make sure that the builder instance is typed as
dynamic, so that the compiler will get out of your way and allow you to call
the methods you want to call, even though they are not actually declared in
the builder class.

In this case, that can be accomplished by modifying the builder factory class:

public class DynamicBuild
{
    public static dynamic Post
    {
        get { return new DynamicPostBuilder(); }
    }
        
    public static dynamic Comment
    {
        get { return new DynamicCommentBuilder(); }
    }
}

So, to sum up. Using the builder pattern allows you to clean up your test code
significantly and makes it trivial to add helpers when needed.

Original setup code:

var comment1 = new Comment();
comment1.Body = "Comment 1 body";
comment1.Date = new DateTime(2011, 1, 2, 3, 4, 5);

var comment2 = new Comment();
comment2.Body = "Comment 2 body";
comment2.Date = new DateTime(2011, 1, 2, 3, 4, 5);

var post = new Post();
post.Title = "Title";
post.Body = "Body";
post.Date = new DateTime(2011, 1, 2, 3, 4, 5);
post.AddComment(comment1);
post.AddComment(comment2);

Builder based setup code:

var post = Build.Post
    .Title("Title")
    .Body("Body")
    .Date(2011, 1, 2, 3, 4, 5)
    .Comment(c => c
        .Body("comment 1 body")
        .Date(2011, 1, 2, 3, 4, 5))
    .Comment(c => c
        .Body("comment 2 body")
        .Date(2011, 1, 2, 3, 4, 5))
    .Build();

Happy building!

Quick Tip: Finding apt-get Install Location

webmaster@erikojebo.se — Mon, 24 Jan 2011 21:00:49 +0100

To find where apt-get installed a given package just run the following command:

sudo dpkg -L packagename

Git Commit Script for the Lazy Typist

webmaster@erikojebo.se — Sat, 04 Dec 2010 16:59:42 +0100

If you are a git user, you are probably a fan of the command line, and you probably use aliases to make your daily work more efficient. One of my most frequently used aliases is gc, which is an alias for git commit -m.

alias gc='git commit -m'

However, one shortcoming of this alias is that you still have to add the double quotes, which is tedious.

gc "this is a commit message"

There are several ways of solving that problem, and I chose to do it by writing a small ruby script:

#!/usr/bin/ruby

# Performs a git commit with all the command line arguments as a message, 
# for example:
# gcm this is a commit message => git commit -m "this is a commit message"

message = ARGV.join(" ")
%x[git commit -m '#{message}']

By saving this script with a suitable name in some directory that is part of your path you can now commit with messages without quotes.

The commit shown above now becomes:

gc this is a commit message

You can find this script and more up at github where I keep my configuration, such as bash scripts and dot files.

Git-removing Files Marked as Deleted

webmaster@erikojebo.se — Tue, 23 Nov 2010 08:46:01 +0100

If you work in an environment where not all file operations are made through git you probably have been in the situation that files have been deleted by using just plain rm rather than git rm, so you have to manually do a git rm for each deleted file and then commit the deletion.

To make this step a little bit easier you can use the following command:

git rm $(git ls-files -d)

It might be a good idea to either alias this command or put it in a shell script somewhere in your path, to make it easier to use.

Edit:
There is actually a much better way to solve the problem where the deletions are not added, which is to add the --all flag to the git add:

git add . --all

Make Alt-Tab Useful by Disabling Aero Peek in Windows 7

webmaster@erikojebo.se — Mon, 22 Nov 2010 10:17:53 +0100

The default behaviour of Alt-tab in Windows 7 is simply horrible to use. Fortunately you can easily disable Aero Peek, as it is called, to go back to a more traditional style of alt-tabbing.

Go to "Adjust the appearance and performance of windows", by typing it in in the start menu search, and then simply uncheck "Aero peek".

Quick Tip: Useful Shortcuts for your Everyday Windows Usage

webmaster@erikojebo.se — Thu, 04 Nov 2010 09:33:03 +0100

Windows in general:
Windows + E: Open Windows explorer
Windows + R: Open Run dialog
Windows + D: Minimize/restore all (show desktop)
Ctrl + Shift + Esc: Open process explorer

Explorer:
F10 or Alt: Show menu bar
F4: Move focus to adress bar
F6: Move focus to next pane
Alt + Space: Open the system menu for the windod (minimize, maximize, etc)
Ctrl + e or F3: Move focus to search bar
Shift + F10: Open right click menu for current item
Ctrl + w: Close the current window
F11: Full screen mode
Shift + F11: Exit full screen mode

Windows 7:
Windows + 1 to 9: Pinned applications
Windows + Left: Dock current window left
Windows + Right: Dock current window right
Windows + Up: Maximize current window
Windows + Down: Restore current window
Windows + Shift + Left: Move to screen to the left
Windows + Shift + Right: Move to screen to the right

Assertion Classes: Reuse and Expressiveness instead of Test Class Inheritance Hierarchies

webmaster@erikojebo.se — Thu, 28 Oct 2010 22:38:32 +0200

If you have several classes which have some aspect in common, you probably have test classes that have similar tests as well. These similarities often lead to duplication that needs to be removed. One way to remove this duplication is to extract a common super class for the test classes, but inheritance can be a quite inflexible way of sharing behaviour between classes. For example, what happens when you have a test class that share behaviour with not only one other class, but two?

Due to the limitations of inheritance, composition is often a better choice. So, how can you use composition to share functionality between test classes? Let's look at an example from the world of Windows Presentation Foundation and MVVM.

Here is a typical view model class, which implements the interface INotifyPropertyChanged. If you are using MVVM you probably have quite a lot of classes implementing this interface.

public class ViewModel : INotifyPropertyChanged
{
    private string _someProperty;

    public string SomeProperty
    {
        get { return _someProperty; }
        set
        {
            _someProperty = value;
            RaisePropertyChanged("SomeProperty");
        }
    }

    public void RaisePropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

Here is a simple test class, with a single test case that verifies that the property in the view model actually raises the PropertyChanged event when changed.

[TestFixture]
public class ViewModelTests
{
    private ViewModel _viewModel;
    private string _actualPropertyName;
    private int _eventsRaised;

    [SetUp]
    public void SetUp()
    {
        _viewModel = new ViewModel();
        _eventsRaised = 0;
        _actualPropertyname = "";
    }

    [Test]
    public void Setting_SomeProperty_raises_property_changed_event()
    {
        StartListeningForPropertyChangedEvent();

        _viewModel.SomeProperty = "new value";

        AssertSinglePropertyChangedEventWasFiredFor("SomeProperty");
    }

    private void StartListeningForPropertyChangedEvent()
    {
        _viewModel.PropertyChanged += (s, e) =>
            {
                _eventsRaised++;
                _actualPropertyName = e.PropertyName;
            };
    }

    private void AssertSinglePropertyChangedEventWasFiredFor(string expectedPropertyName)
    {
        Assert.AreEqual(1, _eventsRaised, "number of property changed events raised");
        Assert.AreEqual(expectedPropertyName, _actualPropertyName);
    }
}

Now imagine that you write another view model class. You will probably need to write test cases for that class that are almost identical to the test case above. You could extract the helper methods to a super class, but as mentioned above, that is not an ideal solution.

So, now to the good stuff. A simple way of cleaning up the test class above is to extract another class which handles everything that has to do with asserting that a property raises the property changed event.

public class ExpectPropertyChanged
{
    private string _actualPropertyName;
    private int _eventsRaised;
    private string _expectedPropertyName;

    private ExpectPropertyChanged(INotifyPropertyChanged sender)
    {
        sender.PropertyChanged += (s, e) =>
            {
                _eventsRaised++;
                _actualPropertyName = e.PropertyName;
            };
    }

    public static ExpectPropertyChanged On(INotifyPropertyChanged sender)
    {
        return new ExpectPropertyChanged(sender);
    }

    public ExpectPropertyChanged ForProperty(string expectedPropertyName)
    {
        _expectedPropertyName = expectedPropertyName;
        return this;
    }

    public void During(Action action)
    {
        action.Invoke();

        Assert.AreEqual(1, _eventsRaised, "number of property changed events raised");
        Assert.AreEqual(_expectedPropertyName, _actualPropertyName);
    }
}

This removes the need for the helper methods in the test class and enables you to use the same assertion code in any other test class without having to tie the classes together via a static type relationship. Here is the test class after the refactoring:

[TestFixture]
public class ViewModelTests
{
    private ViewModel _viewModel;

    [SetUp]
    public void SetUp()
    {
        _viewModel = new ViewModel();
    }

    [Test]
    public void Setting_SomeProperty_raises_property_changed_event()
    {
        ExpectPropertyChanged
            .On(_viewModel)
            .ForProperty("SomeProperty")
            .During(() => _viewModel.SomeProperty = "new value");
    }
}

So, why would you bother with this stuff? First of all, it let's you reuse code much easier than through inheritance. Apart from that it also simplifies your actual test classes since you can extract lots of boring helper methods into their own classes, which improves the signal to noise ratio significantly. Finally it also gives you a new level of expressiveness by naming the assertion class and introducing methods on the assertions which explain the meaning of each value used. This last point also solves the problem with composite assertions that take several parameters. By introducing an assertion class you can set each value using a method with a self documenting name, which makes it obvious what the value means, instead of having to try your best to guess what the third integer parameter does.

Colorizing Your Git Output

webmaster@erikojebo.se — Thu, 28 Oct 2010 20:46:45 +0200

If the output from your git commands is not colorized, it is time to bring out the old git config.

Either you configure git with the git config commands from a shell:

git config --global color.branch auto
git config --global color.diff auto
git config --global color.interactive auto
git config --global color.status auto

or you open up ~/.gitconfig in your favourite text editor and add the following section:

[color]
    branch = auto
    diff = auto
    interactive = auto
    status = auto

Given that you have a decent shell you can now enjoy the full glory of your git output.

Setting the Default Startup Directory for your Cygwin Bash

webmaster@erikojebo.se — Fri, 15 Oct 2010 08:13:20 +0200

To change the path in which your bash shell is started you can edit your .bashrc file.
To do this, open cygwin and simply open the file ~/.bashrc in your favourite text editor and add a cd command at the bottom.

Getting Emacs to Behave under Cygwin

webmaster@erikojebo.se — Sat, 02 Oct 2010 17:53:48 +0200

If you install emacs under cygwin, there is a risk that you won't be able to close emacs with the usual C-x C-c, since it is mapped to C-x C-g for some reason. To fix this, add an environment variable called CYGWIN with the value binmode ntsec tty .

Set Up Shared and Local Git Repository

webmaster@erikojebo.se — Thu, 09 Sep 2010 20:15:55 +0200

In my current hobby project I'm using git with a shared repository on an external hard drive, and a local repository on my primary disk.

To set up an empty shared repository, use the following command:

git init --bare --shared

This tells git to create a shared repository that is not supposed to have a working copy of the code, just to be pushed to and pulled from.

You then clone the shared repository on your primary disk by executing the git clone command:

git clone /path/to/shared/repository

You will get a warning about that you have cloned an empty repository, but that isn't a problem.

Now you are all set to add your first file and do your first commit in the new repostiory. For example:

touch todo.txt
git add .
git commit -m 'Added todo list'

You now have something that you can push to the shared repository. If you try to push your commits to the shared repository using

git push origin

you will get an error message saying No refs in common and none specified; doing nothing; Perhaps you should specify a branch such as 'master'. This is because of that the remote repository is completely empty, and has no branches. To push your commits you have to explicitly specify the name of the branch, i.e. master.

git push origin master

Now you have pushed your first commits to the remote repository and you can now push and pull like nobody's business.

Use ReSharper to Quickly Generate GUIDs

webmaster@erikojebo.se — Wed, 08 Sep 2010 21:31:49 +0200

Everyone who has used the GUID generation tool in Visual Studio knows that it is quite limited in the GUID formats it can generate. If you are a ReSharper user there is a much more enjoyable way to generate GUIDs. Anywhere in your code or in an XML file, type nguid and press tab to expand the snippet. That will generate a new GUID and let you choose between a number of formats.

Getting Current System Uptime under Windows

webmaster@erikojebo.se — Mon, 06 Sep 2010 09:29:04 +0200

If you are trying to remember when you came to work, one trick is to check your system uptime:

In a command prompt:
- Run the command "net statistics server" or "net stats srv"
- Check the first line of the output, which says "Statistics since …" which shows when you booted

Removing Regions in Visual Studio

webmaster@erikojebo.se — Fri, 27 Aug 2010 15:09:41 +0200

Some people are truly in love with the whole #region thing in Visual Studio. Personally I can't say I share that sentiment. Because of this I found myself wanting to quickly remove all regions in a solution. The first solution that came to mind was our old friend the regular expression.

To remove all regions, open the Find & replace dialog (Ctrl-H), choose the appropriate scope (current document, entire solution etc) and click the "Use regular expressions" checkbox. Enter the following regular expression in the Find field:

\#(end)*region.*$

Make sure the Replace field is empty, and hit the Replace All button. Tada!

Search & Replace with Visual Studio Regular Expressions

webmaster@erikojebo.se — Thu, 24 Jun 2010 10:27:46 +0200

Regular expressions are an awesome tool, but unfortunately every language/environment has its own dialect, including Visual Studio.

Visual Studio uses {} to indicate a group to capture. A captured group can later be referenced by using backslash and the match number (one based).

As an example, let's say you want to do the following replacement:

// Original
var person = new Person("Frank");

// Expected result
var person = new Person { Name = "Frank" };

To achieve this you can use the following search and replace patterns in Visual Studio:

Search pattern: var person = new Person\({:q}\);
Replace pattern: var person = new Person { Name = \1 };

:q is a special Visual Studio regex symbol for matching a quoted string. Another custom VS symbol is :z which matches an integer.

Getting Started with FitNesse

webmaster@erikojebo.se — Fri, 16 Apr 2010 22:05:54 +0200

If you haven't heard of FitNesse, it is Unclebob's acceptance testing framework which let's you specify test cases as wiki pages. These test cases then interact with fixture classes that call the system under test.

The first step in getting started with FitNesse is to download it. You only need one file, FitNesse.jar, which can be found at the FitNesse wiki.

Download fitnesse.jar and put it in your project's lib directory. For the purpose of this blog post we will assume a directory structure that looks like this:

c:- code
  - hellofitnesse
    - bin
    - fitnesse
    - lib
    - src

So, now the lib folder contains fitnesse.jar.

Since FitNesse is based on a wiki, it runs on its own web server. To start fitnesse go to the hellofitnesse directory and execute the following command:

java -jar lib/fitnesse.jar -p 8080 -r fitnesse

This command starts fitnesse and tells it to listen to the port 8080. It also tells it to unpack all the files that it needs in the folder fitnesse.

You can now open up a browser and go to localhost:8080. You should then see the default FitNesse wiki.

Edit the front page by clicking the edit link in the menu to the left and add the following line:

!define TEST_SYSTEM {slim}

!path lib/fitnesse.jar
!path bin

>HelloFitnesse

The first line tells FitNesse to use slim to run the tests. The path statements tell FitNesse where to find fitnesse.jar and the .class files for your fixtures (change this path if your .class files will be generated into some other directory).

This last line creates a link to a child page called HelloFitnesse. When you save the page, a little question mark will appear after HelloFittnesse. Click the question mark to create the page.

This page is now just an ordinary wiki page. To make the page into a test suite page click the properties link in the menu, and select Suite.

Edit the HelloFitnesse page and add the following row:

>MyFirstTest

Create the page and change its properties to make it into a test page.

Edit the MyFirstTest page and add the following code to create a simple test:

|import  |
|fixtures|
 
!|AddFixture           |
|a     |b     |sum?    |
|1     |2     |3       |
|2     |2     |3       |

The first two lines defines a table with all the packages to import. The second table defines the actual test. The first row specifies the name of the fixture class to run. The columns a and b represent state that should be set in the fixture, and the column sum? represents a method call which returns the result that should be verified.

The values a and b are set by calling the methods setA and setB with the corresponding values. When both a and b are set the method sum() will be called and the return value will be compared to the expected value.

You can now run the test by clicking the Test link in the menu. However, since the actual test fixture has not been written yet you will get an exception that looks something like this:

Could not invoke constructor for AddFixture[0]

So, the next step is to write the fixture class.

package fixtures;

public class AddFixture {
    private int _a;
    private int _b;

    public void setA(int a) {
        _a = a;
    }

    public void setB(int b) {
        _b = b;
    }

    public int sum() {
        return _a + _b;
    }
}

Compile the fixture class and make sure the AddFixture.class file is actually located in bin/fixtures/ folder (if bin is your output folder, specified in the !path directive earlier). You should now be able to run the test and get the proper response, one row should succeed and one should fail.

Fixing Default Indentation in Resharper

webmaster@erikojebo.se — Wed, 31 Mar 2010 09:49:21 +0200

The default indentation rules for Resharper are quite ugly. Both object/collection initializers and anonymous methods are indented way to much. Fortunately this can be fixed.

To fix the indentation of anonymous methods, go to Resharper->Options->Braces Layout and choose "BSD style" for "Anonymous method declaration". Then go to Other and deselect the option "Indent anonymous method body".

Fixing the object/collection initializer indentation is quite similar. Go to Resharper->Options->Braces Layout and choose "BSD style" for "Array oand object initializer". Then go to Other and set "Continous line indent multiplier" to 1.

The Importance of Nomenclature

webmaster@erikojebo.se — Mon, 29 Mar 2010 20:33:18 +0200

Naming is a crucial part of programming, and is probably one of the most challenging parts of the craft. The Behaviour Driven Development movement currently does its best to bring attention to the fact that terminology and naming not only effects the way we read and understand code, it also effects the way approach problems and thereby also the solutions that we come up with.

An example of how terminology influences the code you write is the naming of the attribute which specifies that a method is a test method. NUnit uses the traditional jUnit style by using the [Test] attribute. However, xUnit.NET has chosen to call their attribute [Fact]. This simple change is quite effective in pointing you in the right direction when you sit down to write your unit test.

The [Test] attribute is quite weak since it does not say much, except that the method is to be executed by the test runner. For example, a common style of writing unit test is to do something like this:

[Test]
public void TestPush()
{
   // Create a stack instance
   // Do some stuff with it  
   // Write a bunch of asserts
}

The [Fact] attribute on the other hand sets quite a firm expectation on the test method. If you change the [Test] attribute above to a [Fact] attribute it makes no sense. TestPop is certainly not a fact. You are pushed to write tests with names that actually state some fact about the code under test. To be able to write a fact about the code you are testing you also have to chose a more narrow scope, probably with a single logical assert.

[Fact]
public void GivenEmptyStack_WhenPushing_ThenSizeIsOne()
{
   Stack stack = new Stack();
   stack.Push(0);
   Assert.Equal(1, stack.Size);
}

Implementation of a Micro DSL

webmaster@erikojebo.se — Mon, 29 Mar 2010 19:56:21 +0200

I've previously touch on the topic of using extension methods to clean up the syntax of your unit tests. That approach can give you very expressive and readable tests, for example:

[Test]
public void Validate_RequestWithValidPath_Ok()
{
    "GET /valid/path.html HTTP/1.1"
        .ShouldValidateTo(RequestValidationStatus.Ok);
}

The drawback of using extension methods is when you want to have optional state setup methods that you can chain together to form an expression.

[Test]
public void Validate_RequestWithValidPath_Ok()
{
    "GET /valid/path.html HTTP/1.1"
        .UsingPathChecker(new AlwaysValidPathChecker())
        .ShouldValidateTo(RequestValidationStatus.Ok);
}

If the UsingPathChecker method in the example above needs to be optional you have to supply two extension methods to the string class, UsingPathChecker and ShouldValidateTo. You also need a class that is used as a return value of the UsingPathChecker method call, which holds the state and also contains a ShouldValidateTo method.

As you can see, it can quickly get a bit messy. To get rid of some of the mess, you can use a simple factory method with a well chosen name.

[Test]
public void Validate_RequestWithValidPath_Ok()
{
    TheRequest("GET /valid/path.html HTTP/1.1")
        .UsingPathChecker(new AlwaysValidPathChecker())
        .ShouldValidateTo(RequestValidationStatus.Ok);
}

The method TheRequest in this example simply returns a new instance of the helper class which holds the state, and thereby eliminates the need for the extension methods. You now only have one place where you can put all the stuff you need to create your little DSL.

Here is an example of what the helper class could look like:

class HttpRequestValidatorSpecsIntermediary
{
    string _input;
    private HttpRequestValidator _validator;

    internal HttpRequestValidatorSpecsIntermediary(string input)
    {
        _input = input;
        _validator = new HttpRequestValidator();
    }

    internal HttpRequestValidatorSpecsIntermediary UsingPathChecker(IPathChecker pathChecker)
    {
        _validator = new HttpRequestValidator(pathChecker);

        return this;
    }

    internal void ShouldValidateTo(RequestValidationStatus expectedStatus)
    {
        var actualValidationStatus = _validator.Validate(new HttpRequest(_input));

        Assert.AreEqual(expectedStatus, actualValidationStatus);
    }
}

Lessons Learned from Uncle Bob

webmaster@erikojebo.se — Fri, 19 Mar 2010 21:05:53 +0100

Earlier this week I spent three days with Robert C. Martin, also known as Uncle Bob. He was in Stockholm giving a course on Advanced TDD, which I had the privilege to attend to. Hearing Uncle Bob talk about TDD for three whole days lead to quite a few thoughts and insights. This post is an attempt to summarize the main points I took away from his course.

Don't try to convince others, convince yourself

As a test driven developer on a team with non-test driven colleagues you have probably asked yourself the question "how do I convince the others to take up TDD?". The answer to this question is that you probably can't convince anyone to start doing TDD. That decision has to come from each and everyone themselves. What you can do is to make sure that you are really convinced of the benefits of TDD, yourself. If you are, it will shine through. As time passes the quality and effectiveness of your work will hopefully speak for itself, and help inspire the other developers.

By focusing on following test driven practices yourself and being open for sharing your point of view when anyone shows interest you can slowly but surely spread the knowledge.

Tests are truly first class citizens

Tests are important. Very important. The test code deserves the same tender love and care as your production code. Fore some reason test code is generally not held to the same standards as the production code. You should strive to keep your test code just as DRY and expressive as all other code. Make sure not to repeat tedious setup code or hard-to-read asserts. Use extract method if you can, and split the tests to make sure they are only testing one thing.

The test is more important than the prettiness of your public interfaces. The consequence of this is that it is better to add test specific methods/properties to your objects and to
increase the visibility of private/protected methods than to let your tests suffer. However, every time you are tempted to promote a private method to public for testability you should stop and think if it is not really an inner class that is trying to escape.

For some reason, test code is generally not shipped with the production code. Why not use the fact that you have an extremely powerful diagnostic tool available and ship the tests when you release, together with some light weight test runner software. By doing that you can drastically improve your ability to diagnose problems that occur on the systems on which your software is being deployed.

Make sure you can trust your test suite

Once you have worked on a code base that is covered by a test suite you trust, no matter the size, you tend to get hooked on the feeling of freedom to refactor and change the code. When you reach this point of trust you can start reaping some of the most powerful benefits of a test driven code base. The flexibility of the code allows you to do whatever you please and get immediate feedback. Your QA process is drastically shortened which makes frequent releases and deployment a breeze.

Achieving this kind of trust for your test suite is not something you do easily. It takes hard work and discipline. A good way to do keep the trust level high is to follow the three laws of TDD (see "TDD is hard, get used to it" below).

Don't ask for permission, just do it

A colleague of mine has the philosophy that it is easier to ask for forgiveness than for permission. This is especially true when it comes to TDD. If you start asking management and colleagues if you should do TDD or not, in an organization that is not that progressive, you will probably hear the usual anti-TDD arguments. If you don't want to take the fight, the easies way to resolve this issue is to not ask in the first place.

Most likely, neither colleagues nor management will explicitly tell you NOT to do TDD if you just do it as a natural part of your development process. If your team/management is extreme enough to not want test code in the code base, or something crazy like that, just keep the test code locally on your machine instead of checking it in, or simply throw it away after letting it drive your production code.

Tests are both documentation and functional spec

By letting acceptance tests and unit tests drive the implementation of requirements, as well as the modifications made due to changed requirements, your tests always reflect the current functional spec. Your acceptance test provide an executable functional specification. If you are using a tool such as FitNesse that specification will be easily understood by the customer. In the best of worlds, this specification is not only easily understood by the customer, the customer is also able to create and update specs. Even if that is not the case, the acceptance tests provide a powerful basis from which customer and developer can cooperate to evolve the spec.

The unit tests provide an extensive documentation of the actual implementation of the requirements. This documentation will always be up to date, which is not usually the case with traditional documentation. Code examples very efficiently describe the usage and behaviour of classes/methods etc, much more efficiently than written text. Unit tests are a very useful mixture of executable specification and usage examples.

True TDD is hard, get used to it

To get all the benefits of TDD, you always have to push yourself to follow the three rules of TDD:

1. You are not allowed to write any production code unless it is to make a failing unit test pass.
2. You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures.
3. You are not allowed to write any more production code than is sufficient to pass the one failing unit test.

This is hard. Really hard. Testing legacy code is hard. Testing the GUI is hard. Convincing colleagues is hard. Keeping your tests fast is hard.

There are no simple solutions which magically solve these hard issues. They are hard because they are hard. The only thing you can do is to do the best that you can, and do it over and over again.

Emacsify Your Windows Keyboard Navigation

webmaster@erikojebo.se — Sun, 07 Mar 2010 22:17:12 +0100

If you are an Emacs user you might miss the Emacs navigation keybindings while working in Windows. The Emacs navigation keybindings let you navigate through text without moving your hands from the touch typing position. This can be quite nice, especially when working on a laptop which has home/end and the arrows in funky locations on the keyboard.

Since Emacs shortcuts are extremely ctrl heavy, many Emacs users rebind their caps lock key to be another ctrl key. To emulate the Emacs bindings, while at the same time keeping all the default Windows keybindings, I created a little AutoHotKey script that maps CapsLock+n/p etc to up arrow/down arrow etc.

AutoHotKey is a small but extremely powerful application for doing stuff with keybindings in Windows. If you have not checked it out, I strongly suggest that you do. It can do some really usefull things.

The tiny AutoHotKey script I wrote goes as follows:

CapsLock & n::Send {Down}
CapsLock & p::Send {Up}
CapsLock & e::Send {End}
CapsLock & a::Send {Home}
CapsLock & f::Send {Right}
CapsLock & b::Send {Left}

Now you can navigate easily in any Windows application, even explorer, while still keeping your system pair programming friendly by keeping all standard keybindings unchanged.

Quick Tip: Kill Multiple Processes in Windows

webmaster@erikojebo.se — Fri, 29 Jan 2010 12:55:05 +0100

Linux folks have probably used the kill command from time to time. The Windows equivalent is taskkill.

To kill all instances of the WINWORD process, use the following command.

taskkill /im WINWORD* /f

The im switch specifies the image name, and the f switch tells taskkill to forcefully terminate the processes.

Can Your Site be Used by a Visually Impaired User?

webmaster@erikojebo.se — Mon, 21 Dec 2009 15:58:19 +0100

One of the benefits of using semantic HTML is that your site becomes more accessible to users with visual disabilities. This is because of the fact that screen reader applications make some assumptions about the content of your site depending on what tags you use in your markup. These assumptions are based on the semantic meaning of the HTML tags, which is why semantic markup fits screen readers like a glove.

Writing semantic markup is not always that easy, though. The choice of how to mark up the content of your site can be difficult. To check the accessibility of your site and make these choices easier you can run your site through a screen reader and see which markup makes the most sense.

An excellent way to see how a screen reader would present the contents of your site is to use the Firefox extension Fangs. This extension can generate the text that would be read by the screen reader Jaws.

When you have installed Fangs, all you have to do is right click and choose "View Fangs", and tada, there is the screen reader output in plain text.

Using Extension Methods to Refactor Your Tests

webmaster@erikojebo.se — Fri, 11 Dec 2009 11:01:50 +0100

In a recent Katacast, Bobby Johnsson gave an excellent example of how C# extension methods can be used to create simplistic and readable test cases. He was performing the StringCalculator kata which is a kata where you write a calculator class that can calculate the sum of the integers in a given input string, for example "1,3,5".

Without extension methods an ordinary test case for this kata might look something like this:

[Test]
public void Add_GivenTwoSingleDigitNumbers_ShouldReturnTheSum()
{
    var calculator = new StringCalculator();
    int sum = calculator.Add("1,2");

    Assert.AreEqual(3, sum);
}

This is a quite ordinary test, and there is no problem with the test itself. However if you have 15 other tests with the same structure there is room for some refactoring. One approach to refactor the test could be to simply create a helper method, like so:

private void VerifySum(string input, int expectedSum)
{
    var calculator = new StringCalculator();
    int actualSum = calculator.Add(input);

    Assert.AreEqual(expectedSum, actualSum);
}

This would give a test case that look like this:

[Test]
public void Add_GivenTwoSingleDigitNumbers_ShouldReturnTheSum()
{
    VerifySum("1,2", 3);
}

If you instead use the extension method refactoring you could create an extension method that looked something like this:

public static class StringExtensions
{
    public static void ShouldAddUpTo(this string input, int expectedSum)
    {
        var calculator = new StringCalculator();

        int actualSum = calculator.Add(input);

        Assert.AreEqual(expectedSum, actualSum);
    }
}

This approach gives a test that looks like this:

[Test]
public void Add_GivenTwoSingleDigitNumbers_ShouldReturnTheSum()
{
    "1,2".ShouldAddUpTo(3);
}

I must say that the extension method approach gives a much more fluent and readable syntax, with a very Ruby-esque feeling to it. The back side of using extension methods is that it can be confusing for the reader, since you must have included the namespace of the extensions for them to show up, and you cannot resolve those namespaces as easily as you could with standard method calls. In my opinion, the example above is an excellent use of extension methods when the extension method is located in the same place as the tests, since that makes it obvious what is going on.

Extension methods is truly an awesome feature of C#, when used correctly.

Verifying IEnumerable HasMany Mapping with Fluent NHibernate

webmaster@erikojebo.se — Mon, 07 Dec 2009 21:15:59 +0100

Fluent NHibernate has built in functionality to make it very simple to verify that your entities are mapped correctly. To test the mappings of an entity you can use the PersistenceSpecification class:

[Test]
public void CanMapPost()
{
    using (ISession session = SessionFactorySingleton.OpenSession())
    {
        new PersistenceSpecification(session)
            .CheckProperty(p => p.Name, "Post Name")
            .CheckProperty(p => p.DateTime, new DateTime(2009, 12, 6))
            .CheckProperty(p => p.Comment, "Comment goes here")
            .CheckProperty(p => p.Amount, 250.90)
            .VerifyTheMappings();
    }
}

This creates an instance of the Post class, saves it to the database, retrieves it again and verifies that its properties have the correct values.

The PersistenceSpecification class also includes functionality to verify HasMany and References mappings. For example, you could verify a HasMany mapping like this:

new PersistenceSpecification(session)
    .CheckList(p => p.Tags, tags)

This works well if you have a setter for your collection. However, if you expose the collection as an IEnumerable and use a private backing field, for example by mapping it as Access.CamelCaseField, it will not work. This is because of the fact that Fluent NHibernate does not know how to add the items to the collection.

This issue has been fixed in later releases of Fluent NHibernate. Now you can verify your IEnumerable property mapping using the CheckEnumerable method of the PersistenceSpecification class. A complete verification of the post class above could look like this:

public void CanMapPost()
{
    using (ISession session = SessionFactorySingleton.OpenSession())
    {
        var tags = new List()
        {
            new Tag("tag 1"),
            new Tag("tag 2")
        };

        new PersistenceSpecification(session)
            .CheckProperty(p => p.Name, "Post Name")
            .CheckProperty(p => p.DateTime, new DateTime(2009, 12, 6))
            .CheckProperty(p => p.Comment, "Comment goes here")
            .CheckProperty(p => p.Amount, 250.90)
            .CheckEnumerable(p => p.Tags, (p, t) => p.AddTag(t), tags)
            .VerifyTheMappings();
    }
}

Free .NET Profiler

webmaster@erikojebo.se — Fri, 06 Nov 2009 20:04:47 +0100

If you don't have access to a commercial profiler, such as JetBrains' dotTrace or ANTS Profiler, take a look at IJW Profiler for .NET & Java. It is a basic, but quite nice profiler which is free and the source code is available from the link above.

Starting WPF Application with Window from another Assembly

webmaster@erikojebo.se — Sun, 18 Oct 2009 19:26:05 +0200

When you create a WPF application you get the standard App.xaml and Window.xaml files. The App.xaml file has the StartupUri attribute set to Window.xaml. This is all well and fine, and if you rename Window.xaml or create another window that you want to use as the startup window you can simply modify the value of the StartupUri attribute.

If you are want to use a window defined in another assembly as the startup window it becomes a little trickier. The simplest way to accomplish this is to override the Application.OnStarupt method. In you override you can instantiate the window you want to show and then simply call Show() on it. For example:


public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        // Create an instance of the window that is located in another assembly
        var customWindow = new CustomWindow();

        customWindow.Show();
    }
}

You could also create your own main method, and manually create and run your application.

The first step is to create your own main method is to change the Build Action property of your App.xaml file from ApplicationDefinition to Page, which stops Visual Studio from creating a main method for you. The second step is to add a main method to your App class:


public partial class App : Application
{
    [STAThread]
    public static void Main()
    {
        Application app = new Application();

        // Create an instance of the window that is located in another assembly
        var customWindow = new CustomWindow();

        app.Run(customWindow);
    }
}

Now you are all set. Compile, run and enjoy!

Avoiding Flicker at Page Load when Using the Ajax Control Toolkit ModalPopup Extender Control

webmaster@erikojebo.se — Thu, 15 Oct 2009 20:35:28 +0200

If you are using the ModalPopup extender control from the Ajax Control Toolkit you might have noticed that the popup flickers when the page is loaded. This is because of that there is a slight delay from when the page is rendered to when the javascript of the extender control hides the popup.

To get around this you need to set the display style of the popup element. It seems like you have to set the style directly at the control, and not from an external style sheet.

To set the display style to none for your popup element, add the following attribute:

style="display: none"

Displaying Modal Dialogs with WPF

webmaster@erikojebo.se — Thu, 13 Aug 2009 12:54:41 +0200

In WPF you can show a modal dialog with the ShowDialog method, just as in WinForms. However, it does not behave quite right. For example, if you display a modal dialog, then swich to another application, and switch back to you application the main form will be shown and not the modal dialog.

To get the expected behaviour you have to set the Owner property of the dialog before calling ShowDialog():


var dialog = new FooDialog();
dialog.Owner = this;
dialog.ShowDialog();

This makes the modal dialog the topmost window of the application.

NHibernate: Using Paging with Join Queries

webmaster@erikojebo.se — Sun, 26 Jul 2009 17:45:34 +0200

When you write queries that use joins in NHibernate, most of the time the result you get back is not unique at the root entity level. This is usually not a problem since you can stick a DistinctRootEntityResultTransformer on the query and get a nice unique result set.

However, if you want to page the result based on the root entities there is a problem. Since the DistinctRootEntityResultTransformer operates on the result set that comes back from the database and the paging modifies the database query the paging is made before the data is filtered to be unique. This leads to a result that you probably don\'t want.

To combine paging with joined queries you can split the query into two separate queries. The first query fetches the root entities based on some criteria and pages the result. The second query performs the join for the entities returned from the previous query, without caring about paging or uniqueness. Since NHibernate makes sure an entity is mapped to exactly one instance in a session the result from the second query loads data into the instances returned from the first query.

Here is an example:

// Assuming two classes: Post and Comment. A post has many comments.

public IEnumerable GetPostsByPageWithCommentsLoaded(int pageIndex, int pageSize)
{
    using (ISession session = SessionFactory.OpenSession())
   {
      // Load the posts using paging
      var posts = session.CreateCriteria(typeof(Post))
         .AddOrder(Order.Desc("DateTime"))
         .SetFirstResult(pageIndex * pageSize)
         .SetMaxResult(pageSize)
         .List();

     // Eager load the comments for all the posts returned in the previous query
     // Restrictions.In() is used to avoid fetching unnecessary data
    // temporaryPosts is never used. The point of the query is to load data into
    // the instances returned from the previous query
     var temporaryPosts = session.CreateCriteria(typeof(Post))
         .SetFetchMode("Comments", FetchMode.Eager)
         .Add(Restrictions.In("Id", posts.Select(p => p.Id).ToArray()))
         .List();

     return posts;
   }
}

The First Lesson of Scrum

webmaster@erikojebo.se — Wed, 17 Jun 2009 22:12:30 +0200

The other day I learned one of the most important Scrum techniques: Always take a new sticky by gently pulling it of the pad from left to right, not by yanking it upwards as you would normally do. This ensures maximum stickiness, so that the notes last the whole sprint.

C#: Creating a Cursor from a Resource

webmaster@erikojebo.se — Tue, 02 Jun 2009 12:28:16 +0200

A simple way to use custom cursor icons in .NET applications is to include the .cur file in the project resources (project properties -> resources -> add resource from file).

A cursor can then be created like so:


Cursor cursor = new Cursor(new System.IO.MemoryStream(
    Properties.Resources.MyCursorName));

Tests as Documentation

webmaster@erikojebo.se — Sun, 17 May 2009 21:22:27 +0200

A couple of weeks ago there was an internal seminar at work about Test-Driven Development. The seminar was held by one of the senior devs who has been doing TDD for a few years. As a part of the seminar he presented a few levels of TDD practice, corresponding to different "aha" moments.

One of the "aha" moments was the realization that tests are documentation. When I heard this I thought for a while if I had had this "aha" moment yet or not. I could see how tests could be considered documentation, but that was not how I primarily saw it.

However, about a week ago I actually had that "aha" moment, and then once again today. Last week I had to go through some complex import/export code that I had worked with maybe a month earlier. Since I had worked on the code not that long ago I thought that I would remember how the code was supposed to work. That was not the case. I found myself wondering if a specific behaviour was by design or if it was a bug. After a few seconds of thinking I realized that the tests could tell me ("aha!"). A quick look in the test fixture and I knew that the code worked according to spec.

Today I was setting up a new hobby project, and I was rewriting some old configuration code for Fluent-NHibernate, since that project is changing quite rapidly. I was writing the database configuration and tried to find the correct way to specify "integrated security" as login for a MS SQL Server connection. Intellisense showed that there was a "TrustedConnection()" method of the configuration object, but it had no XML comments.

A quick google search turned up the Fluent NHibernate SVN repository, so I though to myself that I might as well take a quick look in the source. The search function at google code found the unit test for TrustedConnection().

The test look as follows:


[Test]
public void ConnectionString_for_trustedConnection_is_added_to_the_configuration()
{
    MsSqlConfiguration.MsSql2005
        .ConnectionString(c => c
            .Server("db-srv")
            .Database("tables")
            .TrustedConnection())
        .ToProperties().ShouldContain("connection.connection_string" ,
               "Data Source=db-srv;Initial Catalog=tables;Integrated Security=True");
}

Integrated security it is then. Unit tests to the rescue! ("aha!")

However, when it comes to public libraries and API:s like Fluent NHibernate I really think that there is no excuse for not writing XML comments. Documentation in Intellisense is such a productivity boost that it is a must have for all API:s.

From now on, I can say without a doubt that I believe that unit tests are documentation.

Programmatically Add Conditional Formatting Formula to a Cell in Excel

webmaster@erikojebo.se — Wed, 15 Apr 2009 14:30:36 +0200

The following snippet demonstrates how to add a conditional formatting rule to a cell. The rule specifies that the cell color is set to red if the contents of the cell has a length in characters longer than 3.

The snippet assumes an existing worksheet instance.

var range = (Excel.Range)worksheet.Cells[rowNo + 2, colNo + 1];

Excel.FormatCondition condition = (Excel.FormatCondition)range.FormatConditions.Add(
    Microsoft.Office.Interop.Excel.XlFormatConditionType.xlExpression, 
    Type.Missing, "=LEN(R[0]C[0])>3", Type.Missing, Type.Missing, 
    Type.Missing, Type.Missing, Type.Missing);

condition.Interior.ColorIndex = 3; // Red

"Could not find installable ISAM" when Reading Excel Document Programatically with Microsoft Jet

webmaster@erikojebo.se — Tue, 07 Apr 2009 15:32:17 +0200

This generic error message is often an indication of a syntax error in the connection string. In my case the error occurred when I tried to add a second Extended Property, like so:

var connection = new System.Data.OleDb.OleDbConnection(
    "Provider=Microsoft.Jet.OLEDB.4.0;" +
    "Data Source=" + path + ";" +
    "Extended Properties=Excel 8.0;HDR=No;");

The problem turned out to be that the multiple extended properties were not quoted. A single extended property does not need quoting, but multiple do.

The fix was then simply to add escaped quotes:

var connection = new System.Data.OleDb.OleDbConnection(
    "Provider=Microsoft.Jet.OLEDB.4.0;" +
    "Data Source=" + path + ";" +
    "Extended Properties=\\"Excel 8.0;HDR=No;\\"");

SQL Server Express Profiler

webmaster@erikojebo.se — Fri, 20 Feb 2009 15:17:10 +0100

At the moment I am comparing a few different object/relational mapping tools (ORM:s), namely Linq to SQL, Entity Framework, NHibernate and MyGeneration Doodads. Both Linq to SQL and NHibernate have excellent features for writing all generated SQL statements to the console. Unfortunately it is not quite as easy in the other three.

Today I needed to debug a Subsonic query but could not find any information about how to output the generated SQL to the console. Finally I gave up and thought to myself that I would have been really great if Microsoft had included a SQL profiler in the SQL Server Express Editions. It then occurred to me that I had never really tried to find another SQL profiler, so a quick google search found SQL Server 2005/2008 Express Profiler which is an open source profiler for MS SQL Server Express, as you probably guessed.

The project home page is quite spartan and the GUI isn't the best ever, but it works. First of all you have to select which events you want to see in the trace. When that is set up you just press play, do you SQL-magic and watch the queries appear in the trace.

So, if you are using SQL Server Express it is absolutely worth a try.

Compiling Fluent-NHibernate for NHibernate 2.1 without Using Rake

webmaster@erikojebo.se — Fri, 23 Jan 2009 14:31:36 +0100

Currently Fluent-NHibernate references NHibernate version 2.0.0.4 per default. At the Fluent-NHibernate page the suggested way of compiling Fluent-NHibernate for NHibernate 2.1 is to do as follows:

To enable NH 2.1 support, run the rake task (rake use_nhib_21) and then build FluentNHibernate.Versioning.NH21. To go back to NH 2.0.1, run the rake task (rake use_nhib_201) and build FluentNHibernate.Versioning.NH20

To do this you obviously need to have rake installed. As a Windows user you can get rake by using the Ruby installer for Windows.

However, if you do not want to install rake, you can still change the references by hand and compile new Fluent-NHibernate binaries.

First of all, get the latest source code by doing a check out of the latest code from the Fluent-NHibernate repository.

For each project in the solution, remove the references to NHibernate and NHibernate.Linq, then add references to the latest dlls. These dlls are located in the sub-folder Tools/NHibernate/nhib2.1/ in your check out folder.

Now you can find a shining, new FluentNHibernate.dll, that uses NHibernate 2.1, in one of the bin folders.

SCTP Socket Programming

webmaster@erikojebo.se — Sat, 17 Jan 2009 16:44:03 +0100

If you are interested in socket programming you really should take a look at the Stream Control Transmission Protocol (SCTP). It is a new transport protocol that can be used in about the same way as both UDP and TCP, depending on which kind of SCTP socket that is used.

SCTP has two kinds of sockets, one-to-one sockets and one-to-many sockets. One-to-one sockets are very similar to classic TCP sockets, and are also known as TCP style sockets. One-to-many sockets are similar to UDP sockets, and as you probably can guess, are also known as UDP style sockets.

SCTP one-to-one sockets are actually so similar to TCP sockets that you can convert a TCP application to SCTP just by changing the socket call:

// TCP socket
int tcp_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 

// SCTP one-to-one socket
int sctp_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);

If you want to dig deeper into SCTP I can recommend Unix Network Programming, 3rd ed. by Stevens, R. The book covers both basic and more advanced parts of SCTP, with useful examples. If you do some kind of socket programming, you should own a copy of this book, no matter what protocol you currently use. The only problem with the SCTP part of the book is that the specification has changed slightly since the book was printed, so I would recommend updated man pages as API reference. Personally I prefer the Sun Solaris man pages, which are available both as web pages and PDF.

For RFC:s, drafts and documents SCTP.org is the place to go.

Recompiling VirtualBox

webmaster@erikojebo.se — Tue, 09 Dec 2008 10:21:15 +0100

If you run VirtualBox with Ubuntu as your host OS, you will probably run in to some problems when there is a kernel upgrade. To fix this you just have to do a recompile of VirtualBox, like this:

killall VirtualBox
sudo /etc/init.d/vboxdrv setup

Batch Image Resize/Rotate in Ubuntu

webmaster@erikojebo.se — Fri, 05 Dec 2008 09:35:57 +0100

Resizing and rotating images can be a really time consuming and boring task that just begs to be automated. If you are running Ubuntu, this is easily achieved by using Imagemagick.

To install imagemagick, just do an ordinary apt-get, like this:

sudo apt-get install imagemagick

Now you are ready to start batch processing your images. Here are some examples of useful commands:

To resize an image to a specific size:

convert foo.jpg -resize 640x480 foo2.jpg

To resize using a percentage:

convert foo.jpg -resize 50% foo2.jpg

To resize an image to a specific width, keeping aspect ratio:

convert foo.jpg -resize 640 foo2.jpg

To resize an image to a specific height, keeping aspect ratio:

convert foo.jpg -resize x480 foo2.jpg

To rotate an image:

convert foo.jpg -rotate 90 foo2.jpg

These commands can be chained together like so:

convert foo.jpg -rotate 90 -resize 640 foo2.jpg

To operate on multiple files, file globbing can be used, like this

convert *.jpg -rotate 90 -resize 500 rotated_%03d.jpg

The %03d means three incrementing digits. So in this example, the new file names will be rotated_000.jpg, rotated_001.jpg etc.

Unit Testing Selection on a Windows Forms ListView Control

webmaster@erikojebo.se — Thu, 20 Nov 2008 10:55:38 +0100

This is kind of an edge case, but it just stole about two hours of my day, so I thought it might be of interest for someone else who stumbles upon this problem.

In the application I am currently working on I am subclassing a ListView to make it handle strongly typed tags, and for example directly get a strongly typed instance of the tag of the currently selected item. To test my implementation I programmatically created an instance of my ListView subclass, added items and added an item to the selection using both:

Item.Selected = true

and

listView.SelectedIndices.Add(...)

The problem was that this had no effect at all on the ListView\'s SelectedIndices and SelectedItems collections.

I tried doing the same thing on a ListView in one of the forms of my appliation and that worked, but it did not work if I instantiated the ListView directly in the code. After some googeling I finally found a comment to the MSDN documentation on the ListViewItem.Selected Property, saying that the Selected property could not be trusted if the ListView had not been drawn. I did some quick testing myself and confirmed that the problem indeed disappeared if the ListView was drawn.

So, the solution to the problem was to do something like this:


        [Test]
        public void CanGetSelectedItems()
        {
            // Sadly, this is needed to make the ListView handle selection properly.
            // If the ListView is instantiated directly SelectedIndices, SelectedItems etc
            // do not update when modified.
            var f = new DummyForm(listView);
            f.Show();

            listView.SelectedIndices.Add(0);

            Assert.AreEqual(1, listView.SelectedIndices.Count);

            ICollection<string> items = listView.SelectedItems;

            Assert.AreEqual(1, items.Count);
            Assert.IsTrue(items.Contains(strings[0]));
        }

        private class DummyForm : Form
        {
            public DummyForm(ListView listView)
            {
                this.WindowState = FormWindowState.Minimized;
                this.ShowInTaskbar = false;
                this.Controls.Add(listView);
            }
        }

RhinoMocks - Expect that Method is Never Called At All

webmaster@erikojebo.se — Wed, 19 Nov 2008 13:35:23 +0100

If you want to set up an expectation that a method is never called at all, and not just that it is never called with a specific parameter, you can do like this:

MockRepository mocks = new MockRepository();
Foo mockFoo = mocks.StrictMock();

// For void methods:
mockFoo.Bar();
LastCall.IgnoreArguments().Repeat.Never();

// For non-void methods:
Expect.Call(mockFoo.Baz(1)).Return(null).Repeat.Never();
LastCall.IgnoreArguments().Repeat.Never();

mockFoo.Replay();

// Do stuff

mockFoo.VerifyAllExpectations();

Fluent-NHibernate - Unknown Entity Class Exception

webmaster@erikojebo.se — Tue, 18 Nov 2008 11:19:22 +0100

If you are using Fluent NHibernate and you get the exception:

NHibernate.MappingException: Unknown entity class: Foo.Bar.Baz

Make sure your mapping file (BazMap in this example) is public.

If you still get the exception, make sure you are loading you class maps correctly. It should look something like this:

Configuration configuration = new Configuration().Configure();

var persistenceModel = new PersistenceModel();
persistenceModel.addMappingsFromAssembly(typeof(Baz).Assembly);
persistenceModel.Configure(configuration);
            
var sessionFactory = configuration.BuildSessionFactory();

PersistenceModel is located in the FluentNHibernate namespace.

Windows PowerShell

webmaster@erikojebo.se — Fri, 14 Nov 2008 08:34:33 +0100

This weekend I installed SQL Server 2008 Express and one of the requirements for the install was to have Windows PowerShell. I had heard Scott Hanselman talk about it previously, but never tried it myself.

Today I tried it out for the first time, and after about 5 seconds I decided that it was a great product. The simple reason was that I typed ls and hit return, and it listed the folder contents for me. That is so sweet.

Previously I have had a small batch file named ls that did a dir, just to be able to list without having to think about it, but this is quite a bit nicer.

Debugging NUnit Unit Tests in Visual C# Express 2008

webmaster@erikojebo.se — Thu, 13 Nov 2008 15:42:23 +0100

Since Visual C# Express does not allow add-in:s, and attach to process is not available, you have to roll your own simple test runner if you want to be able to debug your unit test.

Fortunately this is quite simple. The easiest way, in my opinion, is to add a new Console Application project to your solution. Add a reference to nunit-console-runner.dll, and then add the following code to the main of the new console app:

Set the console app as start up project by right clicking the project in the solution explorer and choosing "Set as start up project".

You can now set break points in your test code and simply hit F5 to debug the tests.

Cleaning Up Your Grub Boot Menu (Ubuntu)

webmaster@erikojebo.se — Wed, 12 Nov 2008 13:04:16 +0100

As more and more kernel updates get installed on your system the grub menu tends to grow longer. This is easy to fix:

Back up your grub menu file:

sudo cp /boot/grub/menu.lst /boot/grub/menu.lst.bak

Edit your menu file:

sudo gedit /boot/grub/menu.lst

Comment out any unwanted entries by adding a # in the beginning of each line that should not be displayed.

Save the file, and when you reboot the grub menu should be nice and small again.

Changing the Default Vista Explorer Window Size

webmaster@erikojebo.se — Sat, 25 Oct 2008 07:45:22 +0200

After using Vista for a month or two, the single most annoying thing was that Windows Explorer kept opening in its default size, which is far to small, at least if you have a decent resolution. I finally got tired of it and googled for a fix. It turns out that if you shift click the close button on the window, it remembers that size for the specific folder you are currently in. So what you have to do is to:

- start explorer the way you normally do
- change the size of the window to the desired size, then
- shift click the close button in the top, right hand corner before you do anything else.

It should now pop up with the right size, from now on.

For more info, read this blog post.

C# Automatic properties in Visual Studio 2008

webmaster@erikojebo.se — Wed, 01 Oct 2008 12:20:56 +0200

In .Net Framework 3.5 automatic properties were introduced. Automatic properties is a compiler feature that lets you write less code, and thereby increases your productivity. To add a property that only has a basic getter and setter, you only have to type:

The compiler then fills in the rest at compile time, making the above line equivalent to:

To create a read-only property, just make the setter private:

To simplify this even further, there are two code snippets, prop and propg, that generate template properties and let you fill in the name and type. The snippet "prop" generates a read/write property and "propg" generates a read-only property.

To invoke a snippet, start typing the snippet name and it will appear in the IntelliSense-window.

Pres tab once to auto-complete the snippet name, and tab again to expand the snippet name into the actual snippet.

Haskell

webmaster@erikojebo.se — Thu, 04 Sep 2008 14:14:56 +0200

As you probably have noticed, functional programming has recently become the new, hot thing, and one of the languages that suddenly has gotten an upswing in publicity is Haskell.

After listening to a few podcasts on functional programming I decided to play around with Haskell, and came up with the idea to use it for my Project Euler solutions. A quick search led to the Ubuntu Hardy Heron apt-packages ghc6 and haskell-mode, which are the Glasgow Haskell Compiler and an Emacs add-on for Haskell syntax support.

As always, the apt-installation was quick and simple, so in a matter of minutes I had a nice little Haskell development environment set up. The next step was to read some tutorials at the official Haskell page and shortly there after I was up and running.

I have to say that Haskell must be one of the most elegant languages I have encountered, so far. The pattern matching makes function definitions very simple and easy to read, but the detail I found the most appealing is the list definition syntax. For example:

[a | a <- [1..], a [mod] 3 == 0]

This declares an infinite list of all integers that are evenly divisible by three, which is made possible by Haskell's lazy evaluation.

A few days ago I was searching for new sites with video lectures, and to my surprise I found a great Haskell video lecture from O'Reilly Open Source Convention. The lecture was given by Simon Peyton Jones who is one of the guys behind the language. To my even greater surprise I then read that the Software Engineering Radio team had just released a podcast with Peyton Jones on functional programming and Haskell. Hopefully, more resources like these will pop up in the future.

If you are up to it, I really recommend playing around with Haskell. As a starting point, I would suggest the short tutorials at Haskell.org and the video lectures mentioned above.

Unit Testing in PHP

webmaster@erikojebo.se — Thu, 04 Sep 2008 13:58:06 +0200

Recently I have begun to adopt a test driven style of development, trying to do it the Kent Beck way, i.e. test first. When I started planning the development of this site I remembered reading about two different unit testing frameworks for PHP, namely PHPUnit and Simpletest. I decided to start with PHPUnit, and to my delight it was available as an apt package in my beloved Ubuntu, so the installation went as smooth as only apt installations can.

I tried it out on the shipped example, a unit test of an array, and was a bit disapointed with the interface. I had envisioned a PHP based framework that you simply ran in your browser, providing a nice HTML GUI. Instead it was a command line utility, that gave a quite sparse feedback, when running the tests. It had some nice features as report generation in various formats and testing code coverage, so it seemed powerful, but lacking the green bar/red bar feedback.

So, Google to the rescue. I did a quick search and found the documentation for the PHPUnit API basically explaining a nice way of using the API to create a GUI wrapper for PHPUnit. Another search resulted in a source forge project called Cool ("Cool Object Orientated Library", a little GNU-esque there... and it really is "orientated"). This turned out to be just what I was looking for. It was a php site, that provided a nice GUI for PHPUnit. The installation was painless, since all you had to do was to extract so that it is available from the web server.

I started playing around with Cool and PHPUnit and, unfortunately, it soon became obvious that Cool did not handle test suites that well, or at least that it did not work properly in my set-up. Once again, to the Google-mobile, but no luck, so I decided to give Simpletest a try instead.

As with Cool, all you had to do to install Simpletest was to extract it to a place that was reachable by your PHP code and you were done. I was glad to find that it shipped with a simple HTML GUI, so this was more in line with what I first had in mind. The documentation was well written and had good examples, so it did not take long to get up and running. Since everything felt solid I decided to use Simpletest for the project.

Simpletest turned out to be really nice to work with and it has a nice Mocking-framework, that was easy to use. The only down side was the HTML reporter which was very basic, so after a while I decided to write a slightly more advanced reporter. The API used by the reporter classes was documented and since the source for the original HTML reporter was available it was quite a simple job to write a custom reporter.

So, if you want a light weight, portable testing framework for PHP, I can recommend Simpletest. I will probably post my extended HTML reporter at this site in the near future, if anyone wants to try it out.