Next year it's starting with a busy busy month. This is the list of the engagements I already have, if you are nearby any of the cities I'll be visiting don't hesitate and we can have some beers ;) I'm also interested in meeting people in Tenerife that are willing to join INETA and create a .NET User Group over there...

So actually this are the planned speaks:

• C# 3.0 Language Features // Madrid .NET User Group, January, 18th 2007

Introducing Extension Methods, Query Languages, Lambda Expressions and all the upcoming C# 3.0 language features. Further details and registration at http://www.madriddotnet.com

• C# 3.0 Language Features // .NET User Group Galicia, Coruña, January, 19th 2007

First meeting of .NET User Group Galicia, and I'll be there presenting Extension Methods, Query Languages, Lambda Expressions and all the upcoming C# 3.0 language features. Further details and registration at http://www.nugg.es

• LOVE Tour: Windows Workflow and Windows Communication Foundation // Tenerife, January, 23rd 2007

I keep collaborating with MSDN presenting .NET Framework 3.0 over major cities in Spain. This time I'll be in Tenerife (Canary Islands) presenting Windows Workflow and Windows Communication Foundation. Further details and registration at http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032312578&Culture=es-ES

• LOVE Tour: Windows Presentation Foundation // Málaga, January, 25th 2007

I keep collaborating with MSDN presenting .NET Framework 3.0 over major cities in Spain. This time I'll be in Málaga, directly from Tenerife, presenting user interface improvements with Windows Presentation Foundation. Further details and registration at http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032312580&Culture=es-ES

 More to come for February.

A couple of days ago my fellow friend Ricardo Varela started to blog in spanish (in parallel with his actual english blog). Former member of Microsoft communities, he is actually working at Google UK. The actual point is that on his new blog he started a post with some kind of coding teasers, going back to basics, to the principles of coding. This is going to be funny.

Well, this is my answer to his post. There were three questions regarding data structures and alternative thinking about reversing things.

• Do you know how to reverse a string? In example, if you get "abc" the returned string should be "cba"

This seemed pretty easy. In C# every string is represented as an array of chars, so you can use the indexers to get chars at any position and reverse them "manually" with something like:

string inputString = "abc";
string reversedString = string.Empty;

for (int c = inputString.Length; c > 0; c--)
{
    reversedString += inputString[c - 1];
}

Console.WriteLine("Original String: " + inputString);
Console.WriteLine("Reversed String: " + reversedString);

Or you can use some of the features of the .NET Framework to do it in a more "elegant" way:

char[] chars = inputString.ToCharArray();
Array.Reverse(chars);

// Use the reversed array of chars

• Going deeper into data structures, do you know how to reverse the bits of a byte? In example, if you get 1 the returned byte should be 128

I must admit this was a hard one. Although I perfectly know the concepts of bits and bitwise operations the C# language doesn't provide an easy or structured way to access those elementary elements of data structures. I finally managed to achieve it. The smallest numeric data structure available to represent a byte internals I found was a simple byte[8], so now I just have to fill it with the values for each byte:

static byte[] getBits(byte inputByte)
{
    byte[] bits = new byte[8];

    for (int p = 0; p < 8; p++)
    {
        bits[7 - p] = (byte)(1 & (inputByte >> p));
    }

    return bits;
}

Simple? Ok, I'll explain it a bit... the bitwise operator >> just shifts the bits in the byte to the right so if 01010101 is shifted one position to the right it becomes 00101010... then I perform a logical AND operation with the mask 00000001 to determine if the bit is setted. I just store the state of every bit in the output array and return it. As a quick note, the bit array could be directly reversed if I change the line inside the for loop to:

bits[p] = (byte)(1 & (inputByte >> p));

But I wanted more generic methods to convert between byte and bits, so I didn't included reversing directly in that method. Once I have an array, it's simple to reverse it just with the previous method used with string arrays or via the .NET framework features:

Array.Reverse(bits);

And know, we only have to be able to convert the bit array back to a byte structure:

static byte setBits(byte[] bits)
{
    byte obyte = bits[0];

    for (int p = 1; p < 8; p++)
    {
        obyte = (byte)((obyte << 1) + bits[p]);
    }

    return obyte;
}

The method used is similar to the one I used to extract the bits, but this time the bitwise operator << is shifting bits to the left, so I can increase the number til it reach to the desired value. A simple test program to test how it works would be:

byte inputByte = 1;
byte outputByte = 0;

byte[] bits = getBits(inputByte);
Array.Reverse(bits);
outputByte = setBits(bits);

Console.WriteLine("Input Byte: " + inputByte);
Console.WriteLine("Reversed Byte: " + outputByte);

• And a more complex one. Floating point numbers are represented usually by the standard IEEE 754, would you be able to reverse the bits of a floating point number? In example, if you get 118.625f the output should be -17180580000f

Wow! This is was a really hard one. I didn't know how the IEEE 754 standard worked so I read it at the wikipedia (the IEEE page for this standard is under revision and there was no info available) and it seems pretty simple. The floating point its a 32bit data structured divided like this:

So now it seems much simpler to me. It's just a bit reversing operation, in C# the two floating point structures are Float or Double, the former to store floating point numbers with 32bits precision and the last with 64bits; the problem is that those types don't allow bitwise operations, so I need to create a new set of methods to work with them using the BitConverter class.

It's probably refactorizable so just a pair of methods suit all the needs of bit operations, but the goal was to reverse the floating point number, so here I go:

static byte[] getFloatingBits(double input)
{
    byte[] bytes = BitConverter.GetBytes(input);

    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(bytes);
    }

    byte[] bits = new byte[64];

    for (int i = 0; i < 8; i++)
    {
        Array.Copy(getBits(bytes[i]), 0, bits, i * 8, 8);
    }

    return bits;
}

I explain the method it...The float type can by divided into 4 bytes and the BitConverter.GetBytes method can give us an array of that four bytes, but unfortunately it doesn't include a method to turn back an array of four bytes to a float, so I created this method for the double type and used casting :(

The method is pretty simple, I extract the 8 bytes of the double precision float number. Then, I verify if the processor is LittleEndian and in that case I reverse the byte order to reflect the actual value. Everything is copied to an array of bits, and we are done. Now we only need to reverse that array of bits:

Array.Reverse(bits);

And turn back to the method that reverse the process from a bit array to a double precision floating number:

static double setFloatingBits(byte[] bits)
{
    byte[] bytes = new byte[8];

    for (int i = 0; i < 8; i++)
    {
        byte[] actualByte = new byte[8];
        Array.Copy(bits, i * 8, actualByte, 0, 8);
        
        bytes[i] = setBits(actualByte);
    }

    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(bytes);
    }

    return BitConverter.ToDouble(bytes, 0);
}

The issue is that the expected floating number is not the one I got with this method that reverse the complete array of bits. In fact, I've also re-read the question and it said "are you able to reverse the order of the bits for the exponent and mantissa?" ... I actually did also that, reversing only bits for mantissa and exponent, obtaining the following bit arrays:

Original: 0 10000000 10111011010100000000000
Reversed: 0 00000001 00000000000101011011101
Expected: 1 10000100 00100000000000000101011

But that reversed number doesn't represent the one that Ricardo stated in his post. What am I doing wrong? Is anything wrong in my point of view or is the expected number wrong? I'm really curious about why there is one bit less in the expected number and how the sign bit changed.

During the following post I'm going to explain a design pattern widely used during software development processes and how it fits into the .NET ecosystem. This pattern would probably fits into the structural patterns group and it's mainly used to decouple components, so abstractions and concrete implementations can vary independently.

Using the provider pattern in .NET (and most object oriented languages) is pretty easy. We need the following artifacts:

• A provider definition, used as a contract that specifies what it should do
• One or multiple provider implementations of the declared contract
• A consumer willing to make use of the provider and it's implementations

Imaging the following real life scenario: There is a basic definition of what a car should do (provider definition) and what is considered a car: it must have 4 wheels, an engine, steering wheel, etc.. in the market you are able to find lot of implementations following the actual definition of a car (implementations of the provider), and we, as consumers, can make use of the knowledge and methods defined in the provider contract to change the implementation we use without affecting our behavior (we are able to switch cars and use the common definition of it, as a car, to drive any of the implementations).

So know, imagine it in the context of software development. We have an interface that defines a set of properties and methods that our provider must implement; we then have one or multiple implementations of that interface available; and of course, any consuming application can use the interface to switch between implementations without being affected. Have a look to the following diagram:

This is pretty awesome and practical when we are willing to create componentized and decoupled applications. We just use interfaces. This pattern has been widely used in the new ASP.NET 2.0 to create the application services provider infrastructure. For example, the MembershipProvider can be defined either as SqlMembershipProvider or as a custom OracleMembershipProvider; they both provide the same functionality but with different behavior (one uses SQL Server as repository while the other is using Oracle databases)

This pattern itself, IMHO, can dramatically increase the quality of your architecture because of the modularity and simplicity it provides.

One of the hidden treasures of .NET is the existence of a Provider Model Framework that allows you to create custom Providers for anything (not only extensions of ASP.NET Providers, but any kind of .NET application or service)

Using .NET Framework 2.0 Provider Model

So let's start writting some code. To create a provider we first have to create a public abstract class that defines our contract. This class must implement the System.Configuration.ProviderBase abstract class and it should contain the definition of methods and properties used as the "contract" of our provider.

1 public abstract class ImageProvider : ProviderBase
2 {
3    public abstract bool CanSaveImages { get; }
4    public abstract Image GetImage(int id);
5    public abstract void SaveImage(Image image);
6 }

We then need to add the actual implementations of the provider. In this case, we are going to add an image provider for the file system and an extra one for SQL Server.

 1 public class FileSystemImageProvider : ImageProvider
 2 {
 3     public override bool CanSaveImages
 4     {
 5         get
 6         {
 7             return true; // As we allow to save images
 8         }
 9     }
10 
11     public override Image GetImage(int id)
12     {
13         // Some witty code to get the image from a folder in the FileSystem
14         return null;
15     }
16 
17     public override void SaveImage(System.Drawing.Image image)
18     {
19         // Some witty code to save the image to a folder in the FileSystem
20     }
21 }
22 
23 
24 public class SqlImageProvider : ImageProvider
25 {
26     public override bool CanSaveImages
27     {
28         get
29         {
30             return true; // As we allow to save images
31         }
32     }
33 
34     public override Image GetImage(int id)
35     {
36         // Some witty code to get the image from a folder in the FileSystem
37         return null; ;
38     }
39 
40     public override void SaveImage(System.Drawing.Image image)
41     {
42         // Some witty code to save the image to a folder in the FileSystem
43     }
44 }

And finally, we need to create the service that will use the ImageProvider. It's is coupled to the contract definition of our provider and not to it's implementations, so it knows what to ask for but no actually how or where will it be done. The service just initializes the provider using the LoadProvider() method (it should read the provider from the config file; have in mind that here it's hardcoded for instructional purposes and you only need to change the LoadProvider method to achieve that goal)

 1 public class ImageService
 2 {
 3     private ImageProvider _provider;
 4 
 5     public ImageProvider Provider
 6     {
 7         get
 8         {
 9             return _provider;
10         }
11     }
12 
13     public ImageService()
14     {
15         LoadProvider();
16     }
17 
18     public void LoadProvider()
19     {
20         ProviderSettings ps = new ProviderSettings("FileSystemImageProvider", "FileSystemImageProvider_Type_Assembly");
21         _provider = ProvidersHelper.InstantiateProvider(ps, typeof(FileSystemImageProvider)) as ImageProvider;
22     }
23 
24     public Image GetImage(int id)
25     {
26         return _provider.GetImage(id);
27     }
28 
29     public void SaveImage(Image image)
30     {
31         _provider.SaveImage(image);
32     }
33 }

The main caveat of using the .NET Provider Model is that you must reference the System.Web assembly in, probably, non-web projects. This is needed in order to access the ProvidersHelper class used to instantiate the provider collection. And it also forces the application to use the System.Configuration namespace and classes to read the provider configuration located in the web.config or app.config files.

You'll have to deal with the types and assembly names where those types are defined to create the ProviderSettings instance needed by the ProvidersHelper.InstantiateProvider method. It's maybe not recommended to use all this "web" references in a desktop or service context; so there's a clean and elegant alternative for the OO purists :)

The pure OO implementation

So, we need to get rid of the System.Web reference and make the provider pattern work without using the .NET Framework 2.0 model. The first thing we need to do is to refactor provider's abstract class to an interface (or leave it as a class, it's up to you, but remove the ProviderBase inheritance and any reference to the System.Configuration namespace) and change the concrete providers implementations to make them use the newly created interface. The class diagram should look similar to:

First, we should create the following code for the provider contract:

1 public interface IImageProvider
2 {
3     bool CanSaveImages { get; }
4     Image GetImage(int id);
5     void SaveImage(Image image);
6 }

And of course change the signature of the concrete provider implementations for FileSystemImageProvider and SqlImageProvider so they use the new contract:

 1 public class FileSystemImageProvider : IImageProvider
 2 {
 3    // Implementation of the provider code, only signature of the class changed
 4 }
 5 
 6 
 7 public class SqlSystemImageProvider : IImageProvider
 8 {
 9    // Implementation of the provider code, only signature of the class changed
10 }

The ImageService still almost the same, we only need to change LoadProvider's code so it creates an instance of the desired concrete implementation without using the ProvidersHelper class. Something like this may work perfectly:

1 public void LoadProvider()
2 {
3     _provider = Activator.CreateInstance(typeof(FileSystemImageProvider)) as IImageProvider;
4 }

Any conclusion?

As you can see, the approach it's quite similar for both methods and it's really simple to introduce it in most of actual software projects and architectures. It provides ease of installation, highly decoupled systems and modularity both in development and deployment.

There's no excuse to avoid this pattern, as far as it's possible and pragmatic to use it in the context of your architecture :)

Hope this helps anyone.

Yesterday I spent all the day in the preconference sessions at TechEd Developers 2006. I was going to attend Software Architecture sessions by Scott Hanselman, by I ended up at Agile Team System sessions by Roy Osherove.

It's really interesting to see Royt explain Agile and Team System concepts, althought the were not very deep if you are experienced with agile methods and practices. We saw Agile concepts, TDD and Continuous Integrantion practices and finally how to apply Scrum with Team System.

The most productive part to me was the Scrum session, and I got a really nice piece of intelligence from the Test Driven Development session. The name of test methods is really important because it's used directly as documentation, as a permanent sample of your code represented by unit tests. I already knew this, but the naming rules I used made me create names like this:

public void CreateUserWithNullUserName

And there's nothing wrong with that name, it's almost perfect from my point of view, because it states clearly what the unit test is testing. But Roy presented a naming rule based in three parts that results in a much much better name:

public void CreateUser_WhenUsernameIsNull_ThrowsInvalidOperationException

Indredible!!! Much more pragmatic. Much more readable. Much simpler to see the behaviour of that unit test with the pattern MethodName_Behaviour_ExpectedResult.

This has become an adopted practice. Inmediatly. During the next days I'll keep posting my thoughts about TechEd and sessions here.

I've been a fan of Lego Mindstorms since I first saw it two or three years ago. I bought my own Robotic Invention System (well, frankly it was Diana's gift for one of my birthdays... yoohoo!!!) and I love it... it provides me great intellectual and funny moments... I've learned how to use C# and .NET to program my robots and tried to attach a bluetooth device to it with no success.

I was really sad when Lego retired the kit, because I thought it would be almost impossible to find more pieces or expansion kits... but far away from what I though Lego announced a new version of the Mindstorms kit called NXT ... and it looks much more impressive than (the now old-fashioned) RIS; look at it:

I want one of those now! While I manage to buy one this is a list of interesting resources (an interesting fact is that the Lego website is developed using ASP.NET):

• Lego Mindstorms NXT press announcement (dated 4 January?!?)
• http://www.nxtbot.com/
• Lego Mindstorms NXT product features
• Lego Mindstorms NXT Issues Call for "NXT" Great Developers

By the way... Just related to my Lego Mindstorms addiction, I'll be speaking in an event called Applied robotics with Lego Mindstorms and C# in our April meeting (third Thursday) at Madrid .NET User Group

It would be held in Madrid, Spain; and in perfect spanish :-D ... If you can pass by and visit us that day, it would be great!