In order to get it working for WCF, you need to provide a custom error handler by implementing the IErrorHandler interface:

public class ElmahErrorHandler : IErrorHandler
{
    public void ProvideFault(Exception error, MessageVersion version,
                             ref Message fault)
    {
        var dummyRequest =
            new SimpleWorkerRequest("dummy", "", new StringWriter());
        var context = new HttpContext(dummyRequest);

        var elmahLogger = Elmah.ErrorLog.GetDefault(context);
        elmahLogger.Log(new Elmah.Error(error));
    }

    public Boolean HandleError(Exception error)
    {
        SDExceptionHandler.DoHandle(error);
        return true;
    }
}

This error handler needs to be added to the stack of error handlers. You can do this in a couple of ways, for example by providing a custom attribute that implements IServiceBehavior and then applying this attribute to your service class.

Next you need to add some configuration to your web.config and your all good to go:

<system.web>
    <httpHandlers>
        <add verb="POST,GET,HEAD"
             path="MyService.Elmah.axd"
             type="Elmah.ErrorLogPageFactory, Elmah" />
    </httpHandlers>
</system.web>

<elmah>
    <errorLog type="Elmah.XmlFileErrorLog, Elmah"
              logPath="C:\MyServiceLog\"/>
</elmah>

What’s nice about this approach is that you don’t need to run the WCF service in ASP.NET compatibility mode, which is a major bonus.

Hope this helps

I must say that I was pleasantly surprised by some of the features that this IDE has to offer. The first and most obvious one is probably intellisense that just works as expected.

Also notice the on-the-fly code inspection (colored marker bar on the right) that should be familiar when you’re a Resharper addict like me. Web IDE provides W3C XHTML/CSS validation while working in the editor which is really useful.

Being the uncertain type, it was also nice to see all the familiar refactoring features from Resharper being available as well. Renaming a class or id is just a breeze. All the corresponding HTML or CSS files are consistently updated.

Navigation is there as well (CTRL-N and CTRL-SHIFT-N).

This looks just like Resharper for web developers, but there’s more. At first, I had all the HTML and CSS files including all the image file in the root folder of the project. I wanted to divide and conquer by putting the images and CSS files into their own separate folder. As I prepared myself to change all the references in the HTML files, Web IDE did that all for me when I dragged the files to their final destination. Now I didn’t had to go over all the HTML files and manually change the links. How cool is that!

Web IDE also provides source-control integration Subversion, Git, Perforce, etc … and that’s just the tip of the iceberg. While working on the prototype of the web application, I mostly focused on the layout and not so much on the behavior so I didn’t use much of the JavaScript capabilities. But I was told that it is comparable with the JavaScript features in RubyMine as described by Peter in this blog post. This is something that I’m going to explore when I start learning more about JavaScript .

Although being the first version and still in beta, the IDE seems pretty stable and I couldn’t notice any performance hiccups so far (which cannot be said for all IDE’s these days).

I do hope that there will be some support for ASP.NET or other view engines like Spark, NVelocity, etc. … in future versions. In fact, I still silently wish that JetBrains would come up with an IDE for .NET. Being realistic about it, I don’t have high hopes for something like that coming out but it would totally rock if they decided to build one. Sweet dreams

Bottom line, when you’re doing web development in Visual Studio, make sure to also check out Web IDE. It will probably help you to become more productive along the way.

Invoking private methods is not considered a best practice in general, but there are cases where you have no other option than to fall back on using reflection. The following code snippet shows how one would typically accomplish that.

public class Subject
{
    private String DoSomething(String input)
    {
        return input;
    }
}

// Calling code
var subject = new Subject();
var doSomething = typeof(Subject).GetMethod("DoSomething",
    BindingFlags.Instance | BindingFlags.NonPublic);
var result = doSomething.Invoke(subject, new[] { "Hello Muppets" });
Console.WriteLine(result);  

We all recognize this piece of code as we’ve done this at some point in one of our coding sessions. What I want to share here is a slightly nicer way to accomplish the same without all the usual reflection ugliness.

// Calling code that uses delegates
var subject = new Subject();
var doSomething = (Func<String, String>)
    Delegate.CreateDelegate(typeof(Func<String, String>), subject, "DoSomething");
Console.WriteLine(doSomething("Hello Freggles"));

This code just creates a delegate that matches the signature of the non-public method that we want to call. To me, this approach looks far more elegant. Note that this only works for instance methods and not for static methods.

I hope that this can be of some use.

While I was (re-)learning CSS, I came across these two properties called margin and padding. At first, they seem to be doing the same thing namely providing space between HTML elements. But although they seem to fulfill the same purpose, there’s a clear distinction between the two.

The margin is intended for providing space between outside HTML elements or the sides of the page. Padding is used for providing visual space between the content and the border of the box.

The first example provides a margin to add visual space between the border and the parent element. The second one provides space between the border and the content.

I agree that this is trivial, but it matters to understand the difference between these two properties when using CSS.

Retrospective of 2009

• I learned more about integration patterns and ESB’s. I also learned about NServiceBus and I’m going to take this a few steps further in 2010. I’m hoping to get some real-world experience with a true Service-Oriented Architecture.
• StructureMap is now my IoC container of choice.
• I definitely learned a lot about NHibernate this year and I’m still a huge fan. I’m also looking forward to see what NHibernate 3.0 will bring to the table in 2010.
• Thanks to the European VAN presentations of Greg Young on DDD and Mark Nijhof’s CQRS sample application, I learned a tremendous deal about Domain-Driven Design. I finally understand some of the stuff that Greg Young and Udi Dahan are talking about for a couple of years now. 
• I (re)learned HTML/XHTML and picked up some basic knowledge about CSS during the last couple of weeks. My goal is not to become a CSS jedi, but I just want to have enough knowledge and experience in order to prevent the most obvious rookie mistakes.
• I took my first baby-steps in Ruby earlier this year, but I definitely need more study and practical use in order to become a more proficient user.

There’s some stuff on the list that I didn’t managed to learn about:

• JavaScript and jQuery
• Lean/Kanban
• F#

On the the other hand, I was able to learn about CouchDB and the NoSQL movement. I also learned a significant deal about RESTful architectures.

I also gained a lot of experience with WCF (Windows Communication Foundation) throughout the year, but I regret to say that it was mostly negative than positive. I don’t think that I’m going to consider this technology again in its current state. Maybe I’ll reconsider it again after it further matures.

Planning for 2010

Hereby the stuff I want to learn more about in 2010:

• Continue exploring NServiceBus and using it in a real-world project.
• Web development is something that I want to become more familiar with. JavaScript and jQuery are still high on the list, but I also want to take an in-depth look at some of the web development frameworks out there. I’m looking forward to learning about ASP.NET MVC, Fubu MVC, Django, OpenRasta and Ruby on Rails.
• Following my new motto of learning one NoSQL database each year, this year I’m going to take a closer look at MongoDB.
• Following the same credo applied on programming languages,  I’m currently very interested in learning Clojure, and not only because it can also target the CLR. As already mentioned, I also want to become more proficient at Ruby.
  

  Community

  On the community side, I’ll continue to co-organize the European VAN meetings with Colin Jack. We’ll try to do them on a more regular basis. I also hope to put out more blog posts in 2010 than I did in 2009. In 2007 and 2008 I managed to write ~100 blog posts a year. This past year, I didn’t even manage to publish half of that and I’m not very pleased with that. While I was evaluating the past year, I’ve come to some conclusions about what might be causing this. Maybe I’ll get back to this in a later blog post.

Well, there you have it. I would love to hear about some of the things that you, my dear readers, are planning to learn in 2010. I wish you all a happy and successful new year.

After logging on, the first step is creating a new appliance. Here you can choose which type of operating system you want to install (desktop, server or minimal), what type of desktop (GNOME or KDE) and the particular processor architecture you want to target (32-bit or 64-bit).

You can also give your appliance a name.

After you created your new appliance, its possible to select the packages that you want installed.  

Of course, you don’t have to choose everything yourself. Some packages are selected by default. Having MonoDevelop pre-installed is quite easy. Just search and add it to the selected software. You can even upload your own package and have it pre-installed for your appliance.

After you made up your mind on which particular applications should be included with your appliance, you can choose to do some configuration. For example, one of the most important choices you have to make is the background of your appliance .

Other settings like the language, keyboard layout, time zone, users + password, etc. … can all be pre-configured. When you’re done configuring, you can choose to create the appliance. There are a couple of delivery options you can choose from:

When SUSE Studio is done building the appliance you composed, you can either download it or take a test drive. Now, this is the probably the coolest feature of SUSE Studio. With test drive you can boot and test your appliance in a browser without downloading it!

I don’t know about you, but I would love to have something similar for configuring Windows appliances. I mean, wouldn’t it be cool to have the Windows OS pre-installed with Visual Studio, Resharper, TestDriven.NET, etc. …?

The only thing that I feel is missing in SUSE Studio are a couple of packages that are not yet available, like CouchDB for example. I also kind of expected that the latest version of MonoDevelop and Mono would be available already, but at the time of this writing only the previous versions can be pre-installed.

Now try it for yourself, it’s free . The only thing you have to do is apply for an invitation and you’re ready to take if for a test drive.

As my bookshelf has grown out of proportion over the last years, I basically had two options left. First option was to build an extra room onto my house that could serve as a private library, which is kind of expensive. Second option was to the reduce the amount of paper by buying an eReader device. I chose to investigate the second option. I already heard and read a lot of nice things about the Amazon Kindle, especially the Kindle DX.

As you may or may not know, these devices were not available in Europe until about a month ago Amazon announced that they will make the Kindle 2 available outside the US. But what I really wanted was the Kindle DX because it seemed to provide good support for PDF documents while the Kindle 2 doesn’t support this format at all. I already had a couple of eBooks in PDF format, so that was the most obvious choice for me. I also checked with the major book publishers and most of them also provide the native Kindle (AZW) and Mobi formats (beside PDF).

The only problem left was to get a Kindle DX to Belgium. Luckily David and Elle were happy to help me out on this one (many thanks). And so, since a couple of weeks I’m a proud owner of a Kindle DX. I must say that I really like the experience so far.

I wanted to read both novels and technical books using this device. The 9.7” e-ink screen (no backlit or LCD) provides a pleasant reading experience. At first, I was afraid that some documents wouldn’t be as readable due to the fixed format of PDF. But thus far, the Kindle DX seems to solve this very elegantly. Getting a PDF documents on the device is as easy as you’ve come to expect. Just hook it up on your PC using USB, copy the files and you’re good to go.

The size of the Kindle DX can be compared to a regular technical book. Its also incredibly thin and it definitely doesn’t weigh as much as some books.

The amount of storage is amazing. I can practically put my entire library on there without running out of space. It also has a very long battery life. I’ve been using it for about two weeks now and so far I did not have to recharge the battery.

Skimming through a book does take some time. You can’t beat a paper book on that one. But the search capabilities are very neat and it’s also possible to search in multiple books (which again is rather difficult with paper books).  You can place bookmarks its possible to go to a specific page number. The experience of going to a next or previous page was a bit odd at first, but I got used to that after a couple of hours. With auto-rotation, you can read a document in portrait or landscape. The only downside is that the experience is not as fluent as with an iPhone or iPod Touch because sometimes it can take a couple of seconds to adjust. Below are some pictures of my Kindle DX in order to get a sense of the PDF support that it provides:

  Enterprise SOA Adoption Strategies (InfoQ)

C# in Depth

    NHibernate in Action

ASP.NET MVC in Action

I haven’t tried the text-to-speech feature and wireless support. I also need to check out the support for audio books and the ability to make notes while reading. I think the most obvious new feature for a next version of the Kindle DX would be a color touch screen. That would make the whole experience even better.

Bottom line, compared to the Kindle 2, the Kindle DX is a no brainer. If you’re able to spend the extra money, you won’t regret it. The PDF support and the large screen are definitely worth it.

I must admit that getting through the first chapter, which tries to introduce the ESB, was not that easy. Too abstract and high level for my taste.

The second chapter is about the State of Integration and discusses how both business and technical drivers contributed to the ESB approach as opposed to Enterprise Application Integration (EAI). One of the best parts in the book is the discussion about “Accidental Architecture” which is an accurate and far too familiar description of the current architecture in most companies. Although the book is approximately 5 years old, it is still very relevant as the adoption rate of ESB’s is still not that common. But then again, I could be wrong about this .   

The third chapter examines the key concepts of an ESB were the author tries to prove that these are born out of necessity, based on real requirements and problems that couldn’t be solved with typical EAI broker architectures (like Biztalk for example).

Chapter 4 states that XML is the exchange format of choice for passing data structures between applications and services. Nothing new here.

Chapter 5 till 8 provide in dept information about each of the key concepts described in chapter 4, like Message Oriented Middleware (MOM), Service Containers and Endpoints, Routing, Transformation, Messaging, etc. …

Chapter 9 goes back to the real world by exploring the most common form of integration that is practiced today: bulk data transfer using ETL and an endless amount of small batch applications. Sounds familiar? This chapter also provides the necessary steps in order to migrate away from latency and reliability issues towards a real-time integration and how this affects your business.

Chapter 10 is a bit more technology focused as it talks about Java Components in an ESB. However, this could equally be .NET or any other platform.

For me, chapter 11 is a real masterpiece especially the part on Portal Server Integration patterns like Forward Cache and Federated Query. Highly recommended reading.

The final chapter discusses the WS-DeathStar (WS-*) specifications and what they could mean for an ESB.

In the end, I have a lot to think about after reading this book. It challenged a lot of my earlier assumptions on distributed computing and it certainly helped me understand a couple of things while I was exploring NServiceBus.

Till next time