Mads Tjørnelund Toustrup

Squirrel - The Basics

2016-03-11T00:00:00+00:00

Squirrel is like ClickOnce, but works.

This intriguing thesis made me wanna know more. By coincidence, I got the opportunity to spend the last few days fiddling with Squirrel. Squirrel is an install and update framework. It comes in a few flavours, for Mac, Windows, and iOS. In this post we’ll focus on Squirrel.Windows, the Windows flavour.

If you’ve ever had the pleasure of working with ClickOnce, you know that it has its flaws and that it can really be a pain to work with and maintain.

This post takes you through all steps of packing your application for release, distribution, installation, and updating.

Packaging

Squirrel is based upon NuGet. Your application is therefore wrapped into a NuGet package before Squirrel can make an installer.

I would recommend creating a .nuspec file and use the nuget pack command to create the .nupkg file. For a quick demo you can create the .nupkg using a tool like NuGet Package Explorer.

You .nupkg file should contain a single lib folder with a net45 folder inside. .Net 4.5 is a requirement for Squirrel, but it is not restrained to only be used with .Net 4.5 projects. Actually, you can use Squirrel to distribute and install any sort of desktop application on Windows and Mac.

Then inside your net45 folder you put the content you want to install. For .Net projects, this is often the output of a Release build. You can remove all IDE related files and debugging symbols, such as .pdb, .vshost etc. Set the appropriate metadata on the .nupkg file. The icon will be used on the application, and the package summary will be used as Name in the Programs and Features list.

Once you have a nice .nupkg file, you use Squirrel to Releasify the application:

> squirrel.exe --releasify myapp.1.0.0.nupkg

This means that Squirrel wraps it into a folder, a Releases folder per default, next to the .nupkg file. The Squirrel.exe is part of the squirrel.windows NuGet package. This means that an easy way to access it, is through the NuGet Package Manager Console in Visual Studio. Squirrel.exe comes with a number of command line options, which are worth looking into.

Inside the Releases folder is the .nupkg file, a Setup.exe, a Setup.msi, and a RELEASES file. The two Setup files are used for installation. The RELEASES file contains information, a SHA, name, and size of the releases in the folder.

The content of the Releases folder is your installation pieces. Just run the Setup.exe or the Setup.msi to install your application.

Distribution

One of the key features of Squirrel is that you can distribute your application from almost anywhere.

You can copy the content of the Releases folder to a local path, a Dropbox folder, Amazon S3, Azure Blob Storage, Microsoft IIS, etc. There are no requirements what so ever. You can even change the path or url and move the installation files. If you wanna use the background updating mechanism, you just have to update the path or url in your application.

Updating

To get started with updating your application you would need to pick up the Squirrel.Windows NuGet package:

> install-package squirrel.windows

This will give you the Squirrel namespace. Now you have two options, you can take the Easy-Mode or the Step-Wise path.

Easy Mode

When you have referenced the NuGet package you use the ‘Easy Mode’, which will run all the tasks necessary to check, download and apply new releases.

You can use the ‘Easy Mode’ with the following snippet:

using (var mgr = new UpdateManager("C:\\Projects\\MyApp\\Releases"))
{
    await mgr.UpdateApp();
}

You can place this snippet somewhere that makes sense. Some applications checks for updates on startup others have a separate UI for this.

If there is a new release for the application it will be installed silently in the background, and when the user restarts the application he will be using the new version.

Step-Wise

Opposite to the Easy-Mode, the Step-Wise updating mechanism is the solution if you would like to notify the user that there is a new release, and ask the user for permission to install.

As with Easy-Mode it is good practice to put the UpdateManager into a using statement. It is required that the UpdateManager is disposed prior to application termination. You can either handle this manually or use a using statement.

CheckForUpdate()

First step is to call the CheckForUpdate() method on the UpdateManager object:

using (var mgr = new UpdateManager("C:\\Projects\\MyApp\\Releases"))
{
    var updateInfo = await mgr.CheckForUpdate();
}

You can then use the updateInfo object to check the installed version and whether there is any new releases available. Using the FetchReleaseNotes() method you can retrieve the release notes from the .nupkg, display them to the users and let them decide whether they’d like to install the update.

DownloadReleases()

So if you want to install the release, we can extend our small sample with the following:

if (updateInfo.ReleasesToApply.Any())
{
    newVersion = updateInfo.FutureReleaseEntry.Version;

    Console.WriteLine("New version: {0}", newVersion);

    Console.Write("New version available. Install? (y/n) ");
    if (Console.ReadKey().Key == ConsoleKey.Y)
    {
        Console.WriteLine("Beginning to download...");

        mgr.DownloadReleases(updateInfo.ReleasesToApply).Wait();
        Console.WriteLine("... done downloading.");
    }
} What happens is that we check the `updateInfo` for any releases to apply. This would be any new releases. If this is the case we ask the user whether to install the latest release. If this is the case to call the `DownloadReleases()` method on the `UpdateManager` object. Upon downloaded, we can apply the release.

The downloaded release will be put into a folder next to the current.

ApplyReleases()

Once we have downloaded our releases, we can apply the releases using the ApplyReleases() method. This would extend our sample with this:

Console.WriteLine("Beginning to apply release...");
mgr.ApplyReleases(updateInfo).Wait();
Console.WriteLine("... done applying."); This step will change shortcut pointers from the current installed release to the newly downloaded.

CreateUninstallerRegistryEntry()

It is by all good practice to create an uninstaller for the user to uninstall the application in the Programs and Features page. This is done with the following:

Console.WriteLine("Creating uninstaller...");
mgr.CreateUninstallerRegistryEntry().Wait();
Console.WriteLine("... done creating uninstaller.");

Restarting Your Application

Whether you use the easy-mode or step-wise, you can restart your application after applying a new release. Squirrel has a buit-in feature for this. It is a static method on the UpdateManager:

UpdateManager.RestartApp();

This is the final step in creating a step-wise updating process for your application.

Gotchas

During my experimentation with Squirrel I came across some gotchas, which could be of interest to others.

There is an ArgumentException with a message saying, You must dispose UpdateManager!

You will run into this issue if you wrap your UpdateManager into a using statement and awaits the any of the async methods on UpdateManager, like this:

using (var mgr = new UpdateManager("C:\\Projects\\MyApp\\Releases"))
{
    var updateInfo = await mgr.CheckForUpdates();
}

The runtime will not be able to dispose your UpdateManager object before the application terminates.

To resolve this you can either make the CheckForUpdate() call synchronous, applying .Result to CheckForUpdate or make sure to dispose the UpdateManager when finalizing the AppDomain, like this:

AppDomain.CurrentDomain.ProcessExit += () => DisposeUpdateManager();

The other gotcha I ran into was a AbandonedMutexException with a message saying, Leaked a Mutex!

Again this is related to the locking mechanism of the UpdateManager. I got this exception when I tried to call the UpdateManager.RestartApp() method inside my using statement. This would close the running application before the UpdateManager’s mutex is released.

To resolve this, move the UpdateManager.RestartApp() outside the using statement.

Conclusion

Coming with some experience using ClickOnce, it is a relief to use Squirrel. It is much more lean, and requires so much less effort. Both in maintenance and development.

I have put my sample application on GitHub.

If you have any comments or feedback on this post, throw them into the comments.

Electron, From Web to Desktop - Part 1

2016-01-22T00:00:00+00:00

Some time back I kicked the tires of Electron. I really fancy the idea that you can use web technologies on your desktop.

With this mindset I decided to try out Electron. In this first post in a series of Electron posts, I’ll create a small and simple desktop app using Electron.

In this first post I’ll be showing how quickly you can get up and running with Electron.

Once again, npm is your friend. We create a folder in which we would like to hold our Electron desktop application:

> mkdir electron-hello

Then inside this folder we run npm init. You then have to answer some questions about application. This will create the packages.json file which contains some metadata about your application. This packages.json is mandatory in any Electron application.

Now we need to install the electron-prebuilt package:

> npm install electron-prebuilt --save-dev

This will install the electron-prebuilt package and store this dependecy as a development dependency in the packages.json, we created above.

Now go on and create a folder that will hold the application specific files:

> mkdir app

I’ve called the folder app. In this folder we once again run the npm init command, and answer the questions. Now we need to edit the packages.json file created. When you open the file in your favorite text editor it should look like this:

{
    "name": "app",
    "version": "1.0.0",
    "description": "",
    "main": "index.js",
    "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
    },
    "author": "",
    "license": "ISC"
}

For my own convenience I change the main to main.js, so my packages.json will look like this:

{
    "name": "app",
    "version": "1.0.0",
    "description": "",
    "main": "main.js",
    "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
    },
    "author": "",
    "license": "ISC"
}

Now create the main.js in the app folder. In this very trivial sample application the main.js will look like this:

var app = require('app');
var BrowserWindow = require('browser-window');
var mainWindow = null;

app.on('ready', function() {
    mainWindow = new BrowserWindow({
        width: 800,
        height: 600
    });

    mainWindow.loadUrl('file://' + __dirname + '/index.html');
    
    mainWindow.on('closed', function(){
        mainWindow = null;
    })
});

In the first line we require the app, which is our application. Next we require a browser-window. This is the actual Electron shell, which will host our application. The mainWindow variable will hold a reference to an instance of the BrowserWindow.

Then we hook up our application by listening to the ready event. So, when the application is ready we create the BrowserWindow instance and sets its dimensions. Then we load some content into the mainWindow by using the loadUrl method.

The loadUrl method can take anything basically. In this case we want to show a local index.html, but there is nothing that can stop you from host a website inside your Electron application. I could host and distribute this blog as a desktop application like this:

mainWindow.loadUrl('http://www.madstt.dk');

The last line in my main.js is an event handler, which will release the reference to the mainWindow object upon the application is closed.

We’re almost ready to take this little beast for a spin. We need to create index.html:

<html>
    <head>
        <title>Hello from Electron!</title>
    </head>
    <body>
        <h1>Hello from Electron!</h1>
    </body>
</html>

This is very simple.

Now, to launch this application we move to the outer folder (the folder containing the app folder). Here we can run the following command:

> electron app

Now your first Electron application is airborne. That’s was easy, right? In the following posts we’ll extend this simple application with more advanced features. On the top of my mind, the next post will focus on setting up gulp for building, running, packaging, and distributing the application. Other topics will be setting up AngularJS, crash reporting, distribution, automatic updating, debugging, etc.

Throw me a comment for suggestions.

Freelancing

2016-01-01T00:00:00+00:00

The last year or so I have had a growing wish to try myself of as an entrepreneur and become a freelancer. Time has come, and from January 1st I have started my own business. The name is madSkills.

I am so pleased that this is finally taking off. I am so much looking forward to service my own customers and help develop their businesses. My main focus is to support all kinds of businesses in my local area. I believe that the outer western part of Denmark upholds a large potential of businesse in the need of aware, present, and state-of-the-art consultancy. These services should not only be something for the larger cities in the Eastern parts of Denmark. I hope to be able to help and support small to large businesses in realizing their potential and growing great ideas to meet the challenges of the future.

I will continue working for d60, but in parallel I will take upon freelance tasks. As many of you know I have commuted 5½ hours a day to get to Aarhus and back. With my new business located locally, I will be much more flexible and have more time to see my kids and be part of their everyday life.

So what kind of tasks will I be up for? I am not that choosy with the kind of jobs and tasks I am up for. My main experience is with .Net and C#. So obviously that is where I’ll be building my business. In the last years have had a growing interest and experience with AngularJS and all web related. I hope to find tasks in these areas as well. Finally, I hope that I can build my business on Ionic.

Would you be interested in hiring me send me an email at kontakt@madskills.dk or ping me at @madskillsdk.

Ionic Denmark

2015-06-11T00:00:00+00:00

In this post I’ll outline how I became organizer of Ionic Denmark, and why this is such a good idea.

In a work-related context I recently had the opportunity to get chance to play around with Ionic. And it was love at first sight. There are so many aspects of Ionic, that I find attractive. I’ll cover many of these in the first meetup.

I’m no expert, but I’d really like to learn more about Ionic, so this motivates me into starting a meetup for Ionic, Ionic Denmark.

It was by a co-incidence that I started this meetup. I saw a tweet from @ionicframework about a scheduled meetup in @ionicpoland. I thought there might also be a meetup about Ionic in Denmark. But, unfortunately, no. There is no user group nor meetup about Ionic, so one thing let to another, and I picked up the @ionicdenmark Twitter handle. I asked @ionicpoland were they had their awesome logo from. They replied that @katiegv, marketing and communications manager of Ionic, was the one to talk to.

I got in contact with Katie, who informed me that Ionic has a complete setup for starting and supporting meetups. The logo is designed by @benjsparry, one of the co-founders of Ionic. We just received it a couple of days ago.

I started a meetup at meetup.com. I’ve used meetup.com as an attendee on other meetups, but never as an organizer, but it has really been a pleasure. I like the tool and its different features.

We have already scheduled the first meetup. Which will be on the 12th of August in Århus. The plan is to re-run this meetup in Copenhagen some time during September. The ambition is that we try to cover both Århus and Copenhagen with the same meetups. It can be difficult, and it depends on the event host, whether he/she will do the meetup both places.

In the first meetup we will cover hybrid apps in general and dig into the world of Ionic. This deep dive will take the audience around how to get started, tooling, the framework, etc.

I really hope to get this meetup up and running, so please register at meetup.com and join us.

Creating A Custom Log Handler In scriptcs.rebus

2015-06-09T00:00:00+00:00

In the latest release of scriptcs.rebus, it is possible to receive the log entries from a remote script execution process. On the client side you can define a number of log entry handlers, and specify at which log level they should receive the log entries.

Out of the box there is a console log handler, the ToConsole(), which you can add like this:

Require<RebusScriptBus>()
	.ConfigureBus("someBus")
	.With.AScriptFile("scriptfile_simple.csx")
		.Log.ToConsole()
.Send()

You can specify the at which log level you would like to receive logs entries in the console like this:

Require<RebusScriptBus>()
	.ConfigureBus("someBus")
	.With.AScriptFile("scriptfile_simple.csx")
		.Log.ToConsole(LogLevel.Debug)
.Send()

Now this would make all log entries with log level Debug send to the console of the client. This is great, but what if I’d like to get all log entries of LogLevel.Error put into a rolling file? Well, easy, you just implement the IReceiveLogEntries interface, and then add it.

This is an example of a simple, and yet naive, rolling file implementation:

public class RollingFileLogger : IReceiveLogEntries
{
	private StreamWriter _writer;

	public RollingFileLogger()
	{
		_writer = new StreamWriter(new FileStream("logs.txt", FileMode.OpenOrCreate));
		_writer.AutoFlush = true;
	}

	public void Log(string logEntry)
	{
		_writer.WriteLine(logEntry);
	}

	public LogLevel LogLevel { get; set; }
}

Now we can add this rolling file logger to our list of log entry handlers like this:

Require<RebusScriptBus>()
	.ConfigureBus("someBus")
	.With.AScriptFile("scriptfile_simple.csx")
		.Log.ToConsole(LogLevel.Debug)
		.Log.To<RollingFileLogger>(LogLevel.Error)
.Send()

This sends the all LogLevel.Debug, and below, entries to the console, while all LogLevel.Error, and below, are sent to a rolling file.

Other examples of log entry handlers could be SQL Server, MongoDB, RavenDB, Azure Blob Storage, etc. I might post examples of these in futures posts.

Throw me a comment below or ping me on Twitter, to let hear what you think of this feature.

scriptcs.rebus 0.6.0

2015-05-06T00:00:00+00:00

I’m really excited to finally announce the release of scriptcs.rebus 0.6.0. The 0.5.0 version was release back in November 2014, so this release has been under development for some time. This release is feature packed, its the version with the most new features since 0.1.0. It is a major step towards 1.0. It has been a great and fun ride, and I could have dumped more features in there, but on the other hand I’d also like to share these new features with you guys.

At the time of writing, scriptcs.rebus has been downloaded more than 850 times on nuget.org. Still, I haven’t received any feedback what so ever. The numbers count for themselves, there is someone out there using it. So, basically, I’m doing the features and the fixing the issues I find. If you’re using scriptcs.rebus, please let me know how you’re using it and if there is anything you’re missing.

What’s New

A bunch. In the following subsections I outline all the new features that is packed into 0.6.0.

Dynamic WebAPI Controller Generation

scriptcs.rebus now has built-in support for dynamically creating new controllers inside a running WebAPI application. Sounds awesome? It is. How does this work? I’ve extended scriptcs.rebus.hosting with the capabilities to take some controller logic and on-the-fly wrapped it into a controller class and served for the API. The scripting logic is saved to disk, so that if the server is restarted, the controllers are still available.

In which context could this feature become relevant, you may ask? Well, instead of having to take your API down for maintenance, you create new controllers without. You could also use this in the initial phases of creating your WebAPI. Just throw an empty WebAPI in the air, and dynamically create controllers as you explore the domain.

Let’s look at an example. The following code sends some controller logic to a WebAPI:

Require<RebusScriptBus>()
	.ConfigureBus("hostedBus")
	.With.AWebApiController("Customer")
		.AsAScript("public string Get() {return \"Customer name is Adam!\";}")
	.Send()

The AWebApiController() extension method takes a single parameter, which is the desired controller name. The Get() method is sent to the WebAPI. scriptcs.rebus.hosting saves this script, and on the next request to the WebAPI, a new controller is dynamically created and served. On all subsequent calls WebAPI serves the controller from memory. Script execution only happens on server restart or if a new controller script is sent to the WebAPI.

It is also possible to send your controller script as file, like this:

Require<RebusScriptBus>()
	.ConfigureBus("hostedBus")
	.With.AWebApiController("Customer")
		.AsAScriptFile("CustomerController.csx")
	.Send()

Now to set this script execution feature in your WebAPI, you should reference the scriptcs.rebus.hosting NuGet package. Then add the following piece to your WebApiConfig.cs

var bus = new MsmqBus("hostedBus");
bus.RegisterHandler(() => new ReceiveWebApiControllerHandler());
bus.Start();

This will enable your server to receive and correctly save the controller script appropriately. Now, also in your WebApiConfig.cs add:

var builder = new WebApiControllerBuilder();
builder.Build(config);

This will pick up the scripts and turn them into actual WebAPI controllers.

The credits for this feature goes to Glenn Block, who made some initial spiking on this. I basically teared it apart and put it into a messaging and scriptcs.rebus context.

You still have the same options with regard to downloading and referencing NuGet dependencies, local dependencies, etc. as you are used to from previous versions. See more here. Just as it is now:

Require<RebusScriptBus>()
.ConfigureBus("hostedBus")
	.With.AWebApiController("Customer")
		.AsAScript("public string Get() {return \"Listen to your customers!\";}")
	.AddFromNuGet("MongoDB.Driver")
.Send()

This would download and reference the MongoDB driver for usage in your controller.

Returning Script Execution Output

This is a great feature, and nonetheless quite unique in the script execution context. Currently, we can send scripts to host application for execution. We can use this feature to extend running applications with new features, dynamically. This is possible already today, but in this release I’ve added a feature to receive any script execution output in the client. This is possible since the backbone in scriptcs.rebus is Rebus, which makes it possible for the server, the host application, and the client, the script execution initiator, to communicate.

Currently all script execution output is sent to the console of the host. Often, or in many cases, the host application is blackbox and it is not possible to see any output.

Lets take a look at an example:

Require<RebusScriptBus>()
.ConfigureBus("someBus")
	.With.AScriptFile("scriptfile_simple.csx")
		.Log.ToConsole()
.Send()

In this example a script file, scriptfile_simple.csx, is sent the a host application for execution. The .Log.ToConsole() extension method tell the server to send all output back to the console of the client. This is a great way to get some insights into how your scripts are executed.

By default the log level is set to LogLevel.Info, other options are LogLevel.Debug, LogLevel.Error, and LogLevel.Trace, with raising density. The log level is set as a parameter on the ToConsole() method like this:

Require<RebusScriptBus>()
.ConfigureBus("someBus")
	.With.AScriptFile("scriptfile_simple.csx")
		.Log.ToConsole(LogLevel.Debug)
.Send()

This release ships with the built-in .ToConsole(), but there is an extension point to adding your log receiver. This is done through the To<T>:

Require<RebusScriptBus>()
.ConfigureBus("someBus")
	.With.AScriptFile("scriptfile_simple.csx")
		.Log.To<RollingFile>()
.Send()

Where T is an implementation of the IReceiveLogEntries interface. In this case a rolling file. Other examples could the Azure Web Storage or SQL Server. This interface contains a single Log() method and a LogLevel property.

This opens up for some pretty advanced logging scenarios. Like the following:

Require<RebusScriptBus>()
.ConfigureBus("someBus")
	.With.AScriptFile("scriptfile_simple.csx")
		.Log.ToConsole()
		.Log.To<RollingFile>(LogLevel.Debug)
.Send()

Here all log entries of log level Info is sent to both the console and the rolling file, but the rolling file also receives log entries of log level Debug. So cool..

New Hosting API

As you can see from the above examples, I’ve made some breaking changes to the hosting API. These changes were necessary, so I could add both logging and incorporate the WebAPI handler.

Previously you could only specify whether to use logging, which meant that the host would spit out logging entries to the host’s console. This is in many cases not a great solution. And since version 0.4.0, were scriptcs.rebus.hosting introduced, you would use the .WithAScriptFile() or .WithAScript() to send a scriptfile or script to a host. This is now changed, so there is now an extension point for future specific handlers.

Bug Fixes

This release of scriptcs.rebus also contains the usual number of bug fixes. There is a bunch of minor fixes that I’m not going to mention here, but focus on the larger and rather more important fixes.

Rebus Patterns

Rebus is designed with a number of messaging patterns. You can read more on these here. So far, I’ve relied on the Server pattern, but in the context of scripting this pattern has some unfortunate side-effects like the sender handling its own messages etc. This has sort of changed in 0.6.0. For simple messaging, it has changed to One-way Client Mode, but when specifying to use logging, we still use Server. This makes it possible to to provide a return address for the host to reply with log entries.

In short, no more weird behavior, were messages disappear due to bad messaging design.

Multiple Handlers

The idea of having multiple handlers is great, but it seemed rather buggy. It turned out that it was only the last added handler that was actually registered. This is now fixed, so that all handlers registered are actually active.

Azure Service Bus and RabbitMQ as Script Packs

A rather annoying thing about using the Azure Service Bus or RabbitMQ extensions for scriptcs.rebus, has been the necessity of adding a using statement. This is now fixed by turning the extension projects into pure script packs. This means that the necessary namespaces are specified inside the script pack, and it should not be necessary to add the using statement to your script anymore.

Latest Dependencies

Last but not least, I’ve updated scriptcs.rebus to the latest versions of scriptcs and rebus.

Should you have any questions regarding any of the above, don’t hesitate contacting me. I’m available on Twitter, but also on Gitter.

Azure IIS Logs in ElasticSearch

2015-03-09T00:00:00+00:00

In a work context we have been working on creating an internal logging framework. This framework should be use by all projects, and provide both developers and the support team a nice status of all running applications. We currently have support for Serilog, which is using the latest durable ElasticSearch sink.

Other types of logs supported are IIS logs and Azure IIS logs. In this post I’ll describe how we send Azure IIS logs from several Azure Websites to ElasticSearch.

Background

We wanted to create a small logging framework, which would enable fellow colleagues to easily send their logging statements to an Azure hosted ElasticSearch server. This would enable the projects, and our support staff, to supervise several projects using Kibana.

We did some extensive experimenting using the LogFlow log agent. LogFlow log agent watches a specific folder and forwards logs to ElasticSearch. Actually, it can be configured to apply for several applications, which I’ll describe later in this post. Serilog has an ElasticSearch sink, which can forward log statements immediately to ElasticSearch, but we were looking for a more durable option. Therefore it seemed obvious to use LogFlow, which can forward logs already written to disk. LogFlow is an executable looking through the current folder to find any assemblies with an implementation of the Flow class. We did have a hard time making this setup work in our context. So, we wrote a custom Serilog sink, which is durable and ElasticSearch capable. We wrapped the configuration of Serilog and the sink, in a small NuGet package and made it available in our internal NuGet repository.

Now, so much for application specific log statements, it would also be a nice addition to get the IIS logs from on-premise servers and from Azure Websites in ElasticSearch as well. This would provide great insights into server health, and maybe help foresee future server issues by surveying response times and status codes.

Azure Website Logs to Azure Storage

There is a rather neat feature in Azure Websites, which might not be known by the majority of Azure users. It is actually possible to get access to Azure IIS logs. A simple option on Configure tab for the website on the Azure Portal that you would like to get the logs from:

If you click the Storage button and followed by a click on the Manage button, you’ll be presented with this dialog:

Now in this dialog you should select which storage account to push your IIS logs. The storage accounts available is the accounts that is created in the same region and under the same subscription as the website. This is important. So, if you cannot find your desired storage account, it might be because it is created in a different region or under another subscription. You also specify the name of the container in this dialog.

When this is done, you can move over to the storage account and see the content of the specified container. It will only forward new log entries, so you should maybe do some dancing on you website before any log entries ends up in the storage container as blobs.

Azure Storage to ElasticSearch

Now that our log entries are safe inside Azure Storage, we need to index them for super search capabilities. This is done in ElasticSearch.

For the client package we discarded LogFlow as log agent, but in this scenario, LogFlow is at its prime. When using LogFlow you create a class that inherit from Flow. When the LogFlow.exe is started it will look for any assemblies with implementations of Flow.

A Flow implementation contains a call to CreateProcess(), which is found in Flow base class. The CreateProcess() call initiates a fluent configuration style, which contains three overall steps, FromInput(), Then(), and ToOutput(). The FromInput() step handles in input source and how the log entries gets picked up and put into the LogFlow flow. The Then() step does some processing of the log entries and, finally, the ToOutput() step forwards the processed result.

FromInput()

LogFlow contains two build-in input processors, the ConsoleInput and FileInput. The former reads the log entries from a console and the latter from any files, using a file watcher. In our case we need an input processor that can read from Azure Storage blobs. We therefore created the StorageInput, an implementation of the LogInput class:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using LogFlow;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;
using Newtonsoft.Json.Linq;

namespace AzureLogForwarder
{
    public class StorageInput : LogInput
	{
		private readonly List<CloudStorageAccount> _storageAccounts;
		private readonly int _readBatchSize;
		private readonly int _checkIntervalMiliseconds;
		private ConcurrentDictionary<Uri, CloudBlockBlob> _blobs = new ConcurrentDictionary<Uri, CloudBlockBlob>();
		private ConcurrentDictionary<Uri, BlobMetaData> _metaDatas = new ConcurrentDictionary<Uri, BlobMetaData>();
		private ConcurrentQueue<Result> _unprocessed = new ConcurrentQueue<Result>();
		private readonly IDictionary<string, long> _positionCache = new Dictionary<string, long>();

		public StorageInput(List<CloudStorageAccount> storageAccounts, int readBatchSize = 100, int checkIntervalMiliseconds = 30000)
		{
			if (storageAccounts == null)
				throw new ArgumentNullException("storageAccounts");

			_storageAccounts = storageAccounts;
			_readBatchSize = readBatchSize;
			_checkIntervalMiliseconds = checkIntervalMiliseconds;

		}

		private void GetCurrentBlobs()
		{
			foreach (var account in _storageAccounts)
			{
				var client = account.CreateCloudBlobClient();

				var containers = client.ListContainers(detailsIncluded: ContainerListingDetails.Metadata);

				foreach (var container in containers)
				{
					if (!container.Metadata.Any() || (container.Metadata["app"] == string.Empty || container.Metadata["env"] == string.Empty))
					{
						// invalid container metadata, container rejected for further processing...
						break;
					}

					var listBlobItems = container.ListBlobs(null, true, blobListingDetails: BlobListingDetails.Metadata);
					foreach (var someBlob in listBlobItems)
					{
						var blockBlob = someBlob as CloudBlockBlob;
						if (blockBlob != null)
						{
							var blob = blockBlob;
							_metaDatas.AddOrUpdate(blob.Uri,
								new BlobMetaData
								{
									ApplicationName = container.Metadata["app"],
									EnvironmentName = container.Metadata["env"]
								},
								(key, value) => value);
							blob.Metadata.Add("app", container.Metadata["app"]);
							_blobs.AddOrUpdate(blob.Uri, blob, (key, value) => value);
						}
					}
				}
				
			}
			return;
		}

		public override Result GetLine()
		{
			while (true)
			{
				Result result;
				if (_unprocessed.TryDequeue(out result))
				{
					var fields = new JObject();
					fields["app"] = result.MetaData["app"];
					fields["env"] = result.MetaData["env"];
					result.Json["fields"] = fields;

					return result;
				}

				while (_blobs.Count == 0)
				{
					Thread.Sleep(_checkIntervalMiliseconds);

					GetCurrentBlobs();
				}

				var blobs = _blobs.ToList();
				for (int i = 0; i < blobs.Count; i++)
				{
					ReadLinesFromBlob(blobs[i].Key);
				}

				if (_unprocessed.Count == 0)
				{
					Thread.Sleep(_checkIntervalMiliseconds);
				}

			}
		}

		private void ReadLinesFromBlob(Uri key)
		{
			var cloudBlockBlob = _blobs[key];

			using (var stream = cloudBlockBlob.OpenRead())
			{
				using (var reader = new StreamReader(stream))
				{
					var originalPosition = GetPosition(cloudBlockBlob.Uri.AbsoluteUri);
					reader.BaseStream.Seek(originalPosition, SeekOrigin.Begin);

					while (!reader.EndOfStream)
					{
						var result = new Result(LogContext) { Line = reader.ReadLine() };
						result.MetaData[MetaDataKeys.FilePath] = cloudBlockBlob.Uri.AbsoluteUri;
						result.MetaData.Add("env", _metaDatas[cloudBlockBlob.Uri].EnvironmentName);
						result.MetaData.Add("app", _metaDatas[cloudBlockBlob.Uri].ApplicationName);
						result.Position = reader.GetLogicalPosition();

						if (reader.EndOfStream)
						{
							result.MetaData.Add("processed", "true");
							result.MetaData.Add("etag", cloudBlockBlob.Properties.ETag);
						}

						_unprocessed.Enqueue(result);
					}
				}
			}
		}

		private long GetPosition(string blobUri)
		{
			var key = "position_" + blobUri;

			long position;
			if (!_positionCache.TryGetValue(key, out position))
			{
				return LogContext.Storage.Get<long>(key);
			}
			return position;
		}

		public void SavePosition(string blobUri, long pos, bool persist)
		{
			var key = "position_" + blobUri;
			_positionCache[key] = pos;

			if (persist)
			{
				LogContext.Storage.Insert(key, pos);
			}
		}

		public override void LineIsProcessed(Result result)
		{
			SavePosition(result.MetaData[MetaDataKeys.FilePath], result.Position, result.Position > 0);

			if (result.MetaData.Any() && result.MetaData.ContainsKey("processed"))
			{
				CloudBlockBlob removedBlob;
				_blobs.TryRemove(new Uri(result.MetaData[MetaDataKeys.FilePath]), out removedBlob);
				SavePosition(result.MetaData[MetaDataKeys.FilePath], 0, true);

				try
				{
					removedBlob.DeleteIfExists(accessCondition: AccessCondition.GenerateIfMatchCondition(result.MetaData["etag"]));
				}
				catch (Exception e)
				{
					Console.WriteLine(e);
				}
			}
		}
	}
}

With a default check interval of 30 seconds, all Azure storage accounts are iterated. Each blob found is attached an application name and environment name, found in the metadata of the container. If these are not specified on the container, the container is rejected for further processing. Then each line in the blob is read, and stored in a queue of unprocessed lines. When the overridden GetLine() is called, we pick the oldest in the queue and attaches application name and environment name to the JSON before returning. When a line is processed we persist the position, and check whether we have reached the end of the blob. If this is the case, we delete the blob and resets the position to 0. The latter is due to issues, where Azure re-creates a deleted blob for further processing. We can only delete the blob, if Azure hasn’t added more content in-between we detected end-of-blob and we try to delete it.

This implementation is pretty robust. It saves its position after reading a line and handles a possible race condition, so we don’t delete any blobs which has unprocessed lines.

One thing is to make a custom implementation of the LogInput class, another one is how to make these pieces run on Azure. We came up with the idea to run this as an Azure WebJob.

What we did was to create a free Azure Website, turn Always On, and add the output of your build as a .zip-file as a WebJob. The WebJob should be configured to run continuously. The Azure Website will unpack and start the LogFlow.exe, which will find the assembly containing our flow.

Then()

In this step we process the lines picked up in the previous step. In our case we can use the builtin IISLogProcessor. This processor will parse each line and set the correct fields with the correct values.

ToOutput()

In the final step we use the build-in ElasticSearchOutput processor. It takes an ElasticSearchConfioguration as parameter. In this configuration, we set the IndexNameFormat property and provides a ConnectionSettings instance as a parameter. Since our ElasticSearch server is using SSL, we provide a Uri instance with the correct credentials.

Summary

So, in this post I’ve outlined how we managed to get the Azure IIS logs into ElasticSearch. We use the build-in feature of Azure Websites to make them send their logs to Azure Storage. From here we pick them up using a WebJob, running on an Always On Azure Website. This WebJob uses LogFlow to process the log entries, and finally forwarding them to an Azure Virtual Machine which has an ElasticSearch server running.

If you have any comments, feedback, or what so ever, please feel free to throw us a comment below.

NCrunch, My New Crush

2015-02-05T00:00:00+00:00

This blog post is not about falling in love, being in love or love life in general. We fall in love now and then. Some love relations lasts a single night, some last longer, and even some lasts a lifetime. We fall in love, split up, find each other again, split up again, find someone else, and it all starts over again. You can put your money on multiple horses at once, but it is not recommendable though.

In the software business you get in touch with a large number of tools and technologies. Some gets dumped immediately, some stick around for a while and some even makes it into your toolbox. In contrast to your love life, you can have multiple tool and technology love relations at once, each serving their purpose.

In this post I’ll show off my latest score.

My New Crush

Years back I put my hands on this new continuous testing tool called NCrunch. I loved the idea and the perspectives. Unfortunately, I experienced some heavy performance issues, and had to uninstall the trial immediately. I dumped NCrunch. I forgot all about it. I made the conclusion that this was just another one of those tools who promised too much on the outside, and couldn’t live up to that. We have all been there. No big deal.

Years went by, I saw NCrunch named here and there, but always remembered how it had dragged down Visual Studio to its knees. Not for me.

Then a couple of months ago, I saw a Tweet by Damian Hickey saying that he was using NCrunch. Damian is one of my trusted sources when it comes to tools and technologies, so I thought why not give it another chance. I’d once fall in love with the ideas and concepts, time has passed, so there might have been some improvements.

And there has. This is not a complete feature full description of NCrunch, but more my personal usage and why I’ve fallen in love with this tool, and why it deserves a place in my toolbox.

Configuration

You can download a 30-day trial, and get access to all features. I’d recommend this, for both first-timers and old lovers. The first time you start up Visual Studio after installing NCrunch, you’re met with the configuration wizard. This is a brilliant piece of configuration. It lets your configure fine-grained details about how NCrunch should behave inside Visual Studio. Among other details, it lets you configure how to share the number of cores between NCrunch and Visual Studio.

This is a huge improvement. There are other key performance optimizations you can do with the wizard, like the maximum number of processing threads, parallel test execution, etc.

The last configuration you should do, before sending NCrunch loose on your code, is to specify how NCrunch should act upon start. You can choose to either, run all tests, or disable all and then enable them manually. Depending on your application, you might consider going for the latter. Currently, I have NCrunch running on a solution with ~7000 unit tests, so it would stupid to make NCrunch run all tests every time I change a character. My advise is therefore, to optimize performance, disable NCrunch for all test, and then enable / disable depending on the system under test (SUT).

Let’s Go Testing

Once configured, and enabled (Ctrl+M, D), you’ll notice dots next to each line in your code. The dots are very important, and gives you immediate feedback about the testing state of each line. A white dot means that this line of code is not covered by any unit tests. Red means there is at least one failing test for that line. And, of course, a green dot indicate that all unit tests covering this line succeeds. A red cross indicates in which line a test is failing.

As I use this tool, I find myself not doing things I used to. I rarely or never run the application. I never run use the unit test runner. I even rarely compile my code. Well, I do sometimes, but that’s pretty much just old habits. The NCrunch build engine is much faster than the built-in. Tools like NCrunch changes the way you work to the better. This is efficient development.

Code Coverage

As you can tell by looking over the code, you will be given an indication of the code coverage of that particular unit of code, i.e. white dots means not coverage and red/green dots means coverage. This is very valuable. It means that you don’t need an extra tool (read license), or extra window, for telling you about the code coverage. Coverage is explicit, right next to your code, not in some percentage in a dialog somewhere. It gives you that immediate feedback that is so valuable. Code coverage in percentages is a management KPI. I want to see which lines that are not covered by any unit tests. Now. Inline in my code window.

Next to the line where a test is failing, there will be red cross. If you wanna navigate to the corresponding tests, the Ctrl+M, S shortcut will open a context menu to show you which tests covers that specific line.

If you wanna see the ‘usual’ full code coverage of your code base, this is possible through the NCrunch Metrics dialog.

Profiling

If we switch over to your unit tests, you’ll see the same dots as in your SUT. You’ll see whether the test is successful and a red cross indicates where in the test it is failing. In contrast to the dots in the SUT, these dots can have varying colors. These dots has a ring, indicating a ‘hot spot’, which means that the test is slow. If you hover your mouse over the dot, you’ll see how much time NCrunch took to execute that specific line. This is also a very useful feature. Instead of investing in an expensive profiling tool, NCrunch will give you this, inline in code.

As it can be seen in the above, the code lines 761, 762, and 768 are ‘hot spots’ and have a significant execution time, while the lines 771 and 773, has less significant execution time.

Risk And Progress Bar

This is one little brilliant feature. The Risk and Progress bar (R&PB) keeps track of the overall status of how your coverage is and how you’re doing overall, in one compact overview.

The R&PB consists of two components, a numerical indicator and a risk projection. If there is any failing tests, the numerical indicator would show the number. If there isn’t any failing tests, a risk percentage will indicate whether there might be tests that can fail given the current state of the solution. If it is a large solution with many long running tests, the risk percentage can indicate whether or not to make a commit to source control.

The risk projection serves two purposes, an overall status of the ongoing NCrunch processing, indicated by a progress bar, and a risk curve, indicated by a darker color, which shows the risk percentage at any time during processing.

Distributed Processing

This could become a real time saver. NCrunch can offload build and test processing to servers. For developer teams this is could be an awesome feature. Builds and tests can be processed concurrently on a number of other computers. It is even possible to offload the entire build and test work from the client. All that is required is a TCP connection to where the processing should be offloaded to.

Summary

As I’ve already outlined, I’m in love. NCrunch is not just a crush. NCrunch is love. As outlined in this post, NCrunch has quickly become an essential tool in my toolbox. I can’t imagine me writing any unit tests without anymore. I’d encourage any other unit test practitioner to give NCrunch a spin. I promise you, you’ll thank me afterwards.

Also as stated there is a 30-day trial, and I admit it, it is a rather expensive license, but it is worth every little penny.

Throw me comment below and share your experiences using NCrunch.

Migrating to Jekyll

2015-01-20T00:00:00+00:00

For a while I’ve been working on migrating my blog over from Wordpress to Github Pages and Jekyll.

What

So, Jekyll is a static site generator written in Ruby. I uses a template engine called Liquid which supports a number of markdown flavors, as well as HTML. You can therefore write your blog posts in HTML or markdown, and then make Jekyll generate a static HTML page for you.

Why

A number reasons is behind this decision. I was really never that happy with my Wordpress solution, I had a hard time with the themes. Actually I never found a theme that I really liked. So my reasons to migrate can be outlined in the following bullets.

I really had a hard time working with the Wordpress themes, I couldn’t find one that fitted my needs and I found customizations hard.
I’m a markdown lover. It really fits my needs. I feel much more productive writing beautiful posts and notes using markdown. I try to use it everywhere I can. I recently got markdown support in Confluence from Atlassian. We use Confluence for documents at work.
I like that I can sit down and write my blog posts in my favorite markdown editor, currently MarkdownPad, and just git commit and push it to my blog.
One of the things that was really hard for me when using Wordpress, was how code is rendered. I tried different approaches, but neither seemed to fit my needs.
All the themes I tried out, did not render nicely on mobile or tablet.

So therefore I migrated to GitHub Pages.

How

Basically I followed Hadi Hariri’s guide. Although Hadi’s post is based on installing Jekyll on OSX (Linux and Unix is also supported out of the box), and I wanted to install this on Windows, his guide is good starting point.

To install Jekyll on Windows I followed Julian Thilo’s guide. Once you’re done with Hadi’s and Julian’s guides, you have all your blog posts in the _posts folder as HTML.

I then spend some time finding a Jekyll theme that would cover most of my needs. At this point I could start tweaking the _config.yml and the templates in _layout. You can use your HTML and CSS skills to modify and tweak your blog to look exactly as you would like.

I write my blog posts in markdown, and the Liquid templates takes care of how it is rendered.

Done?

No. I’m still not completely satisfied with the looks of the blog. I’m still in the progress of changing bits and pieces. One of the things I would really like, is an archive feature, to where I can reference for specific categories. I also need to change the landing page. I don’t like the current ‘list’ view. There are other more or less advanced changes that is would like to apply.

Throw me a comment of what you think about the new layout of my blog.

So, Campus Days 2014...

2014-12-03T00:00:00+00:00

Last week I had the opportunity to attend Campus Days 2014 in Copenhagen. A Microsoft hosted conference. In this post I’ll give my feedback on the conference and, in particular, the content.

It was my first Campus Days conference, since Campus Days until this year had been focusing more on the DevOps/IT Pro facets. It now turns out that Danish Developer Conference has merged with Campus Days. This makes the conference a much better choice for developers.

Since august I had been in contact with one of the organizers, Technical Evangelist Anders Lybecker, whether I should be giving a talk on scriptcs. Unfortunately, I didn’t make the cut, but was giving a user group talk at CNUG on Tuesday night instead.

Sessions

Campus Days 2014 had 11 tracks(!), but in essence there two-three tracks that would be relevant for .Net developers. These tracks were App Development, Microsoft Azure & Web Development, and Visual Studio & Team Foundation Server. So in these three tracks I found my sessions.

Mary Jo Foley from ZDNet gave an inspiring keynote on how she saw Microsoft in the past, today, and tomorrow. This was not the usual keynote, which gave a sort meh-feeling afterwards. With over 900 attendees, a large venue and Microsoft as host, I would expect them to be able to attract a larger speaker name.

I started out at session called Introduction to Project Roslyn with Henrik Lykke Nielsen. I think this was my third introduction to Roslyn, and none, this one included, has given me the everyday tool that I was promised. What I really mean by this is, that since I heard about Roslyn back i 2011, I was told that this would revolutionize the .Net developer’s toolbox. I still miss this point. Henrik gave a good baseline introduction to Roslyn, and then, like the other ‘introduction to’ sessions I’ve attended, showed of how to make analysis and diagnostic tools for Visual Studio. This is a great feature, no doubt, but who would argue that this is a feature that the everyday .Net developer would use? I might not be too objective, but I think that what scriptcs does is were I see power of Roslyn unleashed - powerful and instant compilation of C# code.

Anders Lybecker gave a nice session on Azure Search full-text searching. Having experience with Elastic Search I think Azure’s ‘we’ll do the configuration for you’-approach is something that might trigger a lot of newcomers into using these search engines. It is very straightforward to install and configure Elastic Search, but if you are new to full-text searching the Azure Search approach is very appealing.

Mogens Heller Grabe held his famous talk on CQRS and event sourcing. I’ve heard the talk before, but Mogens did some very neat things using Azure Service Bus Relay Service, which I’ve never seen before. With the relay service you can create hybrid applications that can run both on-promise and in the cloud, and still use the same infrastructure. The relay service makes it possible to by-pass firewall restrictions.

On the second day, I went to see Morten Christensen do a session on Azure Management Libraries. In essence the Azure Management Libraries is bunch of CLI tools for automating everything around managing your Azure instances. Being a CLI and automation fan-boy I found these tools very appealing, and something that I need to have in my toolbox. Morten did somehow mistime his talk, and did the session in 30 minutes, despite it being a 75 minutes slot. My own experience is that it is very difficult to hit the exact time, but a 45 minutes off is way too much. 30 minutes into a session slot, doesn’t give the attendees a chance to find different session, since it’s difficult catch up for missing 30 minutes.

In the next slot, I attended Christian Horsdal doing a talk on modulary web applications using OWIN/Katana. I’ve used OWIN for OAuth2 before, but Christian showed off some nice Func-of-Func examples, that really illustrated the OWIN pipeline workflow. Good talk, with a nice flow and good balance between slides and code.

Later I had the pleasure of enjoying Christian Dalager’s talk on Azure WebJobs. I’ve never had any scenario for WebJobs, but they are pretty cool. So, basically you can write scripts in your favorite script language, although scriptcs is still missing, and make your Azure Website make use of it to do some background job. Christian demoed a small Twitter-like app for sending emotional tweets, or emotweets. He showed how the site would benefit from the use of WebJobs. I really liked Christian’s presentation, both informative and funny.

The last session on the second day of Campus Days, was on web security. Anders Skovsgaard, the founder and kingpin behind Hackavoid, did a really awesome session on and about web security. Probably the best of the conference, so much take-away. He did a combine theory and practice session, where he show some of the most utilized web site hacker methods, both with examples of how to use them and how to prevent them. This is a very smart and bright guy, who has a lot experience in this field. He has done security work for both Google and Twitter.

On the third day, I stopped by Christian Holm Diget’s talk on patterns in single-page applications. I probably had other expectations to that talk, than what Christian really wanted to show. From the title and the abstract, I would have expected a talk on general patterns in single-page applications, but Christian showed us how AngularJS and other frameworks are composed, and that they share similarities. One of points, Christian emphasized was that, you, as a developer, should not be too religious about choice of framework, but rather focus on design principles and the domain. That’s true. I would therefore have expected, a clean talk without any, or maybe very little, mentions of libraries and frameworks. As a former colleague, I can tell that Christian is a great developer, both on .Net and web, and can give us all a lesson on single-page applications, but I just had the wrong expectations to this talk.

In my second session on the third day, I attended Lasse Skytte Knudsen in his talk about migrating from Azure Federation to Azure Elastic Scale. This talk really didn’t get. I was probably not the target audience. It was one of those sessions slots, where it was difficult to pick a session.

The ASP.NET vNext has really been buzzed and hyped recently, so it really made good sense to attend a talk about this topic. Stig Irming-Pedersen gave us a great introduction by showing off some of the most important aspects. This talk was indeed one of the highlights of the conference. I’m not going to use this post on explaining details about ASP.NET vNext, this can be read elsewhere, but I would use this space to credit Stig for a great talk.

My last session of Campus Days 2014, was about coded UI tests and cloud-based load tests. I’ve previously used coded UI tests, and was rather pleased to see how much has progressed since then. Peter Lindberg gave a brief introduction to the latest in coded UI test with Visual Studio. Showed a nice demo with manually recording test scenarios, progressed and showed how to automate them. Finally, maybe a bit overdue, but nonetheless very relevant, cloud-based load tests were used to load test the application with the same test scenario. These cloud-based load tests has very promising aspects. You can assign a number of virtual users, depending on your subscription, and make them use your application. Very clever.

Venue

The Cinemaxx movie theater is a great venue for hosting a conference. Great audio, great seats and awesome displays. But, and there is usually a but. Why does a movie theater with 14 screens on three floors, only have toilets on the lower floor. The staffing was adequate and kind. All in all, the positives by far outnumbers the negatives with regard to the venue.

Catering

Catering covers all kinds of food, beverages and snacks provided by the host or sponsors. And this is by far, my most critical point, it was bad. Compared to other Microsoft hosted conferences I’ve attended, the catering of Campus Days 2014 was particularly bad. On the first day, my session got delayed due to some technical issues, so all there was left was this:

I’ve got a lot of replies on Twitter, asking what this is. And no, it is not a dead or squashed turtle. It should be something Paleo-thingy, with Portobello mushrooms acting as bread around some veggies and meat. I didn’t taste it, so I’m willing to take the punches. But Microsoft, this is an IT conference, throw us some delicious sandwiches, and use the Paleo stuff in your own canteen.

On the second day, there were sandwiches, and great sandwiches. But, on the third day, we were back to the experimental kitchen. I ended up getting two rolls in ricepaper with a tiny piece of salmon, and a proportionally large amount of salad. They were very dry and tasteless. An alternative was wraps with pulled pork. I was thrilled, but again, so terribly disappointed. The tortilla wrap was replaced with cabbage leaves. Now that is blasphemy. Again, were did the good sandwiches from day 2 go? Some times the good alternatives were lacking in stock.

Breakfast was served in brown bags. Brown bags with a tiny piece of bread with a hard crust, some cheese, chocolate spread, and jam. The bread was nice and fresh, but why only a single piece. I got two bags, ending up with too much cheese and stuff, generating food-spill. And all garbage these brown bags generate was enormous.

Also at the social event on Wednesday night, a 1920s themed event with jazz and poker tables. It was well themed, loved the jazz, the entertainment, and drinks, but again the food failed. We had Budweiser, bad beer, and badly timed according to the 1920s theme, but ok, I could live with that. There were other options like a variety of craft beers, wine and drinks. The food was steaks and burgers. Unfortunately, the steaks was very rare, and served only with a fork. Although chopped, but in very large chunks, it just made the experience so bad. The burgers was ok, to the extend that they were difficult to handle and very juice. One thing to note about the Campus Days conference, is that there was not enough seats for everyone, so many meals is eaten standing.

Round Up

This really turned out to be a large blog post, but I think the speakers, of which sessions I attended, deserves some feedback. I know they’ve spend hours preparing their talks. And also Microsoft for hosting the conference, might need some feedback from the trenches.

All in all a great event. The assembled group of speakers was great, although I could have wished for bigger speaker names which could have given the conference some international attendees as well.

An advise on the catering, find different supplier that knows their audience and were supplies last.

scriptcs.rebus 0.5.0

2014-11-13T04:37:15+00:00

This release is coming very soon after the 0.4.0. It doesn't mean that I'm going to increase my release cycle, it's just that I have some new features that I'd like to share with you and there were things in the 0.4.0 that I wasn't satisfied with.

What's New

The following subsections describe the new features of scriptcs.rebus 0.5.0.

New API for scriptcs.rebus.hosting

In 0.4.0 I introduced the hosting feature in scriptcs.rebus. With this feature you can extend any standard .Net application with new functionality using scriptcs. You would send a custom script to a host application, which would then be able to compile the script and execute this inside the host process. Now, in 0.4.0 you would send the script like this:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .SendAScriptFile("start.csx")

This would send the script inside the start.csx to a host for execution. And, if you would need to download and reference a NuGet package, you would do it like this:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .SendAScriptFile("start.csx", "mongocsharpdriver")

This would download and reference the Mongo C# driver and execute the start.csx script inside the host application. This was my initial and, admitted, pretty naive implementation. So, when I wanted to introduce the use of the Mono compiler inside the hosted application, I ran into some issues. You can read all about my endeavours with scriptcs.hosting here.

So, in 0.5.0 I've changed the API, so now if you want to send a script you go like this:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .WithAScript("Console.WriteLine(\"Hello everyone!\")")
    .Send()

And a script file:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .WithAScriptFile("start.csx")
    .Send()

This is all just semantics, so why the change? Well, I wanted to add a bunch of additional options, so therefore I needed a fluent api for this. In the following sections I'll shortly describe them.

Add a Local Reference to Host Executed Script

If you want to reference a local assembly to be used in your script, this could be an assembly that is part of the host application, you can add the following option:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .WithAScriptFile("start.csx")
        .AddLocal("someLocal.dll")
    .Send()

Now, you can reference more local assemblies, just add another AddLocal().

Download and Reference a NuGet Package for Host Executed Script

So if your script needs a NuGet package to extend the host, you can specify these using the AddFromNuGet() like this:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .WithAScriptFile("start.csx")
        .AddFromNuGet("mongocsharpdriver")
    .Send()

Again, you can add multiple AddFromNuGet() to the configuration.

Importing a Namespace for a Host Executed Script

So, imagine we now have downloaded a NuGet package or referenced a local assembly, then to make it available for the script, you need to specify in which namespace to find the type you wanna use:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .WithAScriptFile("start.csx")
        .AddFromNuGet("mongocsharpdriver")
        .ImportNamespace("MongoDB.Bson")
    .Send()

This would download and reference the Mongo C# driver and make the MongoDB.Bson namespace available to the script for execution.

Using the Mono Compiler on the Host

Since the current release of Roslyn, does not support things like the dynamic keyword or async/await, it might be handy to be able to use the Mono compiler on the host:

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .WithScriptFile("start.csx")
        .UseMono()
    .Send()

Now the Mono compiler is set as execution engine, the script will be compiled. A scenario like this could also be relevant when doing cross-platform development.

Logging Inside the Host

In some cases it might be great to see some debugging output in the host console.

Require<RebusScriptBus>()
    .ConfigureBus("myOwnBus")
    .WithScriptFile("start.csx")
        .UseLogging()
    .Send()

This sets the loglevel to Debug, instead of Info which is default. This feature is only relevant in a limited number of cases where the host is a console application.

Using Script Packs Inside a Host

Script packs are really just NuGet packages used for hiding boilerplate code of common frameworks. Therefore, if you download and reference a script pack, it will be made available to the script without any further.

That's all there is to 0.5.0. So throw me comment, either below or on Twitter.

Endeavours With scriptcs.hosting

2014-11-05T04:16:09+00:00

One of the most promising perspectives in scriptcs, in my opinion, is hosting. Basically hosting is the complete package of scriptcs, just put inside your own application. It can be pretty mind blowing to think about this. Hosting makes it possible execute C# scripts inside of any standard .Net application.

With my scriptcs.rebus project, I wanted to add a feature, which would use scriptcs.hosting for executing scripts inside of a host. The script was supposed to be send over either MSMQ, RabbitMQ, or Azure Service Bus. When the host received the script it would be executed. It should also be possible to added NuGet references, local dependencies, and import namespaces to be used by the script.

I had read the excellent blog post by Filip Wojcieszyn on extending Glimpse using scriptcs. This blog post gives a small hint on the perspectives for scriptcs hosting. When I came up the idea of combining scriptcs hosting with messaging, I had a Jabbr session with Glenn Block, who guided me in the right direction.

The end of the session with Glenn, was that all I needed to do was reference scriptcs.hosting, and I should be given all the dependencies needed.

Initial Attempt

I started looking into how the internals of scriptcs is working, and how hosting in particular is working. I soon realized that there is a number of different dependencies at work, and quickly came up with idea of using AutoFac, which is also used inside of scriptcs hosting. I wrote a rather nice script module, on which I registered all my dependencies from scriptcs.hosting.

This script module would be registered in my ScriptHandler. The ScriptHandler subscribes to messages of type Script:

public class ScriptHandler : IHandleMessages<Script>
{
    public void Handle(Script message)
    {
        var builder = new ContainerBuilder();

        builder.RegisterModule(new ScriptModule());

        using (var container = builder.Build())
        {
            using (var scope = container.BeginLifetimeScope())
            {
                var logger = scope.Resolve<ILog>();
                var executor = scope.Resolve<ScriptExecutor>();
                scope.Resolve<IInstallationProvider>().Initialize();

                try
                {
                    executor.Execute(message.ScriptContent, message.Dependencies);
                }
                catch (Exception ex)
                {
                    logger.Error(ex);
                    throw;
                }
            }
        }
    }
}

So upon receiving a script, the script module is registered, and I can resolve the logger and ScriptExecutor. I thought this was a pretty cool setup.

For completeness my ScriptExecutor would look like this:

 public class ScriptExecutor
 {
    private readonly ILog _logger;
    private readonly IFileSystem _fileSystem;
    private readonly IPackageAssemblyResolver _packageAssemblyResolver;
    private readonly IPackageInstaller _packageInstaller;
    private readonly IScriptPackResolver _scriptPackResolver;
    private readonly IScriptExecutor _scriptExecutor;

    public ScriptExecutor(ILog logger, IFileSystem fileSystem,
                        IPackageAssemblyResolver packageAssemblyResolver,
                        IPackageInstaller packageInstaller, IScriptPackResolver scriptPackResolver,
                        IScriptExecutor scriptExecutor)
    {
        _logger = logger;
        _fileSystem = fileSystem;
        _packageAssemblyResolver = packageAssemblyResolver;
        _packageInstaller = packageInstaller;
        _scriptPackResolver = scriptPackResolver;
        _scriptExecutor = scriptExecutor;
    }

    public void Execute(string script, string[] dependencies)
    {
        // set current dicrectory, import for NuGet.
        Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;

        // prepare NuGet dependencies, download them if required
        var nuGetReferences = PreparePackages(_fileSystem, _packageAssemblyResolver,
                                        _packageInstaller, PrepareAdditionalPackages(dependencies));

        // get script packs: not fully tested yet        
        var scriptPacks = _scriptPackResolver.GetPacks();

        // execute script from file
        _scriptExecutor.Initialize(nuGetReferences, scriptPacks);
        var scriptResult = _scriptExecutor.ExecuteScript(script);
        if (scriptResult != null)
            if (scriptResult.CompileExceptionInfo != null)
                if (scriptResult.CompileExceptionInfo.SourceException != null)
                    _logger.Debug(scriptResult.CompileExceptionInfo.SourceException.Message);
    }

    private IEnumerable<IPackageReference> PrepareAdditionalPackages(string[] dependencies)
    {
        return from dep in dependencies
            select new PackageReference(dep, new FrameworkName(".NETFramework,Version=v4.0"), string.Empty);
    }

    // prepare NuGet dependencies, download them if required
    private static IEnumerable<string> PreparePackages(IFileSystem fileSystem, IPackageAssemblyResolver packageAssemblyResolver,
                            IPackageInstaller packageInstaller, IEnumerable<IPackageReference> additionalReferences)
    {
        var workingDirectory = Environment.CurrentDirectory;

        var packages = packageAssemblyResolver.GetPackages(workingDirectory);
        packages = packages.Concat(additionalReferences);

        packageInstaller.InstallPackages(
                            packages,
                            allowPreRelease: true);

        return packageAssemblyResolver.GetAssemblyNames(workingDirectory);
    }

}

The Execute() method will take the script to be executed and a number NuGet dependencies. Setting the Environment.CurrentDirectory is required for NuGet to be able to determine which packages are already installed, and where to download and install the new ones. The PreparePacakages() method will download and install NuGet packages, if they are not already installed. If there is any script packs installed, they'll be referenced, using the ScriptPackResolver. The ScriptExecutor is initialized with the NuGet references and the script packs. ExecuteScript() is called on the ScriptExecutor. The result is verified and logged if relevant.

This is solution that I released in version 0.4.0. Despite missing a few essential scriptcs.hosting features, like importing namespaces and reference local dependencies, I decided to release it anyway.

On of the key features of the upcoming 0.5.0 release is Mono support. I'd like to add the options to use the Mono compiler inside of the hosting pieces. During this work I ran into an issue with the way I wired up my dependencies. It was rather trivial to set an option for using the Mono compiler, and then replace it with the dependency to Roslyn. It worked so far that I could compile plain C#, just like the Roslyn compiler, but if I wanted to compile C# with some features that is not supported by Roslyn yet, like dynamic or async/await, the Mono compiler would throw me an error. At first I was convinced that this must be a scriptcs bug, and there called out for help in the scriptcs community. Once again, I got in contact with Glenn Block. So, one morning, we toke a one-to-one on Skype, were I showed Glenn my code and put him into my mindset of what I'd like to achieve. Glenn is a nice guy, so he said, this cool, but you're doing it wrong. So with Glenn looking me over my shoulder, I re-implemented the Execute() of my ScriptExecutor.

Actual Approach

Glenn told me that all my wiring using AutoFac wasn't necessary, there is already a built-in helper class for that. It's called ScriptServicesBuilder. What ScriptServicesBuilder does is wire up the dependencies for you. It then serves you a ScriptServices instance, which makes it trivial to override the dependencies.

I therefore added a small method to my ScriptExecutor class, which I borrowed some pieces from here:

private ScriptServices CreateScriptServices(bool useMono, bool useLogging)
{
    var console = new ScriptConsole();
    var configurator = new LoggerConfigurator(useLogging ? LogLevel.Debug : LogLevel.Info);
    configurator.Configure(console);
    var logger = configurator.GetLogger();
    var builder = new ScriptServicesBuilder(console, logger);

    if (useMono)
    {
        builder.ScriptEngine<MonoScriptEngine>();
    }
    else
    {
        builder.ScriptEngine<RoslynScriptEngine>();
    }

    builder.FileSystem<ScriptFileSystem>();
    return builder.Build();
}

I do some configuration of the console and the logger. The log level is set depending on whether the user would like some debugging output. Whether the user would like to use the Mono compiler, I override the ScriptEngine. Finally, I override the logical file system, which scriptcs uses as its environment. I override it with this:

/// <summary>
/// By default, the scriptcs.hosting inspects the bin folder for references.
/// </summary>
public class ScriptFileSystem : FileSystem
{
    public override string BinFolder
    {
        get { return AppDomain.CurrentDomain.BaseDirectory; }
    }
}

All this customization does is that it tells scriptcs that my dependencies are located in the same folder as the script is executed. Otherwise, I'd have to copy all my dependencies over to a \bin folder.

So after some iterations my Execute() method, ended up like this:

public void Execute(Script script)
{
    // set current dicrectory, import for NuGet.
    Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;

    var services = CreateScriptServices(script.UseMono, script.UseLogging);
    var scriptExecutor = services.Executor;
    var scriptPackResolver = services.ScriptPackResolver;
    services.InstallationProvider.Initialize();

    // prepare NuGet dependencies, download them if required
    var assemblyPaths = PreparePackages(services.PackageAssemblyResolver,
        services.PackageInstaller, PrepareAdditionalPackages(script.NuGetDependencies), script.LocalDependencies, services.Logger);

    scriptExecutor.Initialize(assemblyPaths, scriptPackResolver.GetPacks());
    scriptExecutor.ImportNamespaces(script.Namespaces);
    scriptExecutor.AddReferences(script.LocalDependencies);

    var scriptResult = scriptExecutor.ExecuteScript(script.ScriptContent, string.Empty);

    if (script.UseLogging && scriptResult != null)
        if (scriptResult.CompileExceptionInfo != null)
            if (scriptResult.CompileExceptionInfo.SourceException != null)
                services.Logger.Debug(scriptResult.CompileExceptionInfo.SourceException.Message);
    scriptExecutor.Terminate();
}

I get the scriptcs dependencies wired up and served with CreateScriptServices(). I pull out the ScriptExecutor and the ScriptPackResolver. One, important step, is to initialize the InstallationProvider. In my case, the InstallationProvider is a NuGetInstallationProvider. If you forget to initialize you are given a ArgumentNullException if you try to download a NuGet package with the PackageInstaller. I still have my PreparePackages() which looks like this. The functionality is the same, I just added some more logging and error handling.

I then initialize the ScriptExecutor with the path to the assemblies, and the resolved script packs. I import additional namespaces and adds a reference to some local assemblies if necessary.

Finally, I call ExecuteScript() on the ScriptExecutor. If we're using logging, the result, errors or exceptions are sent to the console.

My Execute() method now holds a lot more code, than in my initial attempt, but on the other hand I can save a bunch of code and complexity with this solution.

This, final solution, is how it is implemented in the upcoming scriptcs.rebus 0.5.0.

scriptcs in Sublime Text and Atom

2014-10-20T02:38:37+00:00

I really love the REPL in scriptcs, and feel comfortable using it. But sometimes, when writing larger scripts its just not a suitable tool. Then it is good that there are other, still lightweight, options out there.

In this post I'll show you how to setup Sublime Text and Atom to use scriptcs for script execution.

Sublime Text

Sublime Text has been my favorite text editor for a while, and I use every occasion I get to give it a shout, and hopefully I can convince more people to use it.

To setup using scriptcs in Sublime Text, you need to install the scriptcs plugin. This is done using the great Sublime Package Manager. The Sublime Package Manager is in it self an addon. So open the Sublime Text console, using Ctrl+´, and run this Powershell script. When you have installed the Sublime Package Manager, open it by using the Ctrl+Shift+P, type install and choose Package Control: Install Package. Now the repositories will be refreshed. Once ready, a dialog will list all available packages. Then type scriptcs, and press enter. The scriptcs package will now be installed.

When installed, all .csx-files will now have text highlighting and you can execute your scripts by pressing Ctrl+B.

SublimeREPL

I neat feature that Sublime Text has and which, not to my knowledge, Atom does not have is SublimeRepl or rather an alternative. SublimeREPL is a Sublime Text package which adds a REPL inside Sublime. This REPL is highly configurable, and can run an interpreter inside Sublime, including scriptcs. Again, open the Sublime Package Manager, using Ctrl+Shift+P, type install and chose Package Control: Install Package. Find SublimeREPL in the list and install it.

When installation is done, you can find the scriptcs REPL in Tools -> SublimeREPL -> ScriptCS.

Atom

The new kid on the block. It is a bit more cumbersome to get scriptcs set up in Atom. Firstly, you need to install the Atom Runner. You would either go through the Atom Package Manager GUI, which is found in the Settings tab (Ctrl-,) or take it from the command line like this

apm install atom-runner

To get C# highlighting in your scripts you'd also have to add an additional package

apm install language-csharp

Now we need to associate Atom with the .csx file extension. Open you local config file

Ctrl+Shift+P

This open the config file. Add the following to the config file

'runner':  
    'extensions':
        'csx': 'scriptcs'

Save the file using Ctrl+S. Now you can write your scripts, save them with the .csx file extension and run them using the Atom Runner

Ctrl+Shift+P

Press 'R' and select Runner: Run.

I hope this can help someone getting started using scriptcs. Throw a comment, or give me a shout on Twitter.

ScriptCs.Rebus Moving to scriptcs-contrib

2014-10-15T10:04:30+00:00

I've worked on ScriptCs.Rebus since the spring, and had a lot of fun. I have not received any feedback from users actually using it, so I'm basically coding in the dark. It's completely true, I've managed to sneak it in in some integration testing scenarios. During development of 0.4.0, I got in contact with Glenn Block, who guided me with the implementation of the hosting pieces. He also encourage me to move my GitHub repository to the scriptcs-contrib organization. If found this appealing, although it would mean that I would have to move it away from my own user. Guess it feels a bit like one of your kids moving away from home. It would certainly give the repository more attention, and potentially more users adn feedback. I would still have administrator rights and in full control, so why not.

I did some considering and after releasing 0.4.0, I decided to move it over. So its new home is here. I've renamed the project to align with the other projects in scriptcs-contrib.

ScriptCs.Rebus 0.4.0

2014-10-13T02:59:09+00:00

The last month or so I've been busy on putting the pieces together for the latest release of ScriptCs.Rebus. I'm very proud of what I managed to put into this release.

This is the fourth release of my little scripting tool, and this post will focus on what's new in version 0.4.0, so if your new to ScriptCs.Rebus, I urge you to read my other posts.

What's New

Some minor bug fixes, the major features of this release is support for Azure Service Bus and scripted host execution.

One other major change in this release is that I've split ScriptCs.Rebus into separate dependencies. This will be a breaking change for existing users, and you have my apologies for that. When adding Azure Service Bus, it occurred to me that it didn't make sense to distribute ScriptCs.Rebus with dependencies for all transport options, when you're only using a single one. So therefore from version 0.4.0 ScriptCs.Rebus spans the following NuGet packages:

- ScriptCs.Rebus
- ScriptCs.Rebus.RabbitMQ
- ScriptCs.Rebus.AzureServiceBus
- ScriptCs.Rebus.Hosting

Support for Azure Service Bus

To get started using Azure Service Bus, you need to install the script pack:

scriptcs -install ScriptCs.Rebus.AzureServiceBus

And you would also need to create a service bus on Azure.

As the addition of RabbitMQ in version 0.3.0, I've continued the original design for configuration:

Require<RebusScriptBus>()
    .ConfigureAzureBus("MyMessageQueue", "Endpoint=sb://someConnectionString")
    .Send<string>("Hello from Azure Service Bus")

A message containing a string is now sent to the Azure service bus specified in the connection string, and added to the queue given in the first parameter. The connectionstring must be the connectionstring of the service bus, and not the actual queue. Receiving a message follows the design of the MSMQ and RabbitMQ:

Require<RebusScriptBus>()
    .ConfigureAzureBus("MyMessageQueue", "Endpoint=sb://someConnectionString")
    .Receive<string>(x => Console.WriteLine(x))
    .Start()

Hosting

Now this a feature I'm really proud of. Hosting is a vital, yet powerful feature in ScriptCs. The idea is that you can host ScriptCs inside any standard .Net application and that way execute code inside the host. This gave me the idea to create a ScriptCs.Rebus hosting feature for executing scripts received over any of the support buses. I have been playing around with ScriptCs.Hosting before, but was pretty unsure were to start. I therefore got in contact with Glenn Block, with whom I had some discussions over the idea. The result is ScriptCs.Rebus.Hosting.

First of you need to reference the NuGet package from your application. Go to the package manager console:

 install-package ScriptCs.Rebus.Hosting

This will provide with a number of dependencies, but in essence it is the complete ScriptCs that you now have a reference to and can use to execute C# code. The pieces that ScriptCs.Rebus.Hosting delivers is a message handler capable of executing a script. It can even download and reference extra NuGet packages required by your script. I now this sounds strange and complex, but I believe I've developed a rather simple and powerful implementation.

There are two options to go for when you wanna execute scripts, received over any supported bus technology using Rebus, in your application.

Existing Rebus Infrastructure

If your application is already using one of the supported bus technologies with Rebus, just hook in the supplied message handler. How this is done, depends on how you have configured Rebus. But the ScriptHandler class implements the standard IHandleMessages<T> interface in Rebus. So all you need to do is register the message handler to the DI container you have configured for Rebus in your application.

No Rebus Infrastructure

If your application does not use any bus infrastructure and you would like to extend its functionality using scripts, you can get going using the following simple configuration:

var bus = new MsmqBus("MyMessageQueue");
bus.Container.Register(() => new ScriptHandler());
bus.Start();

That's it! Your application is now ready to receive scripts send over MSMQ. It is advisable to configure the bus in a bootstrapper or application entry point. The Start() can be deferred to other parts of the application.

Should you wanna go for RabbitMQ or Azure Service Bus, just change the first line. See the README. When using RabbitMQ or Azure Service Bus, you would need to reference either the ScriptCs.Rebus.RabbitMQ or ScriptCs.Rebus.AzureServiceBus script packs as well.

Sending A Script

Now that you have a script-aware application, lets start sending some scripts. You can send scripts from the source of your choice. You can go simple and send it from the ScriptCs REPL:

Require<RebusScriptBus>()
    .ConfigureBus("MyMessageQueue")
    .SendAScript("Console.WriteLine(\"Hello from the REPL!\")")

This would send this simple script to the host, which would then execute this. If the bus is not started in the hosting application, the script will wait in the queue, and be executed when the bus is started. Standard messaging stuff. You can also send a script from another application:

var bus = new MsmqBus("MyMessageQueue")
bus.SendAScript("Console.WriteLine(\"Hello from other application!\")")

Sometimes you just don't wanna write your scripts in the REPL or inline in the sending application. You can therefore create a script file, in your favorite editor, and send it for execution in the host. From the REPL this would look like this:

Require<RebusScriptBus>()
    .ConfigureBus("MyMessageQueue")
    .SendAScriptFile("someScriptFile.csx")

The script file will now be send over the bus and executed in the hosting application. You can do the same from another application.

Additional NuGet Packages

If executing C# scripts inside a host application cannot make your day, how about downloading and referencing additional NuGet packages inside your host application, and executing a script using them.

If your script is going to require additional NuGet packages, which is not already referenced by the host, you can supply them when sending the script:

.SendAScriptFile("someScriptFile.csx", "LiteGuard")

If the LiteGuard Nuget package is not already downloaded and referenced in the hosting application, ScriptCs.Rebus.Hosting will download and reference it, so you can use it your script. Using LiteGuard is just an example.

Please feel free to either give me a shout on Twitter or on GitHub with feedback.

Upcoming Software Architecture Open Space 2014

2014-09-29T04:42:36+00:00

This week I have the pleasure of attending the Software Architecture Open Space (SAOS14) conference. I attended this conference in 2012, when it was still located in Århus. At that time it was a two day open space session intensive conference, which was free to attend. And I loved it

Last year the conference shifted gear and turned into a payed event in Copenhagen. The remained the same, open space intensive sessions. Although now in more professional settings. In 2012 there were a number of attendees who didn't show up. This must have been related to that being a free event. So this year I expect everyone registered to show up.

This year I've been so fortunate to be able to participate in this great event. In 2012 this conference format exceeded my expectations, so I'm looking forward to some great discussions with other professionals sharing their experiences.

At the time of writing we're 53 registered for this event. I think this is way too low. I can recon a number of attendees who also participated in 2012, I'll argue that if you've once done this open space format, you'll return over and over again. You won't find any conference formats where you'll get so much take-away. If you're willing to. One of the very key characteristics of the attendees should be their willingness to share their experiences and, not least, be willing to listen to other attendees sharing their experiences.

This year there will be some more formal conference elements, such as a keynote. I'm exited about this, and looking forward to see if such an initiative should affect the open space discussions.

There are still some slots available, so if you have the time, and is in Copenhagen, you shouldn't miss this awesome event.

ScriptCs.Rebus 0.3.0

2014-06-13T02:27:00+00:00

Currently, ScriptCS.Rebus uses MSMQ as transport mechanism. In the latest release of ScriptCs.Rebus, I’ve included support for RabbitMQ and console logging.

RabbitMQ is a widely used and rock-solid messaging framework. In my original post, I outlined how to get started using ScriptCs and ScriptCs.Rebus in particular, I’ll therefore urge the reader to read that post prior to this one.

What’s New

Besides major refactorings and code clean-up, the two main features of 0.3.0 is support for RabbitMQ and console logging.

Support for RabbitMQ

I’ve been very trying to be very consistent with the original design, and therefore configuring ScriptCs.Rebus for RabbitMQ is very straightforward:

Require<RebusScriptBus>()
	.ConfigureRabbitBus("MyMessageQueue")
	.Send<string>("Foo")

This will configure the bus to use the default RabbitMQ port, amqp://localhost:5672, which requires a local server. This configuration is equivalent to using ScriptCs.Rebus with MSMQ, with additional RabbitMQ features. Usually, a remote server is used, and to supply a connectionstring, use the following configuration:

Require<RebusScriptBus>()
	.ConfigureRabbitBus("MyMessageQueue", "amqp://remoteserver")
	.Send<string>("Foo")

With this configuration the message of type String will be sent to the remote server. Likewise when you to need receive messages from the remote server, configuration follow the same setup as of the one from MSMQ:

Require<RebusScriptBus>()
	.ConfigureRabbitBus("MyMessageQueue", "ampq://remoteserver")
	.Receive<string>(x => Console.WriteLine(x))
	.Start()

Console Logging

Working with message busses can often be very complex and a blackbox. Since Rebus has a nice and very useful console logging, it makes so much sense to support this as an option for script authors. Console logging is available for both MSMQ and RabbitMQ busses. By default console logging is disabled. To enable console logging, just add UseLogging() to your configuration:

Require<RebusScriptBus>()
	.ConfigureBus("MyMessageQueue")
	.UseLogging()
	.Send<string>("Foo")

Now console logging is enabled and will output some nice logging like this:

Rebus.Configuration.RebusConfigurer DEBUG (): Defaulting to 'throwing endpoint mapper' - i.e. the bus will throw an exception when you send a message that is not explicitly routed
Rebus.Configuration.RebusConfigurer DEBUG (): Defaulting to in-memory saga persister (should probably not be used for real)
Rebus.Configuration.RebusConfigurer DEBUG (): Defaulting to in-memory subscription storage (should probably not be used for real)
Rebus.Bus.RebusBus INFO (): Rebus bus 1 created
Rebus.Bus.RebusBus INFO (): Using external timeout manager with input queue 'rebus.timeout'
Rebus.Bus.RebusBus INFO (): Initializing bus with 1 workers
Rebus.Bus.Worker INFO (): Worker Rebus 1 worker 1 created and inner thread started
Rebus.Bus.Worker INFO (): Starting worker thread Rebus 1 worker 1
Rebus.Bus.RebusBus INFO (): Bus started
Sending message of type String...
Rebus.Logging.MessageLogger DEBUG (): Sending Foo to MyMessageQueue
... message sent.

That’s it for 0.3.0, get it, use it, and let me know what you think of it.

Introducing ScriptCs.Rebus

2014-05-26T11:45:50+00:00

In a recent blog post I introduced the reader to the world of scripting with C# using ScriptCs. I really love the idea of encapsulating boiler-plate code into a script pack, and be able to consume larger frameworks from simple scripts. One of my favorite frameworks is Rebus. Rebus is this lean and very simple service bus. It is founded and coordinated by my good friend Mogens Heller Grabe.

Why?

Well, why not? Rebus is a simple, yet powerful framework for messaging, it is obvious for me to make Rebus the messaging engine for ScriptCs. On the current work project we use Rebus extensively, and to provide some sample messages and for testing purposes, we’ve so far used small console applications. It is my intend to switch over and use ScriptCs.Rebus from now on. With scripting possibilities for messaging I can imagine larger test scenarios, and stress-testing.

Basic Usage from REPL

I’d refer to the readme on GitHub for installation guidelines.

To enter the REPL, run scriptcs. Send a message of type string to MyMessageQueue:

Require<RebusScriptBus>()
    .ConfigureBus("MyMessageQueue")
    .Send<string>("My first scripted message!")

Now open another command prompt or use the same, and enter the following to receive the message of type string from MyMessageQueue:

Require<RebusScriptBus>()
    .ConfigureBus("MyMessageQueue")
    .Receive<string>(x => Console.WriteLine(x))
    .Start()

The command prompt should output the following:

From MyMessageQueue > My first scripted message!

Basic Usage from Script

The examples from above apply to scripts. Put the send and receive code into two .csx files, lets call them send.csx and receive.csx, and execute them by typing the following from a command prompt:

scriptcs send.csx and

scriptcs receive.csx

In the \samples folder there is some samples to get you started.

Advanced Usage

At this point you should be able to apply these more advanced usages to both the REPL and from scripts.

Custom Types

It is possible to use custom types in your messages. Consider the following class:

public class Message { public string Content { get; set; } }

You enter this class definition in the REPL or create a message.csx script file. If defined in a script file, load this class definition into your script by using #load keyword,

#load "message.csx"

Now you can send and receive messages of this type by using the following syntax:

Require<RebusScriptBus>()
    .ConfigureBus("MyMessageQueue")
    .Send<Message>(new Message {Content = "Hello from custom type!"})

and

Require<RebusScriptBus>()
    .ConfigureBus("MyMessageQueue")
    .Receive<Messge>(x => Console.WriteLine(x.Content))
    .Start()

This should output From MyMessageQueue > Hello from custom type.

Multiple Handlers

In some cases you might be expecting to handle different kinds of messages. This can be achieved by adding multiple receive commands fluently:

Require<RebusScriptBus>()
    .ConfigureBus("MyMessageQueue")
    .Receive<string>(x => Console.WriteLine(x))
    .Receive<Message>(x => Console.WriteLine(x.Content))
    .Start()

Applying multiple handlers of the same type, will give the possibility to handle message of the same type in different ways.

Future Directions

This is only the first revision of ScriptCs.Rebus, I’ll continue to explore new possibilities with building messaging infrastructure using scripts. I’ve got RabbitMQ and Azure Service Bus aligned in the pipeline.

Get out there and try it out, throw me a comment or a pull request on GitHub.

Danish Developer Conference 2014 - Aftermath

2014-05-01T03:13:00+00:00

Yesterday I had the pleasure of attending the annual Danish Developer Conference. And it was actually a pleasure, I’m no just being polite here.

When you attend a conference like this, you put down an agenda of expected sessions. You set certain expectations to these sessions. Some times these sessions fulfill, even exceeds, your expectations and other times they barely hit an acceptable level. Generally I think that Microsoft should be more ambitious and make it an international conference, where well-known international speakers could suggest sessions and make it last a couple of days. The Microsoft event organizers know how to put together a well-organized conference, the drinks and food was great. The venue this year was in Aarhus, the past two years have been in Horsens. I think the venue in Aarhus is way better than in Horsens. I do also think that Microsoft had hired a company to help-out with the wiring and microphones, it work well and had a professional touch. Although the screen went out during the keynote. So, all in all an overall nice conference, although I would recommend opening for abstracts and make it international.

It was a very inspirational keynote by Preben Mejer. He gave praise(!) to Microsoft for choosing a new CEO with the right attitude, and backed by Bill Gates. He told about the great potential on which Microsoft sits, and continued his keynote into an outlining of future trends in computing. This keynote made my expectations to a speaker like Preben Mejer.

The session speakers was a mix of Microsoft interns, and external developers and consultants. My first session was with Thomas Jespersen about Spiir's experiences with the Azure cloud platform. There were several take-aways from this session, that could be useful in future projects deployed on Azure. Later I saw Christian Holm Nielsen, make a session about how AngularJS and ASP.NET can fit nicely together. Unfortunately it was a very PowerPoint heavy presentation, I could have wished for some more demos using AngularJS together with Web API. It seemed like Christian, was trying to cover far more topics, than time allowed, so each topic was briefly touched. When this is said, I got some nice hints and leads on AngularJS.

During lunch, Telerik gave a short presentation of their Telerik Platform, and specifically AppBuilder. AppBuilder is using KendoUI Mobile for developing cross-platform applications. This is not the native way as Xamarin does, but the HTML5 approach. I have some experience using KendoUI for web development, and AppBuilder really just wraps these into deployable apps for either Android or iOS. AppBuilder has a number of nice testing and emulator features. I had a short chat with Sebastian Witalec from Telerik about KendoUI and AppBuilder. He gave me a 6 month license for AppBuilder, so I might end up using it. I didn't plan on going to any lunch sessions, but it sounded like a relevant topic, and it turned out to be really fruitful. After lunch, I went to hear about the latest news from the Azure team. Henrik Westergaard Hansen gave a short and brief overview of the latest features. He showed of some great demos. For me the two biggest news was remote debugging of a website and live streaming of logging information from a production site.

I had some high expectations to Christian Helle’s session cross-platform development using Xamarin. And Christian did not let me down. He gave a nice and clean session, where all the business and sales stuff was cut out. It was a cool presentation, developer to developer, honest about pros and cons using Xamarin for cross-platform development. This session was the highlight of the day. He inspired me to once again start using Xamarin. In the last session of the day I had planned on seeing Mads Kristensen, doing a presentation on building Visual Studio extensions. After some consideration, I changed plans and went to see Erik Ejlskov Jensen’s session on Entity Framework 6.x (EF). I’ve used EF some years back, and I recently read a great blog post by Jimmy Bogard, on why considers EF6 a better option than NHibernate, so I thought I might get a brush-up on the latest EF news. It was a nice session, with almost too many slides, but Erik managed to lift the session with concise and simple demos.

All in all, it was a pleasure to attend DDC this year, although I think they should be more ambitious.

Did you attend DDC14? Throw me a comment and let me know what you think.

Danish Developer Conference 2014

2014-04-22T03:40:55+00:00

Once again Microsoft has arranged the yearly Danish Developer Conference (DDC). Previous years the venue has been Horsens, but this year they moved the conference to Aarhus. The past two years they have also had a venue in Copenhagen, to attract the capitals developer force, but this year they seem to focus on the mainland developers(!). One of things that strike me about this conference is that it is a purely Danish conference, even the website is Danish only. I really don’t get this, it seems like Microsoft feels obligated to arrange this local conference, but does not do much more than absolutely necessary. I get the point of focusing on and promoting the Danish developer scene, but to me it seems limiting that this conference lacks international inspiration. On another note, it seems weird to me that there is not an official call for papers (CFP). All speakers are hand-picked by the Microsoft conference committee. I get the commercial stuff, but why not let the masses propose sessions? There are tons of hobby projects in the Danish community, promoting and facilitating Microsoft tools, that would provide DDC with some dedicated flavor. And that really deserves some public attention.

Again this year, I’ll attend the conference, and again my employer is sponsoring the event. This post will focus on my expectations.

At this years Build conference, Microsoft as a company revealed a number of new initiatives. In his keynote, Preben Meijer will enlighten us with details of Microsoft's new strategy. The first session to attend is a tough call, either hear Mads Kristensen on modern web development with Visual Studio or hear Thomas Jespersen’s talk on Spiir’s Azure experiences. At the time of writing I tend to attend Thomas’ talk, since Mads’ is available on Channel 9.

Lately it was announced that my preferred SPA framework, DurandalJS, is going to be merged with AngalurJS. So to me it seems that AngularJS is the de-facto standard for SPA frameworks, I’ll therefore attend my former colleague Christian Holm Nielsen’s talk on AngularJS and ASP.NET. After the lunch break I’ll attend Henrik Westergaard Hansen’s talk on new features in Azure. The Azure team has a very rapid development cycle, so there is always some new features to catch up with. Should be a great session. The following session slot is again a tough call, either the SignalR session or the cross-platform talk with Xamarin and Visual Studio. This is two great technologies, and I would prefer to attend them both. Currently, I tend to attend the Xamarin talk, since I really need a kick to get started with Xamarin. I have the intentions and did some spiking, but this session might get me in the right direction. I have done some SignalR development before, so I do not need an introduction, but it would be great to get some tips and tricks. I'll stick to the Xamarin session for now.

The last session slot of this one-day conference is, in my opinion, the one with the least attractive sessions. I'll either attend the Entity Framework session or Mads Kristensen's session on developing Visual Studio extensions. I have no experience in extensibility, and so-far no intentions of writing any extensions to Visual Studio, but Mads might inspire me. I have previously been using Entity Framework, so it might be great to get brush-up on the latest. I guess I'll make a decision on the day.

This is my DDC 14 schedule as of writing. My experience is that I might change my mind on the day.

If you plan to attend DDC 14, don’t hesitate to say hi, much of attending a conference is to network.

The ScriptCs 101

2014-04-08T03:54:00+00:00

C# is an awesome language. In this post I’ll write about C# and scripting. To get you into the right context, I’ll kick-off with my personal language journey, just to set the scene, and then I’ll introduce ScriptCs.

Introduction

I initially came on to C# back in 2005, when C# 2.0 was the latest. Many features that we take for granted in C# 5, was not included, such as generics, static classes, private setters, iterators, etc. I came from Java, so the syntax seemed straightforward. At the same time, we used some Ruby scripts for building assemblies to different hardware platforms. In 2008 I switched court and started doing some C++ on an embedded Linux platform. Some developers did their development in Vim, but the majority used the Eclipse IDE, including me. It seemed natural coming from Visual Studio. To build the assemblies we used a home-grown build system written in Python. Since 2010, I came back to C#, and it is still my language of choice, although I’m experimenting with JavaScript.

Heavy Development Experience

Over the years it has seemed to me that even the most simple development task feels so heavy with C#. And its not the language, it’s the complete development experience. It kind of feels sad. Even for the simplest console app, we have to open Visual Studio, create a project, select project type, etc. Click, click, click. We really just want to play around with some new feature, or we might have crafted some brilliant idea and want to make a small spike. We get tired before we ever had the chance to write a line of code. Many automation tasks are solved with a small console app. We could use another editor and utilize the CSC compiler, but you’ll soon find out that it is only for basic stuff, there is some difficulties referencing dlls and such.

In other scripting languages such as Ruby, Python or NodeJS, there is more lightweight options available. You can pick you favorite editor, and you’re productive. Of course, these are interpreted language, you would argue. But taste that development experience. Many of the development environments have a REPL (read-evaluate-print-loop). A REPL is a small, interactive programming environment. Just run a console and issue commands. The NodeJS development experience there is no IDE required, no project, a minimum install and everything else is packages. In NodeJS there is NPM. The Node Package Modules provides all the modules for easing the development experience.

So how about C#?

There is an excellent package manager for.Net and C#, its called Nuget. It kind of works the same way as in NodeJS, since it does not need to be installed in a global directory, but to specific projects. So Nuget gets us part of way, how about authoring C#? I’d like to be able to use my favorite text editor. On the .Net platform we have Roslyn.

Roslyn

This is not a post on Roslyn, so if you can skip this section, if you know what I’m talking about. Roslyn is a compiler-as-a-service. It was recently released under less-restrictive Apache License. So it is possible to use Roslyn in any project you find it useful. It is shipped as a library on Nuget, and there is no requirement to use Visual Studio. Any application can use Roslyn to compile C#. You can add reference using the r# keyword. There is no notion of namespaces, so its kind of a loose script. Everything is compiled into a wrapper class. Also, Roslyn does not support multiple files, everything goes into a single file. Roslyn has no notion of packages, so we’re missing a link between Nuget and Roslyn. This is where ScriptCs comes in, it brings the last mile of what Roslyn brings to the table

ScriptCs

So what is this ScriptCs? ScriptCs is pure C# code, without IDE requirement, without a project, without classes, without designer files, without dlls, and without compiling. It has the power of C# and Nuget.

Installation

Releases and nightly builds should be installed using Chocolatey. If you, for some reason, haven’t heard of Chocolatey before, you’re in for a treat. Chocolatey is like Nuget for applications. If you’re familiar with apt-get on Linux, you know what I’m talking about. To install Chocolatey run the following command in a command prompt:

C:\> @powershell -NoProfile -ExecutionPolicy unrestricted -Command "iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))" && SET PATH=%PATH%;%systemdrive%\chocolatey\bin

Once Chocolatey is installed, the latest and stable version is installed from command prompt:

cinst scriptcs

Chocolatey will update your PATH environment variable. To update at a later point in time, just:

cup scriptcs

Writing Scripts

Now we’re ready to write some C# scripts. You can use an editor of choice, my preferred editor at the moment is Sublime Text. To write the traditional Hello World, we create a file in Sublime called ‘start.csx’, inside we write a single line:

Now save the file and open a command prompt. Execute the following command:

scriptcs start.csx

The command prompt should write, ‘Hello from ScriptCs!’. This is much like NodeJS or Ruby, this very loose scripting experience. Now lets wrap this into a method and call the method:

Notice that order doesn’t matter in these loose scripts, and we still haven’t defined any class. Executing this script should output the same as before. Also, please notice the text-highlighting, there is a ScriptCs plugin for Sublime Text.

Now let’s define a class:

We still get the same output. Notice how fast it is compiled and executed, really powerful stuff. When an error should occur in the script, you’ll get the same error as in Visual Studio. If you want to reference other any .dll, you can use the ‘#r’ keyword, like this:

This assumes that the assembly is in the GAC, or in a bin folder next to your script. In many console applications we often want to receive arguments from the console, this can be handle by inspecting the Env.ScriptArgs collection like this:

From the script command line you pass in your arguments like this:

scriptcs start.csx -- "Hello from ScriptCs!"

Your scripts might start to grow, and you want to reuse some script parts. This can be achieved using the ‘#load’ keyword. Reference the scripts you want to include in script like this:

#load "messenger.csx"

Referencing other scripts is recursive, other scripts can have other scripts and so forth. If multiple scripts references the same script, it will reconcile and make sure it only points to the same script once.

The REPL

Like NodeJS, ScriptCs also features a REPL. From the command line you start the REPL by just typing ‘scriptcs’ without any arguments. In REPL you can write the same code as we did above using script files. You can reference other assemblies using the ‘#r’ keyword and reference script files using the ‘#load’ keyword. It is possible to write multi-line statements, where symbols like ‘{’ makes it possible to add more lines until the statement is closed by a pairing ‘}’.

The REPL is very useful for quickly experimenting with some C# code, without any IDE or script file. This is probably the shortest path to a C# scratch pad you’ll see around.

Debugging

Scripts are cool, but when apps get sophisticated debugging is essential. It is possible to debug your scripts, but currently quite cumbersome. IT requires you to install the Visual Studio 2012 SDK and the Roslyn. See this guide on debugging.

Packages

As stated above, ScriptCs it meant as a tool to close the gap between Roslyn and Nuget, how is the achieved. By using the ‘install’ command, we can utilize the Nuget api. Nuget has its own Nuget packages, these can be used to call out to the Nuget api. In the example below, we use the ‘install’ command to retrieve MongoDb from Nuget:

scriptcs -install mongodb INFO: Installing packages... INFO: Installed: mongodb INFO: Installation completed successfully. INFO: Saving packages in packages.config... INFO: Createing packages.config INFO: Added Mongodb (v.1.7.1.4791, .NET 4.0) to packages.config INFO: Successfully updated packages.config.

This is just an example, you can retrieve any package available on Nuget using the ‘install’ command. Packages are stored in the Packages folder, such as if it had been a regular Nuget download, and if Packages.config does not exist it will be created. If you distribute you scripts, you can restore all packages using the ‘install’ command, all you need is the Packages.config.

Often when using the Nuget package as-is, requires a lot of boilerplate coding, which is rather cumbersome in scripts. This is great if you have Visual Studio, but in any other editor or in the REPL, it can be hard to remember namespaces, parameters, methods, etc. Such issues has also been taken care of in the ScriptCs environment. Your friend is called script packs.

Script Packs

In NodeJS you can require a module, this gives you an object, with functions attached that leads you wherever you need to go. You don’t need to remember namespaces or new up objects. All you have to do is make a ‘require’. Script packs is one of the great pieces inherited from NodeJS. Script packs makes APIs much easier to consume from a script. They wrap existing frameworks and provide nicer interaction. Script packs can facilitate injecting using statements and/or provide you with an object to work with.

One very brilliant example of a script pack is the scriptcs.nancy script pack. Its created by Adam Ralph, member of the ScriptCs core team. It’s a script pack to make it easier to use the Nancy web framework from a script file. Script packs are installed as packages using the ‘install’ command. Since a script pack is itself a package it specifies all its requirements. So it might need to retrieve other Nuget packages. Lets install the scriptcs.nancy script pack:

scriptcs -install scriptcs.nancy

Thats it. Now we can start using the Nancy web framework from script, like this:

Require<NancyPack>().Get("/", _ => "Hello world").Host();

Save the script, and execute. Now go to your favorite browser, and hit http://localhost:8888. It should write out ‘Hello world’. The Require<> keyword is ScriptCs specific, and not part of Roslyn. Script packs gives you time to focus on the code you really like to write, and not all the boilerplate and setup.

There is a master list of script packs on the ScriptCs GitHub wiki.

Hosting

One last topic I’d like to touch in this post is hosting. ScriptCs has a very powerful hosting layer. This allows you to execute scripts in different environments. Now the examples of hosting is pretty complex, and there is some very great blog posts on these matters out there already. A great example of hosting a script inside Glimpse is written by Filip Wojcieszyn, one of the founders and coordinators of ScriptCs. Other examples can be found in ScriptCs samples repository on GitHub. I would recommend the WebApi hosting sample.

Conclusion

With this blog post I hope I was able to inspire you to take a closer look at ScriptCs and find some useful applications. Please throw me some comments of where you could think of using ScriptCs.

Warm Crocodile Developer Conference 2015

2014-04-01T07:28:00+00:00

Disclaimer: This is not an Aprils fool.

Yesterday I had the pleasure of being announced as speaker for the Warm Crocodile Developer Conference 2015 in Copenhagen. This will be my first major speaker appearance, and I’m very exited and pleased to be given this opportunity.

The session will cover some general unit testing approaches, and specifically how AutoFixture can facilitate clean and maintainable unit tests. I will introduce AutoFixture at a beginner’s level, moving toward more advanced applications, which even experienced users might find applicable. The title of the session will be “AutoFixture – From Basics to Nifties”.

Hope to see you next year!

Warm Croc Conference – Debriefing

2014-01-17T11:04:14+00:00

So for the last two days, I had the pleasure of being an attendee at Warm Crocodile Developers Conference. It has indeed been two amazing days. There were a lot new impressions and new friends. In my last post I outlined my expectations to the conference. In this blog post I’ll provide an overview of my take-aways and general impression of the conference.

I believe that I had set myself some pretty high expectations to the conference, with a program like the one this year. It did indeed fulfill my expectations. We were 9 in total going to the conference from d60. We had a really great time, both during, and in evenings. It was great to socialize with your co-workers under different circumstances. Besides having to hang out your co-workers, I also spend many hours talking to a number of the speakers from the conference. It is such a great attitude in our industry, that no matter who or where you are, gurus from around the world take time to talk with you. On the first night I was hanging out with Maarten Balliauw, Jimmy Bogard, Justin Rusbatch, Greg Young, and Filip Wojcieszyn.

So, on day 1, I had the pleasure of hearing Mark Seemann give his thoughts on how to stay in flow, meaning that you forget about time and place. He proposed a number of approaches to avoid interruptions and stay in flow. You could wear headphones, most developers already does this, but you’ll not be able to communicate with others.. Use a distributed version control system, like Git, which makes you less dependent on the work of co-workers. Use a smaller screen for development. His argument was that instead of having a ‘wall’ of screens, only using the laptop screen would make you less prone to interruptions. He also pointed out that having a smaller screen, would make write better code, due to the limit width of the screen. Working from home is also a great way to avoid getting interrupted by random questions from co-workers. Reflecting on his experiences with this, I felt that I need to try some of his recommendations. I do wear headphones, use Git and work from home once a week, but I’m guilty of using 3 large LCDs in office. I’m going to try to just use my laptop for development.

Another highlight from day 1 was ScriptCS. Filip Wojcieszyn did an awesome session. Starting out pretty simple, and ending with some mind-blowing demos on the capabilities of ScriptCS. The overall idea of releasing C# from Visual Studio, only using plain script files to get things done. Using your C# skills to write scripts like the ones you can with PowerShell, is pretty intriguing. ScriptCS is definitely something I’ll begin to play with soon.

On the second day, for me the key take-aways was Scott Hanselman, Paul Stack, and Rob Ashton. Hanselman gave a great talk on how to use your C# skills on multiple platforms, like iOS and Andoid. By using Xamarin tools we re-use more than 90% the code. Paul introduced me to a open-source tool called Vagrant. Vagrant is tool a for orchestrating and building development environments. It makes it possible for developers to deploy the exact same environment as in production. Experiment with it and throw it away afterwards. You can also spin an environment up, run your tests and shut it down again.

Rob Ashton gave the last session for me. It was a very personal session on his endeavors the last 15 months. He quit his job from one day to the other, and wrote a blog post saying that he wanted to work for free if he was given roof over his head. So he sold almost all of his belongings and travelled the world. This has given him trip around the world working in different environments with different languages, always learning something new. In the session he outlined a number take-aways from his endeavors which can be related to software. It was a different kind of session, and very personal. Its not the kind of session you get the chance to hear that often.

I think that the conference committee had put together a very compact and inspirational program this year. There were slots were I had to choose between several options and other slots where nothing could really excite me.

A lot of things has to fit together when arranging such a large conference. And there were some small adjustments during the conference which can be improved. Registration was a chaotic experience, there were a long line to get in, and when we finally got in, there were not badges for all, so the majority of the attendees had to write their own badge. Some of us didn’t get the armband or sticker, which should give us access to the conference dinner and party. During lunch on the first day, there were not enough table space for all. This was improved on the second day, where more tables were bought in.

All-in-all a great conference. I got away with a lot of personal and professional experiences. I managed to get around my network and even expand it. Both the conference dinner and party was held in Nørrebro Bryghus. It was a great venue for arrangements like this. Although, it was kind of disappointing to see the low turn-out at the conference party. It seemed like most attendees had left town already. Big thanks to Daniel Frost for setting up the conference, I had a blast.

Warm Croc Conference – Expectations

2014-01-07T18:29:50+00:00

I’ve been so fortunate to receive a ticket for the Warm Crocodile Developer Conference in Copenhagen from my employer d60. The conference is set on January 15th and 16th. The conference is probably the most attractive conference on Danish soil, with respect to the line-up of speakers. To name a few, Scott Hanselman, Udi Dahan, and Greg Young. In this post I’ll outline some of my expectations and session most-goes.

My employer is partnering with Microsoft on this conference, this means that I’ll be responsible for sharing my thoughts on the company’s Twitter and Facebook account. I did some of this during last years Danish Developer Conference as well. I’m planning on sharing my thoughts on my blog as well. The co-workers of mine who is also participating, either as attendees or speakers, will do sharing a larger hotel condor. We’re planning on setting up some hacking and coding during the late nights of the conference. So I’m expecting a lot of socializing with my colleagues. Besides these late night sessions, the conference will hold both a conference dinner and conference party, were I’ll be socializing with other attendees and speakers.

The fact that Scott Hanselman is speaking, is major asset of the conference. Since the first time I heard Scott talk, back in 2008 at PDC, he keeps giving some awesome talks. No matter the subject, you’ll get away with something. Therefore I’ll prioritize his talks. He’ll be giving two talks and give the opening keynote.

Mark Seemann, a Danish pro developer and architect, known for his thoughts on TDD and Dependency Injection. He wrote an award-winning book, Dependency Injection in .Net, which I have recommended several times on this blog. Over the past few years he has improved his speaker skills, and now gives some great talks. He is very passionate about software craftsmanship and SOLID principles, almost religiously. He’ll be giving a productivity talk, which I expects a lot from.

My first software conference was back in 2006, which was the OOPSLA conference, held in Portland, OR, in 2006. The OOPSLA conference is an annual ACM research conference. Among the abstract talks there was a guy named Erik Meijer from Microsoft Research. This guy, always wearing a bright and colorful shirt, gave an introduction to LINQ. A great talk, but also very abstract and complex. Today, LINQ is vital tool in every .Net developers toolbox. I’m looking forward meeting Erik again, and hear what he is up to these days. He gives a a keynote on the second of the conference, and some sessions with promising titles.

JetBrains Evangelist, Maarten Balliauw, is a Microsoft Azure MVP and will show-off some promising Azure stuff. Maarten has received praise for his talks, so I’m looking forward.

The Roslyn project has been ongoing for some time now, a CTP has been released, but I still need to see and grasp the ideas and application of Roslyn. Justin Rusbatch is a dedicated OSS developer and heavily involved in the ScriptCS project, so I will therefore attend Justin’s session on Roslyn, which ScriptCS is dependent on. Besides his talk I’m looking forward to have a chat with him. Filip Wojcieszyn, ASP.NET MVP, known for doing cool stuff with Web API, is also a coordinator on the ScriptCS project. He will give an entire session on ScriptCS, which I look forward to. I puzzle with an idea of introducing ScriptCS on a current project I’m working on.

Back in 2011 I attended Udi Dahan’s Advanced Distributed Systems Design with SOA course. Which was a great experience. Udi is an extremely talented instructor, and kept focus the entire week of the course. When it comes to messaging infrastructure and loosely-coupled architectures, Udi is great resource. He is always well-prepared for his sessions and comes with a message for the audience.

There will be several slots during the conference where I will have a hard time to decide which session to attend. These slots are perfect opportunities to hang out with industry experts and former colleagues.

Conferences like this is a great chance to meet some of the gurus in the industry. I have a semi-agreement with Maarten Balliauw, to bring some of his Belgian home-brew of beer. Oh, and he recently released a Glimpse plugin for Azure, which I hope he can demo for me.

All social activities during the conference will be held at Nørrebro Bryghus. This brewery makes great beer, and as a beer lover I anticipate some great hours.

Assert.Throws<> Over ExpectedException

2013-10-09T02:39:36+00:00

Writing unit tests that expects a given type of exception under given circumstances is essential for any test suite. Although it is useful to use the correct assertion types when testing for exceptions. In this post I will provide some guidance on why to use Assert.Throws<>() instead of ExpectedException.

Using the ExpectedException:

///<summary>
/// Testing exception handling
///</summary>
[Test]
[ExpectedException(typeof(ArgumentNullException))]
publicvoid WhateverTestName()
{
    // Arrange
    var sut = newSystemUnderTest();
    // Act
    // Assert
    sut.MethodThatThrowsEception();
}

In the above example whenever / wherever an exception of the given type is thrown inside the test, the test is considered passed.

A refactored example:

///<summary>
/// Testing exception handling
///</summary>
[Test]
publicvoid WhateverTestName()
{
    // Arrange
    var sut = newSystemUnderTest();
    // Act
    // Assert
    Assert.Throws<ArgumentNullException>(() => sut.MethodThatThrowsEception());
}

Now, instead of using the ExpectedException, I use Assert.Throws<>(). This provides a number of benefits / advantages:

Readability
- The test is now more readable, the reader is not in doubt of where in the code the exception is expected to be thrown. Furthermore, the ExpectedException attribute is easily overseen, which makes it difficult to understand what the intent of the test is.
Multiple conditions
- It is possible to test other conditions. Using the ExpectedException you cannot test anything else than the whether the exception is thrown.
Possible false expectation
- Setting the ExpectedException on a test case, makes it open to be passed whenever an exception of the given type is thrown inside the test. This could lead to some serious and unforeseen side-effects.

NUnit Support for AutoFixture

2013-10-03T12:28:58+00:00

For a more general introduction to AutoFixture, see my previous post.

For a long time it has been an xUnit exclusive to utilize AutoData in your test suites. The extensibility model of NUnit, made the migration to NUnit cumbersome, to say the least. Recently, Gert Jansen van Rensburg, made the first serious attempt to solve this. Having followed his battles on GitHub, he released the first version of the AutoFixture.NUnit2 NuGet package.

Although installation and setup is not at smooth as with xUnit, the power of this extension is without question. This post provides a short setup guide on how to install and configure this to work on both local dev machines as well as on TeamCity. The challenge with the extensibility model of NUnit is the distribution of the Addin, the actual plugin or extension to NUnit. This .dll has to be present in the bin\addins folder of NUnit. This is not preferable in a larger multi dev environment, therefore an alternative approach is proposed.

Installation

Go to your NuGet Package Manager, and Install-Package AutoFixture.NUnit2

If you have any previous version of AutoFixture installed it will be updated to the latest.

And Install-Package NUnit.Runners
Make a manual reference to tools\lib\nunit.core.interfaces.dll, which resides in your packages folder under NUnit.Runners.
The installation of the AutoFixture.NUnit2 package has inserted this line in your AssemblyInfo.cs-file: [assembly: NUnit.Framework.RequiredAddinPloeh.AutoFixture.NUnit2.Addins.Constants.AutoDataExtension)]

Remove this for now.

Now everything is installed and ready to go, except that we need to add the NUnit Addin to the test assembly. I know this is cumbersome, and a bitter pill to swallow. As mentioned above, copying the Ploeh.AutoFixture.NUnit2.Addins.dll-file from the packages folder to your unit test runners bin\addins folder:

NUnit: C:\Program Files (x86)\NUnit 2.6.2\bin\addins
R#: C:\Program Files (x86)\JetBrains\ReSharper\v8.0\Bin\addins

As proposed here, I could also create a new class, which would inherit the Addin, and add this to the test assembly, but in my test setup I found a better spot.

Setup

Usually I setup my test fixtures using a base class, which among other things holds my AutoFixture configurations, a common setup could look like this:

public class TestBase
{
    protected IFixture Fixture;
    protected GuardClauseAssertion GuardClauseAssertion;
    protected WritablePropertyAssertion WritablePropertyAssertion;
 
    protected void Setup()
    {
        Fixture = new Fixture().Customize(new AutoMoqCustomization());
 
        GuardClauseAssertion = new GuardClauseAssertion(Fixture);
        WritablePropertyAssertion = new WritablePropertyAssertion(Fixture);
    }
}

Now this also makes it a perfect spot for my NUnit Addin class, which I’ll include by inheritance:

using NUnit.Core.Extensibility;
[NUnitAddin]
public class TestBase : Ploeh.AutoFixture.NUnit2.Addins.Addin
{
    protected IFixture Fixture;
    protected GuardClauseAssertion GuardClauseAssertion;
    protected WritablePropertyAssertion WritablePropertyAssertion;
 
    protected void Setup()
    {
        Fixture = new Fixture().Customize(new AutoMoqCustomization());
 
        GuardClauseAssertion = new GuardClauseAssertion(Fixture);
        WritablePropertyAssertion = new WritablePropertyAssertion(Fixture);
    }
}

So adding the NUnitAddin attribute and inheriting the Ploeh.AutoFixture.NUnit2.Addins.Addin class, I don’t have to copy the addin .dll to the approriate bin\addins folder. Please note the using statement. This way it is by far easier to setup and distribute in the large developer environment. Since also works with TeamCity, otherwise you would have to setup your NUnit Test Launcher on TeamCity to locate the addin, not advisable and a poorly documented approach.

Usage

With all these efforts behind us, we can now easily auto-generate test data via parameters, such as this:

[Test, AutoData]
public void WhateverTestName(int foo, string baa)
{
    // Arrange
 
    // Act
 
    // Assert
}

In this test case foo and baa will be assigned auto-generate values by AutoFixture. Now there is much more in the box. So far, the NUnit TestCase attribute have had a rather sparse set of allowed types, such as ints, strings, bool, etc. With AutoData it is now possible auto-generate types as decimal, and even complex types:

[Test, AutoData]
public void WhateverTestName(decimal foo, MyClass sut)
{
    // Arrange
 
    // Act
 
    // Assert
}

This is all great and awesome, but wait there is some minors that also might come in handy.

You might have some test scenarios where you would still like to supply your own test data. This will work great along AutoData:

[Test, AutoData]
[TestCase(5, "Some String")]
public void WhateverTestName(int foo, string baa)
{
    // Arrange
 
    // Act
 
    // Assert
}

This will generate two test cases, the first one with auto-generated test data from AutoFixture, and the second one with the test data from the TestCase attribute. Note, that the types must be allowed by the TestCase attribute.

Lets consider a more advanced scenario. I have previously described how to use AutoFixture as an auto-mocking container. This is how we would auto-generate and freeze our dependencies using AutoData:

[Test, AutoData]
public void WhateverTestName([Frozen]Mock<IService1> service1Mock, 
    [Frozen]Mock<IService2> service2Mock, 
    MyClass sut)
{
    // Arrange
 
    // Act
 
    // Assert
}

In this test case we let AutoFixture freeze the dependencies that I would like to setup expectations for, and AutoFixture will the inject them during the creation of the MyClass sut.

These are some of the great new possibilities of the latest extension to AutoFixture, you can probably come up with other awesome scenarios.

Finally, I must send all credits for the extension to Gert Jansen van Rensburg. Read his blog and follow him on Twitter.

Easy Property Notification Verification in MVVM

2013-09-25T11:09:57+00:00

Currently I’m doing a lot of WPF, we’re profound users of the MVVM pattern. I therefore often find myself writing a lot of unit tests for viewmodels. A, or maybe the, key feature of the MVVM pattern is the property binding between the view and the viewmodel. Once assigned a value to a property, the viewmodel notifies the view, who updates the view accordingly. A viewmodel might have a significant amount of properties who can notify the view with updates, therefore I’ve implemented two small extension methods for this purpose:

public static class NotifyPropertyChanged
{
    public static NotifyExpectation<T>
        ShouldNotifyOn<T, TProperty>(this T owner,
        Expression<Func<T, TProperty>> propertyPicker)
        where T : INotifyPropertyChanged
    {
        return CreateExpectation(owner,
            propertyPicker, true);
    }
 
    public static NotifyExpectation<T>
        ShouldNotNotifyOn<T, TProperty>(this T owner,
        Expression<Func<T, TProperty>> propertyPicker)
        where T : INotifyPropertyChanged
    {
        return CreateExpectation(owner,
            propertyPicker, false);
    }
 
    private static NotifyExpectation<T>
        CreateExpectation<T, TProperty>(T owner,
        Expression<Func<T, TProperty>> pickProperty,
        bool eventExpected) where T : INotifyPropertyChanged
    {
        var propertyName =
            ((MemberExpression)pickProperty.Body).Member.Name;
        return new NotifyExpectation<T>(owner,
            propertyName, eventExpected);
    }
}

These extension methods can be used in several verification test contexts. The obvious one would be:

[Test]
public void OnPropertyChangedIsCalledForParticularProperty()
{
    // Arrange
    var sut = new MyClass();
 
    // Act
    // Assert
    sut.ShouldNotifyOn(model => model.Property)
        .When(model => model.Property = "new string");
}

In this test I verify that the property named Property is raising its PropertyChanged event, when the setter is called with the string value “new string”. Clean and easy verification of properties on view models. These extension methods can participate in more complex test scenarios:

[Test]
public void OnPropertyChangedIsCalledForParticularProperty()
{
    // Arrange
    var sut = new MyClass();
 
    // Act
    // Assert
    sut.ShouldNotifyOn(model => model.Property)
        .When(model => model.IntProperty = 3);
}

In this test I verify that the Property is raising the event, whenever another property setter is called.

Combining ShouldNotifyOn with combinations of the ShouldNotNotifyOn makes these two small extension methods quite handy when testing and verifying properties on view models.

Continuous Integration with GitHub, TeamCity, Azure Websites and IIS7

2013-06-19T04:03:09+00:00

The CI objective is to continuously and frequently incorporate changes to the codebase into a centralized build process which may include the automated running of tests, analysis of the code and deployment to target environment(s). Pivotal to this is the version control system as this should be the source of truth for the code base. As a result, effective CI is only achieved through effective use of VCS.

In order for this to work successfully, developers need to apply the good development practices, they’re probably already aware of, but may not have previously had the impetus to adhere to. Committing source code regularly, taking updates from team members as frequently as possible and only putting working code which doesn’t fail tests into VCS are all just common sense and good practice. The difference being that if they don’t do this in the CI world, lots of flashing red lights go off and other people get inconvenienced. Let’s just say they should be a lot more motivated now!

Impact on Development Practices

Forcing developers to only release code – even to a development or test server – via a continuous integration and deployment process can be a fundamental change of working for some people. It means moving away from casual VCS and release practices and having to take a much more structured approach to work.

This is a good thing, and if someone tells you otherwise it’s probably because they’re following less than ideal practices to begin with. This really forces you to modularize work into smaller, more atomic units than you might have done in the past. If you don’t commit code atomically, for example by submitting the code behind but not the ASPX with controls it references, your build breaks and now nobody can push it through to the development server until it’s fixed.

Likewise if you go long periods without committing to source control you start to dramatically increase the risk of conflicts with others. Plus you also increase the duration between releases to a server environment which consequently increases your risk of features not working outside your own PC. Everyone’s familiar with this, I assume.

So in summary, release early and release often. Yes, even if you’re not practicing CI!

Choosing A Build Server

This concept is equally applicable to a whole range of build server products that support the principals of CI. Within the .NET space the products most commonly seen include (but are not limited to) CruiseControl.NET(CC.NET), Microsoft’s own Team Foundation Server (TFS) and the topic of today’s discussion, TeamCity from JetBrains (the good folks who bring us ReSharper).

Much discussion about the various merits of each is available on the web but there are a few key and decisive factors in favor of TeamCity. Firstly, the Professional Edition is free and more than capable of providing sufficient features to get very intimate with how it runs before needing the scale of the Enterprise Edition which even then, is only a couple of thousand dollars.

Since abandoning TFS for Git and GitHub, due to a job change, I’ve been looking for some kind of CI workflow. Actually, I think TFS is a very impressive product. What it’s done with the whole application lifecycle management (ALM) and particularly the testing and lab environment is mighty impressive.

Finally, I just like JetBrains! ReSharper is a raging success (over 250,000 licenses sold) and every interaction I’ve had with them both professionally and via medium like Twitter has been profoundly positive. They give me a high degree of confidence that they understand the development process and the tools software developers need to be successful.

Project Background

I was recently transferred to a new project. It’s a project which currently has a Silverlight CRUD client to some business intelligence (BI) warehouse, which is responsible for creating weekly reports to customers. The task was to migrate the current Silverlight client to a web client deployed as an Azure Website.

At my current workplace, we’re profound fans of Git as version control system, and use GitHub, as hosting service. On some of our projects we use TeamCity server for continuous integration.

Setting Up Continuous Integration with TeamCity

We need to setup a build configuration that is triggered by a VCS check-in. First, of is some general settings for the build configuration. Important notice is to remember the artifact path. This path describes which parts of the VCS repository is included in this build. The ‘**’ is a wildcard to include everything.

The next step is to setup source control. This is done in two steps. We need to attach Git as our VCS for this build configuration:

As highlighted, this build configuration is fetching from the master branch from Github. It is also possible to supply different filters for fetching other branches. It also makes it possible to have other build configuration for other primary branches, such as test, staging, release,… Then we need to setup how VCS checkout is done and where to checkout:

An important notice is to set the checkout mode as ‘Automatically on agent’. Default is on server.

So now we have setup VCS, we then move on to setup how the codebase is build and tested. This is done in two seperate steps:

As highlighted I’m using the build-in MSBuild to perform the actual build of the codebase. A number of options are available. The second, dependent on a successful build, is the testing step:

As highlighted, I use NUnit, but there is support for MSTest. I’m not sure about xUnit. Also highlighted is the assembly list. I usually have a number of test assemblies, unit tests, acceptance tests, and integration tests. Supplying a wildcard, all test assemblies will be run.

We then need to supply a build trigger. A build can be run manually, but by setting up a build trigger we can execute the build on a VCS check-in:

You can trigger builds based on a number of variety of different events such as on a schedule (i.e. nightly) or on the success of another build.

That’s it, whenever we make a Git push on our master branch, a build is triggered. There is a ton of other options available in TeamCity. I have also a build configuration for my test branch and one for my release branch. This setup does not avoid developers from checking in a revision which does not build or have failing tests, but it highlights issues, and makes the team aware of issues on the latest check-in. By making the steps dependent on each other, we can make assure that we don’t deploy a revision with failing tests. In the next section, I’ll setup a deployment step, where TeamCity deploys the, now building and fully-tested codebase, to an Azure Website.

Setting Up Deployment to Azure Websites using TeamCity

We start by creating a new build configuration for deploying to a Azure Website:

In the source control settings, we attach the same VCS root as for building and testing the master branch, shown in the previous section. In the build step section, I’ll setup a command line build step.

It is actually pretty trivial. From command line, we make a Git push to a Azure Website specific URL, on the master branch. This URL can be found on your Azure Website on the Configure tab:

Copy the Deployment Trigger Url to your TeamCity build configuration. The branch needs to be the same on both Azure and in the Git push URL. As shown in the previous section, we can use different branches in different builds, and therefore deploy to different environments. In this project, I have a development environment, which is deployed using the master branch, a test environment using the test branch, and finally a production environment using the release branch. I then have completely separate environments, controlled by Girt branches.

To trigger the Azure deployment, a build trigger is specified:

This triggers the deployment to Azure on a successful build step, shown in the previous section. Basically, this guards any deployment of faulty revisions.

There are two additional settings that we need before we have automated Azure Website deployment. We need to setup two dependencies for the build:

I need a snapshot dependency and an artifact dependency. The snapshot dependency, is a indicating that this build will use the latest successful Build & Test Master build. By doing this we can avoid, that another team member makes a check-in, just after the previous check-in, and thereby invalidates the first check-in. This makes sure that build and revision is in line. The artifact dependency, has the same meaning as the snapshot dependency, but at at artifact level. Making sure that none of the artifact is invalidated by a successive check-in.

This is all that it takes to make your Github repo, being build, tested and deployed to an Azure Website. In the current project, I have also created another build for IIS deployment.

Setting Up Deployment to IIS7 using TeamCity

This is done by using pushing a Web Deploy package to the IIS. A Web Deploy package contains everything that is needed for a deployment. On the server, running the IIS, we need to make sure that the Web Deployment Agent Service is running and always will (automatic startup). On the General Settings page, make sure to provide the correct artifact path:

This indicates where the Web Deploy package is located, dependent on the build configuration used.

Then I’ve setup a MSBuild command line build step:

The important part is the command line parameters. These parameters tells MSBuild that it should build, package, and deploy using Web Deploy. As with the Azure deployment, this build is triggered after a successful Build & Test Master build. I’ve provided two build parameters, %env.Configuration% and %env.TargetServer%, these are provided at the Build Parameters page.

That’s all. Now when a team member makes a Git push to master, the master branch is build, tested, and the client is deployed to an Azure Website and the backend is deployed to an IIS7.

Verify Your Guards With AutoFixture

2013-05-13T16:56:14+00:00

An important tool in leveraging loosely-coupled components is using dependency injection (DI). A common and wide-spread approach to DI is using constructor injection. Basically, when using constructor injection, all dependencies are injected as parameters through your constructors. This allows strong-typed dependency declarations. It is good practice to follow the Guard Assertion pattern or Guard Clause pattern, like this:

publicvoid Service(IService service1, IService service2)
{
    if (service1 == null)
    {
        thrownewArgumentNullException("service1");
    }
    if (service2 == null)
    {
        thrownewArgumentNullException("service2");
    }
}

These guard clauses makes sure that the injected dependencies are in a useful state.

For a long time I have been testing all my guard clauses through my unit tests. I’ve been having discussions with co-workers and associates about the necessity of testing guard clauses. Their argument is that by definition the CLR will throw the ArgumentNullException, it is part of the framework. My argument is that we cannot foresee how this code will be used or refactored in the future. So, to avoid a future situation where the injected dependencies are not verified, I’ll keep testing my guard clauses. Up until now I have done this like this:

[Test]
publicvoid Service1IsNullThrowsException()
{
    Assert.Throws<ArgumentNullException>(() => 
        newService(null, _service2Mock));
}
[Test]
publicvoid Service2IsNullThrowsException()
{
    Assert.Throws<ArgumentNullException>(() => 
        newService(_service1Mock, null));
}

For each of our constructors and each of their parameters I used to verify whether my guard clauses are in place. This is a very tedious and trivial task. Another pain of having these tests is that they are very brittle and will lead to a maintenance hell. I therefore had a chat with Mark Seemann at Danish Developers Conference 2013. He made an excellent session on writing maintainable unit tests. I asked him whether he was testing his guard clauses, and how he did that. His answer was that he was testing them, but got tired of writing tests for all permutations of these scenarios. He therefore implemented this functionality into AutoFixture, or more like into an extension. AutoFixture is an important, if not the most important, tool in my TDD toolbox. It keeps surprising me with new features, and new ways to optimize my TDD endeavors. Check out my recent post on AutoFixture.

AutoFixture has this very cool and, maybe, a little overseen extension called Idioms. It is an extension for idiomatic unit tests, that would be unit tests that keep using common templates. I have just realized this extension, and my first discovery is the GuardClauseAssertion class. This class can be used to test all constructors and all its parameters, to verify whether there is missing a guard clause in any of these. This is how my previous test methods would be replaced using the GuardClauseAssertion class:

var fixture = newFixture();
var assertion = newGuardClauseAssertion(fixture);
assertion.Verify(typeof(Service).GetConstructors());

Using reflection all constructors and all their parameters are verified to make sure that guard clauses are in place. See, my maintenance hell just vanished. Awesome!

On a side-note, the Verify method will provide you with a quite detailed exception message if any constructor argument in any constructor is lacking a guard clause, like this:

Ploeh.AutoFixture.Idioms.GuardClauseException : An attempt was made to assign the value null to the parameter "service1" of the method ".ctor", and no Guard Clause prevented this. Are you missing a Guard Clause?

So, no more excuses not to set up guard clauses for your dependencies.

Danish Developer Conference 2013

2013-03-20T21:03:40+00:00

The upcoming Danish Developer Conference 2013 (DDC) is my first conference this year. I attended DDC last year, which was the first time that Microsoft Denmark arranged. I thought it was a great success, and delighted to see that Microsoft will setup another round of DDC.

This year my employer, d60, will be coffee sponsor and will have a coffee bar with a barista. Sponsored coffee cups and flyers are ready. I’ve been given the great honor of managing the d60 Twitter account, @60dk. So, tune in and follow @d60dk.

As with other conferences these days, Windows 8 is a primary focus area. At the moment I can’t see myself developing any Windows 8 specific applications, therefore I’ll keep my focus elsewhere for now. Fortunately DDC also has great content for attendees like me.

First of is the keynote. Last year it was John Sheehan who held the keynote on Windows 8 and Visual Studio 2011 (2012). This years keynote is held by Jon Galloway, who will talk over the topic of “The Development Landscape Is Moving Extremely! Here’s How To Move Faster”. Exiting headline, looking forward.

In the first session Mads Kristensen, whom I met at last years DevConnections, will provide a session on Visual Studio 2012 vNext. Mads is a cool guy and a great speaker. His work on Web Essentials has been of great benefit to all web developers.

After lunch I’ll head over to hear Gudmundur Hreidarson, giving a talk on single page apps. A topic that I’ve only glanced shortly, so perhaps Gudmundur can reignite my interest in SPAs.

In the third session, Kasper Holdum, will give a talk about async and reactive extensions (Rx). We’re using reactive extensions on the project that I’m currently assigned. It’s just amazing to see the possibilities of Rx, and how it can change the way we code async. This is a session that I’m particularly looking forward for.

In the fourth, and last session, before the closing keynote, Marc Seemann will give an advanced unit testing talk. Marc wrote a great book on Dependency Injection in .Net, which I encourage all serious developers to read, the sooner the better. But Marc also lately published some nice Pluralsight couses on Inside-Out TDD. Faithful readers of this blog knows that I’m a profound TDD practitioner, so hopefully Marc can add additional aspects to my TDD toolbox.

I’m looking forward for the sessions, but also to some of my fellow developers for networking.

Customizations with AutoFixture

2013-02-25T18:17:50+00:00

I’m profound advocate for Test-Driven Development (TDD). I don’t regard myself as a TDD expert, but I’m getting more and more used to the TDD “lifecycle”:

There are several advantages to adopting this approach and its beyond the scope of this blog post in particular, I will definitely write an entire blog post on TDD at some point.

When I apply the TDD “lifecycle”, I use a number of tools, which support and ease the lifecycle. I mainly use the NUnit test framework, I have spiked in xUnit, but still stick to NUnit as my primary test framework. An indispensable tool when unit testing is a mocking framework, I have used Moq for a couple years, after leaving Rhino Mocks. They are both great dynamic mocking frameworks, and a must. The last, but not least, primary tool in my TDD toolbox is AutoFixture. Its one of my favorite frameworks, and I almost can’t TDD without it. For those of you not familiar with AutoFixture, I’ll give you short intro.

AutoFixture creates dummy data for your unit tests, so it can be a real time saver. A simple string can be created like this:

var fixture = newFixture();

var dummyString = fixture.CreateAnonymous<string>();

The result would be a string with a value like this: “a3cb054d-dbb3-4d97-85be-b11e06784f97".

Likewise you can generate integers. You can generate a finite number of strings:

var fixture = newFixture();

var dummyString = fixture.CreateMany<string>();

This would create the as many strings as the fixture.RepeatCount is set to, by default it is set to three. You can also modify the count inline:

var fixture = newFixture();

var dummyString = fixture.CreateMany<string>(5);

This would create five dummy strings. If you need to add dummy data to a list:

var fixture = newFixture();

var strings = newList<string>();

fixture.AddManyTo(strings, 5);

This would add five dummy strings to the ‘strings’ list. The power of AutoFixture is that it can also generate dummy objects from your complex classes:

var fixture = newFixture();

var dummyMyClass = fixture.CreateAnonymous<MyClass>();

So if my complex class had any public properties like strings, these would be assigned a dummy value. Sometimes it might also be great to set a known value for a property:

var fixture = newFixture();

var dummyMyClass = fixture.Build<MyClass>().With(myClass => myClass.Name, "Mads");

There are many more nifty stuff that AutoFixture can help you with, but I’m going to drag you all the way around. For the remaining part of this blog post I’ll focus on how to customize the generation of dummy test data.

There are multiple ways to customize how AutoFixture generates its values. A simple approach to customize the string generation:

var fixture = newFixture();
var seededString = fixture.Build<string>().FromSeed(s => "foo").CreateAnonymous();

One piece of dummy data that always takes time is lists. As we learned above we can generate a dummy list in AutoFixture like this:

var fixture = newFixture();
var dummyList = fixture.CreateAnonymous<List<MyClass>>();

AutoFixture generates the list for you, but the list is empty. We would have preferred a list of MyClass instances, therefore a small customization is needed:

var fixture = newFixture().Customize(newMultipleCustomization());
var dummyList = fixture.CreateAnonymous<List<MyClass>>();

Adding an instance of the MultipleCustomization (line 1), would generate a list of 3 MyClass objects, with a dummy Name string. Remember, three is the default number for AutoFixture. Assume that you have a child class inside your parent class:

publicclassMyParentClass
{
    publicstring ParentName { get; set; }
    publicMyChildClass Child { get; set; }
}
publicclassMyChildClass
{
    publicstring ChildName { get; set; }
}

Generating a list of MyParentClass:

var fixture = newFixture().Customize(newMultipleCustomization());
var dummyList = fixture.CreateAnonymous<List<MyParentClass>>();

Would give me a list of 3 MyParentClass, with dummy string ParentName and a dummy MyChildClass, with a dummy string ChildName.

One more thing before jumping into handling abstractions, lets assume that we would like to a list of MyChildClass inside MyParentClass (line 4):

publicclassMyParentClass
{
    publicstring ParentName { get; set; }
    publicList<MyChildClass> Children { get; set; }
}
publicclassMyChildClass
{
    publicstring ChildName { get; set; }
}

This gives me a list of 3 MyParentClass where each has a list of three MyChildClass objects. Remember we can change the number of list items by changing the RepeatCount on the Fixture instance. In some scenarios it might be necessary to change only one of the counts. This is done by using the Register method:

var fixture = newFixture().Customize(newMultipleCustomization());
fixture.Register(() => fixture.CreateMany<MyChildClass>(5));
var dummyList = fixture.CreateAnonymous<List<MyParentClass>>();

Now we have a list of three MyParentClass where each has a list of five MyChildClass. This means that every time the fixture needs to generate a list of MyChildClass, it would use the anonymous method in line 2.

So, abstractions. By default you can’t do something like this:

var fixture = newFixture();
var dummyAbstraction = fixture.CreateAnonymous<IService1>();

AutoFixture would throw an exception at you. AutoFixture is not able to create an instance of this interface without a constructor. So you can provide a fake instance, all it requires is that it implements the IService1 interface and then register it to the Fixture:

var fixture = newFixture();
fixture.Register<IService1>(() => newFakeService());
var dummyService = fixture.CreateAnonymous<IService1>();

Now AutoFixture is able to create a dummy version of your FakeService.

I’m a big fan of dependency injection and make heavily use of IoC containers. See my previous post on dependency injection and me. Especially constructor injection is used everywhere.

This often forces me to write a lot of mocking data for all my dependencies, which can be a real time killer:

var fixture = newFixture();
var sut = newServiceToTest(newMock<IService1>().Object, newMock<IService2>().Object, newMock<IService3>().Object)

This is just a simple example, sometimes there a many more dependencies. The usual approach with Moq is to set expectations like this:

var fixture = newFixture();
var mock = newMock<IService2>();
mock.Setup(service2 => service2.DoStuff()).Returns("foo");
var sut = newServiceToTest(newMock<IService1>().Object, mock.Object,
                            newMock<IService3>().Object);

This approach is completely fine, but it can be a time killer with a lot of “empty” mocks. Therefore I recently discovered that AutoFixture has an extension using Moq. The way it works is that it uses Moq as a fallback mechanism, by relaying request for creating an abstraction to Moq. I can then refactor the above to the following:

var fixture = newFixture().Customize(newAutoMoqCustomization());
var mock = _fixture.Freeze<Mock<IService2>>();
mock.Setup(service2 => service2.DoStuff()).Returns("foo");
var sut = _fixture.CreateAnonymous<ServiceToTest>();

Cool, right? In line 1, a new customization is added. This extension is part of AutoMoq extension, available via a Nuget. As usual, AutoFixture creates an instance of the ServiceToTest, bet ServiceToTest takes three dependencies through constructor injection. AutoFixture cannot figure out to create instances of these, they are relayed to Moq. Since I need to set expectations on IService2, I can freeze a variable in the AutoFixture framework, and bypass default behavior for creating instances.

This is a great extension to AutoFixture. combining the mocking features of Moq for supporting auto mocking is great. Since Moq was added, a number of other mocking frameworks has been, AutoFakeItEasy, AutoRhinoMocks, and AutoNSubstitute.

Oh, one more thing. Consider the following class:

publicclassMyParentClass
{
    publicstring ParentName { get; set; }
    publicList<IMyChildClass> Children { get; set; }
}
publicinterfaceIMyChildClass
{
}

Okay, I described such class above, the difference is that it is now a list of interfaces. Remember, lists of concrete instances can be created by using the MultipleCustomizations, and interfaces can be created by using the AutoMoqCustomization, so we need to combine the two. This is done by CompositeCustomization:

var fixture = newFixture().Customize(newCompositeCustomization(newMultipleCustomization(), newAutoMoqCustomization()));
var dummyClass = _fixture.CreateAnonymous<MyChildClass>();

This customization combines the two, and creates an instance of MyParentClass, with a list of three MyChildClass instances. Sooo, neat.

That’s it for now. Throw a comment at me, and tell me your AutoFixture niftiest.

Living with a Kindle

2013-01-21T18:53:34+00:00

In a previous post I described the process and my considerations when buying a Kindle. In this post I’ll provide some you with some of my experiences with my Kindle.

I’ve had my Kindle since mid-October 2012, and I cant imagine living without. It has indeed increased my everyday professional productivity. I carry my Kindle everywhere. Every time I find a second, a minute or two, I read in my Kindle. Whenever I’m waiting for the remaining participants of a meeting to arrive, waiting in waiting´-room at the dentist, or on the bus or train. I’ve always felt that I needed some hours every day, to be able to catch up on all the new stuff evolving in the software industry. Having multiple sources right at my hand, basically everywhere I go, suits perfectly into my professional productivity.

So, what do I read on my Kindle? I like to read on different sources in parallel. So I have both fiction books, tech books, blog posts, and magazines. I can therefore pick whatever suits the situation. Easy read sources such as magazines and blog posts are read when time and noise is an issue. Books are used when there is time to focus and really get in-depth.

The books I read are bought from Amazon, Manning, and Riidr (a site with mainly Danish ebooks). Some of these sites support sending the books directly to your Kindle through Amazon’s Personal Document Service. This is a service provided by Amazon to prevent spam from reaching your Kindle. On your Amazon account, there is a Personal Document Settings page, where you supply Amazon with approved email addresses of the sites you want to receive books from. After providing Amazon with approved email address, you provide the book store with your unique Kindle email address. Then the books you’ve bought is seamlessly sent to your Kindle. All you have to do is turn on WiFi on your Kindle, and it downloads your purchased content. This is a great feature. I use it for almost everything. Let me provide some examples. Books bought from Amazon is sent to you this way, so after completing the your purchase on the website, you can turn on WiFi, and there is your book, just a few seconds after you bought it. You don’t have to consider shipping, customs, etc. The first time you use this feature, you’re just amazed of the simplicity. Amazon keeps a record of all your purchases, so you’ll be able to download them again. Also, other personal documents sent to your Kindle is stored at Amazon. So, this includes books from Manning and Riidr.

I have also approved my Gmail address, so I can send larger emails that I don’t have time to read during the day.

And Instapaper. I’m a huge fan of Instapaper. Instapaper provides a great service for collecting and sending content to Kindles. All you have to do is create an Instapaper account and use a bookmarklet for your favorite browser. Whenever you see a blog post, or larger article, that you don’t have time to read, you click the bookmarklet, and the content is stripped for images, videos, so that only written content is stored at your Instapaper account. When I come across some interesting stuff on Twitter, I click the Read Later bookmarklet. On your Instapaper account settings page you supply your Kindle email address, and as described above, you provide your unique Instapaper email address to the Amazon site. Then you setup when Instapaper should sent you the latest content. I’ve setup mine to send the latest content to my Kindle everyday at 4 PM. Scott Hanselman also wrote a blog post on this setup. Instapaper is also a great tool if you’re Google Reader fan.

So when I get home and have the time, I turn on WiFi, and bang there is my content, from all my sources. The Instapaper content is formatted into newspaper like format, and easy to navigate.

The reading experience on the Kindle is phenomenal. This e-ink technology is brilliant. It’s a pleasure looking at a screen that is not backlit, if you, as I do, sit in front of an LCD all day long. I bought the regular Kindle, so the 6" screen is perfect in weight and size for reading everywhere. The navigation is great, although I would have appreciated a better browser experience, but on the other hand its not an iPad, its a Kindle, made for reading ebooks. Battery lifetime is great. A full recharge keeps battery for approximately a month, with daily usage and with WiFi disabled. It then takes a couple of hours of recharge, and its fully recharged.

Sometimes you might have PDFs from other sources, that don’t support the wireless ecosystem. I then use a nice application called Calibre. Calibre is an ebook management tool. Its able to connect to several ebook readers, and is able to convert from PDF to .mobi, which is the format for ebooks on the Kindle. The Kindle is able to read PDFs, but it lacks several great features, such as a navigational TOC and chapters bookmarks.

I’m a happy Kindle user. It fits into my personal productivity setup. So far I don’t regret that I bought the Kindle, and I can only recommend others to do the same.Throw my a comment on your experiences with the Kindle.

Is MEF a DI Container?

2012-12-04T06:21:19+00:00

A couple of weeks ago I read this article in Code Magazine about dependency injection (DI), and they mentioned the Managed Extensibility Framework (MEF) as a DI container. I never thought of MEF as DI container, so I thought, let’s take it for a spin.

Managed Extensibility Framework

So Microsoft coins MEF as a library for creating lightweight, extensible applications. It provides developers the tools for discovering and using extensions with no configuration required. Developers creating extensions are given tools for easily encapsulating code and avoiding hard fragile dependencies.

MEF is providing support for components to discover other components implicitly, via composition. A MEF component, called a part, declaratively defines its imports and exports. The imports are its dependencies, while the exports are its capabilities that the components makes available. When a part is created the MEF composition engine will resolve its imports, with what is available from other parts. Doing this declaratively makes them discoverable at runtime, this avoids hard-coded references and fragile configuration files. By adding metadata MEF allows tagging of extensions for querying and filtering. Since there is no hard dependency on a particular assembly, extensions can be used across multiple assemblies.

So lets take a look at simple example. I’ve created a simple calculator to display the basics of MEF. You can find the source code at GitHub.

The Program class holds an ICalculator property:

   1: [Import(typeof (ICalculator))] 
   2: private ICalculator Calculator;

This means that the Program class requires one, exactly one, implementation of ICalculator. Every import has a contract, which determines what exports it will be matched with. In this case I have specified it explicitly with a string.

The calculator class is declared with the Export attribute with type of ICalculator, saying that this class offers an implementation of the ICalculator interface:

   1: [Export(typeof(ICalculator))]
   2: class Calculator : ICalculator

In order for Calculator to be extensible, it needs to import a list of operations. An ordinary Import attribute is filled by one and only one Export attribute. If more than one is available, the composition engine produces an error. To create an import that can be filled by any number of exports, you can use the ImportMany attribute:

   1: [ImportMany]
   2: IEnumerable<Lazy<IOperation, IOperationData>> operations;

Lazy<T, TMetadata> is a type provided by MEF to hold indirect references to exports. Here, in addition to the exported object itself, you also get export metadata, or information that describes the exported object. Each Lazy<T, TMetadata> contains an IOperation object, representing an actual operation, and an IOperationData object, representing its metadata.

So lets implement the first operation:

[Export(typeof(IOperation))]
[ExportMetadata("Symbol", '+')]
class Add : IOperation
{
    public int Operate(int left, int right)
    {
        return left + right;
    }
}

Again, the Add class exports an implementation of the IOperation interface. Additionally I’ve added the ExportMetadata attribute. This attribute will attach metadata, in the form of a name-value pair, to this export.

Finally, a small piece of calculator logic:

public string Calculate(string input) 
 

























 


To wire things up MEF uses a CompositionContainer: 2: { int left; int right; var fn = FindFirstNonDigit(input); if (fn < 0) { return "Could not parse command."; } try { left = int.Parse(input.Substring(0, fn)); right = int.Parse(input.Substring(fn + 1)); } catch (Exception) { return "Could not parse command."; } var operation = input[fn]; foreach (var i in operations.Where(i => i.Metadata.Symbol.Equals(operation))) { return i.Value.Operate(left, right).ToString(CultureInfo.InvariantCulture); } 28: return "Operation Not Found!"; 30: }

   1: private CompositionContainer container;

To register the necessary types, you need to create a catalogue of types. This is usually done at the assembly level using the AggregateCatalog:

var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));
container = new CompositionContainer(catalog);

And composing the MEF parts:

try
{
    container.ComposeParts(this);
}
catch (CompositionException exception)
{
    Console.WriteLine(exception.ToString());
}

This wraps up my overall introduction to MEF, but does this qualify MEF as a DI container?

Is It a DI Container…?

This post is not suppose to be a complete outlining of what dependency injection is, or how a DI container works. People have written books on these matters. Please see my previous post on DI. I’ll therefore be very concise, and focus on how MEF fits into the DI world.

MEF was developed for a different purpose than a DI container. It’s a framework facilitating add-in support for parts. Such parts is an unknown component for a standard application. A part exposes certain interfaces, but that is all the application knows about the part. There may be zero, or multiple parts, depending on the environment. This is a key difference from a DI container, where we typically know about all, or most of, the components at compile time. We use the knowledge about components to configure the container in the applications Composition Root.

Facilitating add-in requires some sort of discoverability mechanism. Usually discoverability is implemented by scanning a certain folder for assemblies to find all classes implementing the required abstraction. MEF addresses through an advanced discovery model that uses attributes to define consumers and their services.

So to sum up. A fully-fledged DI container favors decoupled composition of services. This provides the greatest degree of flexibility, but it comes at a cost. As developers, we must have knowledge about the components we wish to compose at the time we configure the container. MEF favors discovery of components. This addresses the issue when we know little about the add-ins a design time. The tradeoff is that the discovery mechanism is tightly coupled with the components, so we lose some flexibility.

Some proponents of MEF argues it’s a DI container, but as it, it is not. You might be able to use is as such, but out of the box it a framework for facilitating a plugin architecture.

Branching and Deployment - Good Practices

2012-11-05T11:09:29+00:00

Feature Branches

Branching is a vital tool for all developers, working alone or in teams. The basic idea of feature branching is that when you start work on a feature, you create a branch off of the repository and commit all the changes for the feature onto the branch and when your feature is code complete then merge the changes back.

The advantage in using feature branches is that your main line (you might call main line ‘master’, ‘trunk’ or ‘head’ depending on the version control system you use) is kept clear of uncompleted features or bug fixes, which enables you to release software at any time because you don’t have to wait for all the features and bug fixes being worked on to be completed.

If concurrent development on other branches are in progress, it is a good idea to keep in synch with the latest changes on trunk. Synching with trunk helps avoiding the 'big' merge at code complete.

Test And Deployment Branches

The advantages mentioned above for feature branches, is also evident for test and deployment branches. We would like to isolate test and production versions from the continuous development made on trunk.

Every time a version is released to production it is versioned on its own branch. Should there occur any issues or hot fixes to any releases, these are made on the release branch and changes are merged back into trunk.

A test branch holds an isolated version that is currently being tested either by QA or business. Again, should there occur any smaller fixes, then these should be merged back into trunk. Larger changes, or feedback from business, should be put on a separate feature branch.

A good practice is to release to production from the test branch, so that the version that has been tested and verified by either QA or business, is the one being released to production. This means, that when we need to deploy to production, we merge trunk into the test branch and, when the revision is verified, we create and version a release branch from the test branch.

T4 Templating without Visual Studio

2012-10-31T08:52:32+00:00

I’m currently appointed to an older project to make some new features. I soon realized that this project is developed in a pre-Nuget era, so all dependencies were copied into a 3rd party folder and included in source control. The entire solution includes 29 projects, so there were a larger number of dependencies to this solution. I decided to get rid of all the dependencies that is available on Nuget. These included NHibernate, MVVM Light, log4net, Castle Windsor, Auto Mapper, Rhino Mocks, NUnit, and the Silverlight Toolkit. I noticed that the Silverlight Toolkit is available as individual components, instead of just installing them all. It took a few hours to get all dependencies to work across the solution, but pretty trivial. Besides these dependencies, there was a dependency to Texttransform.exe.

T4 Templating and Visual Studio

Texttransform.exe is part of T4 templating and is installed together with Visual Studio. In this case a developer has copied the Texttransform.exe from the its default installation path in \Program Files (x86)\Common Files\Microsoft Shared\Text Templating\ to the 3rd party folder in the solution folder. The problem with this approach is that the version in the solution folder is the Visual Studio 2010 version. Running Texttransform.exe from Visual Studio 2012, provides an error. I therefore removed the copy from the solution folder and wrote a relative path in the pre-build event to the default installation.

"%COMMONPROGRAMFILES(x86)%\Microsoft Shared\TextTemplating\$(VisualStudioVersion)\texttransform.exe"

The $(VisualStudioVersion) variable provides the current version of Visual Studio, so this approach works on both Visual Studio 2010 and Visual Studio 2012.

I’m not going to cover T4 templating in detail in this post, but I recommend reading Scott Hanselman’s post on this issue. Basically, T4 is code generation. It can generate all kinds of text files, not just code.

Since T4 is installed together with Visual Studio, it gives us quite a challenge to get this to work with Team Foundation Server (TFS) (which is the management decision of source control at my current employer), since the $(VisualStudioVersion) variable is not present on the build server.

T4 Templating and Team Foundation Server

To get the necessary dlls I needed to install the Visual Studio SDK 2012 on my development machine and the copy the following files to the build server:

\Program Files (x86)\Microsoft Visual Studio 11.0\VSSDK\VisualStudioIntegration\Common\Assemblies\v4.0\
- Microsoft.VisualStudio.TextTemplating.11.0.dll
- Microsoft.VisualStudio.TextTemplating.Interfaces.11.0.dll
- Microsoft.VisualStudio.TextTemplating.VSHost.11.0.dll
\Program Files(x86)\MSBuild\Microsoft\VisualStudio\v11.0\TextTemplating\
- Microsoft.VisualStudio.TextTemplating.Sdk.Host.11.0.dll
\Program Files(x86)\Microsoft Visual Studio 11.0\Common7\IDE\PublicAssemblies\
- Microsoft.VisualStudio.TextTemplating.Modeling.11.0.dll
\Program Files(x86)\Common Files\microsoft shared\TextTemplating\11.0\
- TextTransform.exe
- TextTransform.ico

It is important to keep the same directory hierarchy. Due to these issues with T4 Templating and TFS, Microsoft has changed their EULA for Visual Studio making it license-wise legal to copy the files to a build server.

Without making too much custom TFS handling of this, I going to the send the VisualStudioVersion variable, mentioned above, to the TFS from Visual Studio through a MSBuild argument. This is done in your Build Definition, under the Process tab, like this:

Now TFS is able to find texttransform.exe and do the T4 templating.

Instead of this kind of hack, MSBuild ought to support T4 templating natively. Like MSBuild is able to perform configuration transformations, it should support T4 templating as well.

Dependency Injection and Me

2012-10-15T17:25:11+00:00

From time to time I look into my toolbox to see which tools I use the most. With almost 8 years of software development experience, I’ve learned that constantly sharpening the knives of your toolbox and adding new tools, is what makes you a great developer. If I were to highlight one of my favorite tools in the box, the tool that just makes me smile every time I use it, it must be dependency injection (DI).

I’ve used DI a long time before I knew it was called dependency injection. I was introduced to these principles in Behavior-Driven Development course around 5 years ago. Always code against an interface and the Open/Close principle. I started using the techniques and soon realized that they were quite useful, if not mandatory, when unit testing. The loose coupling between components and layers, have given me numerous architectural advantages over years. Even when doing embedded development on Linux using C++, I instinctively grabbed for DI in my toolbox. I had found tricks to handle transient dependencies, and how to share dependencies among several consumers. I usually related my home-brewed DI techniques with the strategy pattern and the decorator pattern.

2 years ago, I left the dark side of Linux and C++ to dedicate my life to .Net and C#, this is where I realized that this loose coupling technique I had used for the past 3 years, was actually termed dependency injection. I then started using DI Containers over my own home-made DI techniques.

DI Container Basics

So, by laying off my home-brewed DI techniques, I’ve found a tool that enhance my productivity, and supplying me with an arsenal of great features.

DI containers are about two things, R&R. No, not rest and relaxation. I’m talking about registration and resolving. These are the acts of storing a list of types and later retrieving instances of them at will.

The DI container is the tool that turns DI into architectural patterns that lets you satisfy a type’s dependencies easily and automatically. It is a repository that typically associates interfaces with concrete types. DI containers all work in a very similar fashion. At the beginning of an application’s execution-cycle, you need to register associations of concrete types to the interfaces that they implement.

Basically all DI containers are based on three dimensions, object composition, object lifetime, and interception.

Object Composition

Object composition is the technique used for wiring up the dependencies to its consumers. This is usually done in the composition root of the application. The composition varies from application type to application type, e.g.. in a console application, the Main() method would be the composition root, the place where all dependencies are wired up to their consumers.

The composition can be configured using different techniques. Configuring by using XML is widely used, and supported by all major DI containers. When using XML, all dependencies are wired to their consumers using an XML file. This is great for late binding. An alternative is to write the bindings explicitly in code, it uses the same discrete bindings as in XML configuration, its just in code. An increasingly popular architectural model is the concept of convention over configuration. Instead of writing and maintaining a lot of configuration code, you agree on conventions.

Four different patterns outlines the object composition catalog, constructor injection, property injection, method injection, and ambient context.

Object Lifetime

This dimension of DI manages the lifetime of the injected dependencies. Some dependencies might be disposable by using the IDisposable pattern, others might be shared between multiple consumers, some might be pooled, etc.

When wiring up the dependencies with their consumers, no matter which composition technique, a certain lifestyle should be considered. Is it a dependency that is thread-safe and can be shared between multiple consumers, then choose singleton lifestyle. If its not thread-safe, then consider using a transient lifestyle. Is it an out-of-process dependency, then it might be a good idea to consider an object pool.

Interception

Interception is the idea of intercepting the call between the consumer and a service and execute some before or after the actual service is invoked. This is a great feature for cross-cutting concerns, such as security, auditing, logging, exception handling, etc. The best analogy to interception is the decorator pattern.

Implementing interception using aspect attributes or relying entirely on decorators, you will find yourself violating the DRY principle. DI containers features dynamic interception by emitting new types at runtime.

Final words…

DI containers are awesome. Use them, use them, use them. You wont regret this, DI is a great tool to have in your toolbox. They provide so much architectural power, they often exceeds the your initial expectations.

I have extensive experience using NInject, and less experience using Castle Windsor, but no matter which DI container you choose, you won’t regret. There might be some initial learning curve, but you get paid back multiple times, I promise.

For further reading I’ll highly recommend Mark Seemann’s ‘Dependency Injection in .Net’. It’s a really great read. I’ve read several chapters here and there, and is currently reading it from start to end.

So, what’s your experience with DI? Throw me a comment…

Buying a Kindle

2012-09-25T10:37:50+00:00

I have always been reading a lot of stuff at the same time. Both magazines and books, technical and fiction. So instead of always dragging around with all these sources I considered buying an e-reader. It quickly turned out to be a choice between an iPad or an Amazon Kindle. The obvious family choice would be to choose the iPad, which would be an excellent toy for the kids and a device that the wife would use. I guess the arguments for buying an iPad is obvious. But for me, I needed a device for reading books, magazines and blogs. Sometime stuff comes in PDFs, so these were the requirements for me.

So I started researching how the Kindle versus the iPad performed in a read-only setting. Factors like size, weight, e-ink, and no reflecting LCD, so reading outside is possible, is decisive for making the Kindle a more superior choice than the iPad. On the other hand, the iPad has a great browser for reading blogs, e-mail support, and better at formatting PDFs. I read Hanselmans blog post on the Kindle, and it seemed that formatting technical books is rather lousy on the Kindle.

Quickly it turned out that the Kindle is the iPad superior when it comes to being an e-reader. But would I miss out on technical books and blog posts? So to complete my research I downloaded a Kindle version of one of the technical books I’m reading (the eBook came free when you have bought the pBook, thank you Manning). I loaded it into the Kindle desktop reader, so I could get an idea how it would be formatted. It was actually formatted quite well. I know that I shouldn’t take the desktop version as a definitive conclusion on the formatting, since different devices renders the books differently. To be able to read blog posts on the Kindle could be some sort of a challenge. Then I read this blog post, about how to use Instapaper for storing web page for reading later and synchronizing them with your Kindle. It uses the unique e-mail address, that every Kindle has for sending personal documents to your Kindle. These documents are also stored in the Amazon cloud storage. So when there is a new article your Instapaper Read Later folder is send to your Kindle at a certain time of the day. Cool. The Instapaper article is a stripped down version of the blog post, where only the text is saved.

Finally, when Amazon lowered their pricing on the Kindle on 6th of September from $109 to $89, I ordered the basic Kindle, the 6” version. Together with a leather casing and a power adapter. I would have ordered the Paperwhite edition, but this is not available outside the US.

In a later blog post I’ll provide my initial experiences.

AAOSConf 2012 – The Retrospective

2012-09-22T17:35:16+00:00

Okay, I’ll start this post with the conclusion; the AAOSConf 2012 exceeded my expectations. In a previous post, I outlined my expectations ahead of the AAOSConf 2012. Reviewing these I found that the conference exceeded my expectations. Let my explain this.

The venue was at some conference facilities at the University of Århus. There were three conference rooms assigned for the AAOSConf. The largest of the three rooms facilitated a projector for the code sessions. My overall impression of the facilities was that they were adequate for a conference of this size and type. Catering included breakfast,lunch, and cake in the afternoon. All day there were coffee and tea. Nothing to point my finger at here.

I’d suppose 20 individuals gathered in largest of the conference rooms. Unfortunately, a number of participants, who were registered, did not show up. This is not just an unfortunate side-effect of free events like this, it’s bad morale. The organizer had put a significant amount of time into organizing this event, so at least you can expect is that registrants decline the event, instead of just not showing up. Okay, I’ve already spend too many lines on these individuals, let’s focus on the remaining participants.

After a short breakfast we were encouraged to write a number of topics on post-its. These outlined the topics of the conference. The same procedure repeated on Friday. During the two day conference I participated in the following sessions:

CQRS + Event Sourcing
Technical Debt
Event Driven Development
Tooling, a decision-maker for language?
Domain Driven Development
“Contractors” aka consultants, how to manage?
Document Databases, good or bad?

And two code sessions:

What really surprised me during this conference was the level of participation from attendees, so honest and willing to share their experiences. I didn’t get the feeling that these guys were trying to sell a book or a service. They were telling true war-stories from real projects. This created an atmosphere were every participant could join the discussions, despite different backgrounds and experience. I’m truly surprised how well this open space setting excels. The knowledge gained from these sessions has multiple perspectives, you get the full package when the participants are willing to share their experiences and their opinions on different matters.

This conference experience exceeded my expectations because I got much more in the bag, than was covered by the sessions. Thank you. I’d encourage everyone who takes software development seriously to participate in this small conference in Århus, it will expand your horizon.

Expectations Ahead of AAOSConf 2012

2012-09-10T17:11:58+00:00

Some time during the Spring I was made aware of this little conference called Agile Architecture Open Space Conference (AAOSConf) by a co-worker. At first I was quite suspicious, but it seemed like an great collection of attendees and the organizer is a old co-worker, whom I know as a serious and hard-working guy. So, why not. I actually didn’t ask my boss until a few weeks ago, but he seemed cool about it, so on Thursday, I’ll attend my first AAOSConf.

I have been wondering a lot of what to expect. I’ve never attended a conference of this sort before, so I don’t know what to expect. From the attendees list it’s going to be quite a variety of fields and domains represented for the open space discussions. There will be Microsoft employees, independent developers, Ruby developers, C# experts, architects, etc., so the ground is laid for some interesting discussions. I don’t know any other conferences of this sort, and the idea is great; gather different sorts software development disciplines and let them share their experience of different sorts. There is definitely going to be something to take with you home from these two days of discussions.

I’m so fortunate that three of my former co-workers are coming along, haven’t seem them for a couple of years or so. So Thursday night going out for a informal dinner with former co-workers and other great people in my network is something I’m looking forward for.

So I guess this sums up my expectations for the two day AAOSConf in Århus; great pragmatic, theoretic, discussions and informal networking and socialising.

What Makes GOTO Århus 2012 So Special

2012-09-10T05:48:06+00:00

Being a pro developer for almost 8 years now, you know your peers and the experts around the field. So when deciding on a conference you check out the speakers list, the organizer and the venue, in that order. I went to Las Vegas in the Spring for the DevConnections, the speakers list and the venue was the main drivers. On the speakers list for DevConnections was Scott Hanselman and Scott Guthrie. I had the pleasure of enjoying Hanselman at PDC 2008, and he is on top of my speakers list. He is an awesome speaker, with a great sense of humour.

Besides Hanselman, GOTO Århus also has Martin Fowler and Anders Hejlsberg on the schedule. I’ve read some articles and a book by Martin Fowler, and is looking forward hearing him talk on the NoSQL topic. Anders Hejlsberg got some secret project up his sleeve, that I’m looking forward hearing about. These three speakers are my main reasons for attending GOTO Århus this year. In my perspective these three speakers makes the GOTO Århus 2012 a special conference this year.

In second line of recommended spearkers is Linda Rising, Jesper Boeg, Hadi Hariri, Jez Humble, and Michael T. Nygard. This year is going to be be my second GOTO Århus conference. I had the pleasure last year as well. I know that I’ll attend sessions that I didn’t plan on hearing. Going to a Microsoft conference you know that the topics will all be about and around Microsoft products, at the GOTO conferences the subjects differ greatly. From strong technical sessions to process oriented sessions. All aspects of software development. It is therefore a good idea to attend the morning presentations of the different tracks of the day. This might convince you into attending a session that you didn’t plan to attend in the first place, or fill in the gaps of your schedule.

Another important aspect of attending the GOTO conferences is the networking aspect. As mentioned above, the GOTO conferences attracts a wide variety of different peers and experts of different areas of software development. This sets perfect conditions for networking at GOTO. To me it seems like the speakers and the attendees are closer to each other, the oppotunities to mingle is higher at GOTO than at any other conference I’ve attended.

Besides cool speakers and nursing my network, I’ll this attend a ReSharper workshop, with Technical Evangelist Hadi Hariri from JetBrains. ReSharper is at the top of my tools list, and I’d love to learn more about this great tool.

With high anticipations I’m looking forward for the GOTO Århus 2012. See you there..?

Interoperating with Flash

2009-06-04T07:26:36+00:00

I've never seen Flash developers as 'real' developers, they don't write real code. They usually come from a design background and always seems focused on transitions and blending rather than aggragations and inheritance. From time to time you have to face the unknown and step into new territories. I recently had to make a tiny step into the Flash territory. I was given the task to create a client player that can stream an RTMPe stream. The RTMPe is an encrypted version of the RTMP protocol from Adobe, orginally Macromedia. This protocol is used by the Flash Media Server (.pdf). On the client side you choose from the different Adobe Flash clients, Adobe Flash Player, Adobe AIR, Adobe Media Player, basically anything that can play an .swf file. So your faced with the challenge of interoperating with Flash.

This is a two side development cycle, so lets start out on the Flash side.

Flash side:

I was recommended a open-source IDE called FlashDevelop. I quickly realised that it has a lot in common with Visual Studio, which is my preferred IDE. Flash is written in a language called ActionScript. ActionScript has some elements in common with VB. VB enthusiasts will probably disagree... With some help from the Adobe Developer Forum I could easily put together a working .swf file. The main components used is the NetConnection and NetStream. To be able to interact with the flash code, your have to set up some callbacks to the external interface:

ExternalInterface.addCallback("SetTrack", SetTrack);
ExternalInterface.addCallback("TogglePause", TogglePause);
ExternalInterface.addCallback("Stop", StopPlayback);

The first parameter is name of the method on which the C# code should call. The second parameter is the function pointer, or delegate in C#, to which ActionScript method should be invoked when, in this case, SetTrack is called. SetTrack receives an URL from the C# code and starts streaming.

C# side:

The first step is to host the Flash Player ActiveX component in the application. This can be done by choosing Add Reference in the context menu of your project or by adding it to your Toolbox by choosing Choose Items in the context menu of the Toolbox.

Then you set the Movie property on the Flash Player: axShockwaveFlash1.Movie = @"xxx.swf"; Now you are able to invoke the methods on the .swf file. This is done by using the CallFunction method on the Flash Player. These calls are done through XML:

axShockwaveFlash1.CallFunction("<invoke name=\"SetTrack\" returnENGINE=\"xml\"> <arguments><string>" + url + "</string></arguments></invoke>");

This call sets the new URL in Flash and starts the stream. Likewise you can pause the stream and make other control calls to Flash Player. One thing that irritated me, was the ability to stop the stream. There is no command for that. So I closes the stream everytime I switch track.

As you can see from this walk-through it is very easy to interoperate with Flash, and writing code in ActionScript seems reasonably easy. Although, I have heard that larger projects in ActionScript can make life a hell.

The beauty of SSH

2009-03-17T14:48:38+00:00

In some cases it might be desirable to get access to your home network. This could be servers, printers, client PCs, etc. At home I have a Firefly Media Server, formerly known as mt-daapd, with all my digital music. Firefly is a cool media server that can stream .mp3, .ogg, .flac, .aac, and .wma. It also supports ID3 tagging. It can on-the-fly transcode .ogg, .flac, .alac, and .wma. It support Roku Server Protocol (RSP) and Digital Audio Access Protocol (DAAP). This means that you're able to stream the content in iTunes and on your Roku Soundbridge.

Firefly is also able to stream its content through a Java applet. This makes it possible to access all your digital music from any webbrowser. This is a cool feature, it gives you the oppotunity to listen to you tunes when you're away from it could be at work, at a party, on vacation, etc. All it requires is internet access.

When it comes to digital distribution of music there is always a 'but'. In this case the 'but' is that Firefly uses port 3689, which usually is blocked by many firewalls. This is also the case at my company. This is when the beauty of SSH, Secure Shell, comes in handy. SSH allow secure exchange of data between two networked devices using secure channels. The SSH server listens on standard TCP port 22, but you might want to change this since port scanners also knows about SSH. This protocol is often used during network maintenance and is therefore usually open. Through SSH you can gain a secure, encrypted access to your home network. In my case this means, among other things, access to my digital content.

I use a small, but excellent application, called PuTTY. PuTTY is a terminal emulator application which can act as SSH client. In PuTTY you can define secure tunnels by port forwarding to the clients on your home network. Since the SSH server is also running on the same machine as Firefly, I add the following forwarded port: localhost:3689. Through a public-private key arrangement (key generation is provided by PuTTYGen) I can gain access, through SSH, to my home server. When PuTTY has connected to my home server, I can type http://localhost:3689/applet.html in my default browser and enter the required password. Then the Firefly Java applet will launch. Sweet.

I have set up other tunnels, for MediaThomb, MySql, etc. These are all servers running on the same Linux machine. It gets even more beautiful, when accessing other clients on the home network. I don't remember the exact reason, but I once had to access the webpage of my router. I probably had to open a port or give wireless access to someone. You cannot access this webpage from the outside. I set up a tunnel for the IP address of the router and port 80, and bingo, I had access to my router. The funny thing is that I use SSH to gain a secure tunnel through my router and then I accessed the router's IP address from inside the network. That is some sweet stuff.

Hattrick

2009-03-09T10:17:02+00:00

Since 2002 I've been playing an online football manager game called Hattrick. I joined the game while I was still studying and it started as a competition with some of my fellow students. They have since stopped playing the game, but I can't leave it. I don't use the same amount of time that I used to.

One of the great things about Hattrick is that even with a small amount of effort you can enjoy the game. The more time you spend on it, the better is you chance to win, win promotion, titles, etc. When you get beyond the initial learning curve, you only have to use 15 minutes a week to control your team. It is possible to use different approaches to Hattrick. Some people spend alot of time trading players and making money, some study tactics and their next opponents, some people is in there for the community side of Hattrick, etc. Since the start I've had the nursing and training talents approach to the game. This means that I buy young midfielders and train them. When they reach a certain age, I sell them and buy new ones. There is two games a week, Wednesday and Sunday. Midfielders playing these days will receive training. Depending on your tactic, you can at maximum train three midfielders 100% and two wingers will receive 50%. This makes it six midfielders and four wingers will receive training per week. Once every season, usually at the end of the season, I sell the oldest player and buy a young one. The profit made on these will be invested on the remaining positions on the team, the stadium, the youth team, coach, etc.

Back...

2009-03-09T09:48:58+00:00

Since October I've had difficulties finding the motivation and time for this blog, my appologies. I assumed that this will change for time to come.

Arrived in Los Angeles

2008-10-26T13:10:36+00:00

After travelling for 16,5 hours, I've finally arrived in Los Angeles. I'm travelling with a good collegue of mine. We transfered in Amsterdam. I was unlucky and obviously the worlds tallast man got seat right in front of me. He insisted in having his seat laid down, which made the journey somewhat discomfortable. And it wasn't better when large frenchman sat next to me, he had some difficulties in using only on seat... Service was okay and they showed the new Indiana Jones movie, that together with the excitement of soon partipating in years biggest and most important developer conference made the journey worthwhile.

I'll get back tomorrow when I've finished the Advanced Windows Debugging pre-con session.

Selected sessions for PDC 2008

2008-10-17T09:54:43+00:00

With only a week left till Microsoft PDC 2008, I've started to focus on which sessions I'm going to attend.

At the moment my list of sessions looks like this:

Day 1:

Microsoft Visual C# IDE: Tips and Tricks

Learn tips and tricks that will make C# code editing faster and more fun using Microsoft Visual Studio.

Microsoft Visual Studio: Bringing out the Best in Multicore Systems

Learn how to prepare for the new challenges in developing and tuning concurrent applications. Hear about important steps in the creation of or conversion to parallel applications with demonstrations of the parallel performance analysis and optimization tools in the next release of Microsoft Visual Studio. See how to identify opportunities for parallelism and how to exploit those opportunities by choosing applicable coding patterns using existing or future programming models. Finally, watch a demonstration that shows how to optimize parallel code by focusing on common sources of inefficiency such as I/O and synchronization.

Agile Development with Microsoft Visual Studio

Visual Studio has built-in tool support for agile practices such as Scrum, XP, and others. The next version adds practices like test-driven development, continuous integration, and single product backlog. See how these can be applied at scale and across geographies.

Day 2:

Coding4Fun: Windows Presentation Foundation Animation, YouTube, iTunes, Twitter, and Nintendo's Wiimote

Spend time with Coding4Fun authors as they walk through some DIY Development projects: TwitterVote, Wiimote, InnerTube, and BabySmash.

Developing Applications Using Data Services

In the near future, applications will be developed using a combination of custom application code and online building block services, including data-centric services. In this session we discuss advancements in the Microsoft development platform and online service interfaces to enable seamless interaction with data services both on-premises (e.g., ADO.NET Data Services Framework over on-premises SQL Server) and in the cloud (e.g., SQL Server Data Services). Learn how you can leverage existing know-how related to LINQ (Language Integrated Query), data access APIs, data-binding, and more when building applications using online data.

Research: BAM, AjaxScope, and Doloto

See Microsoft Research present new technologies for developing, debugging, and deploying web applications. Hear how BAM can turn a simple specification into a web-based cloud application with the click of a button. Learn how AjaxScope and Doloto automatically instrument and rewrite your web applications' JavaScript code for end-to-end monitoring and optimization.

Day 3:

Parallel Programming for Managed Developers with the Next Version of Microsoft Visual Studio

Come learn how the next version of Visual Studio and the Microsoft .NET Framework can help you write better performing and more scalable applications. We take a tour of new .NET APIs, including the Task Parallel Library (TPL) and Parallel LINQ (PLINQ). We also introduce new features in the debugger that help you quickly identify concurrency issues and visualize the internal state of your application.

Improving Code Quality with Code Analysis

Learn how to catch critical bugs earlier in the development cycle by identifying issues such as buffer overruns and SQL injection attacks before they actually cause a security exploit. The Code Analysis features in Visual Studio help you tune application security, robustness, performance, and more. Learn about Code Analysis (for native and managed) and how to apply it effectively within your team's development lifecycle. Also hear about new features in Visual Studio 2010, including the new Rule Sets feature that makes it easy to manage, configure, and maintain rules.

Improving .NET Application Performance and Scalability

Performance must be considered in each step of the development lifecycle. See how to integrate performance in design, development, testing, tuning, and production. Work with tools and technologies like: static analysis, managed memory profiling, data population, load testing, and performance reports. Learn best practices to avoid the performance pitfalls of poor CPU utilization, memory allocation bugs, and improper data sizing.

The Future of C#

In this talk Microsoft Technical fellow and C# Chief Architect Anders Hejlsberg outlines the future of C#. He describes the many forces that influence and shape the future of programming languages and explain how they fit into C#.

Mono and .NET

See how Mono, the open source implementation of the .NET Framework, offers a platform for developers to leverage .NET in new and unconventional scenarios. Explore many of these innovations: the C# shell and the embeddable, C# runtime "eval"; how and why developers are choosing to embed Mono in applications and games on Windows and other platforms; static compilation with Mono enables .NET to be supported on more devices.

Day 4:

Microsoft .NET Framework: Declarative Programming Using XAML

If you're using Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF), or Windows Workflow Foundation (WF), then XAML is your new best friend! Learn how an entire application-from presentation to data to services to workflow--can be authored using simple, declarative XAML notations introduced in the next version of the .NET Framework. Learn about XAML additions like: support for generics, object references, non-default constructors, and more.

Microsoft Visual Studio: Customizing and Extending the Development Environment

The next version of Visual Studio moves beyond add-ins and packages to unleash powerful new ways to customize and extend the environment. Learn about the Visual Studio extension model-built on a common Microsoft .NET extensibility framework--that makes it easy to customize Visual Studio in new ways. See how to create extensions for the new code editor and project system, and hear how to build your own graphical designers and specialized development environments.

Managed and Native Code Interoperability: Best Practices

Learn when, where, and how to use the various managed to native interoperability technologies. See upcoming features and tools and how they make interoperability even easier.

Live Services: Deep Dive on Microsoft Virtual Earth

Learn about the next major release of Virtual Earth. See the improvements to our parsing and geo-coding engines, clustering, localization, and routing. Hear how the new Virtual Earth Web Services provide server-side support for building location-based applications on desktops and mobile devices.

This list is still due to changes, I'll notify you as soon as the come. As you can read from the above it looks like an intensive week. My experience tells me that I'll be busted when I come back to the hotel in the evening. Besides all the sessions, Microsoft has arranged a number of social activities. The main social event of the weeks is the Universal Studio visit on Wednesday. The park will be open exclusively to PDC attendees.

One new mobile for me...

2008-08-27T09:40:46+00:00

I don't know about you, but when ever I have to buy anything, whether its a car, camera, mobile, laptop, etc., I spend a long time researching the market. It has taken me more than six months to find the right mobile for me. I like reading reviews, finding the right price, comparing products, all the elements that that is required for finding the right mobile for me.

My requirements were:

A mobile with an intuitive and intelligent calendar.
A WiFi and 3G enabled device.
A mobile which can seemless integrate with GMail.

My history of mobile phones is the following, Ericsson GA628, Ericsson T10, Ericsson T65, Sony Ericsson Z200 and Sony Ericsson K750. As you can see, my history tells of faithful support for Ericsson/Sony Ericsson. I've always loved the intuitive UI, solid built and nice design. I wouldn't think of buying a Nokia. A couple of times I've had a Nokia in hand (speaking of blasphemy!) and I've had difficulties finding my way around, I don't find the UI intuitive. Another factor could also be the support for the 'underdog' in Scandinavia...

I can't reject my history of mobile phones so I started looking at Sony Ericsson smartphones that would fulfil my requirements. The first one to undergo a closer look was the Sony Ericsson M600i. It fulfilled my requirements except 3G. I could live with this lack, but it also lacks a camera, which means no MMS, FM radio and TrackID. Which is stuff that I regularly use, they are not primary requirements, but comes in handy from time to time. Last summer Sony Ericsson released their P1i, which is the predecessor of both the M600i but also the P990. Its a 3G enabled mobile with 3.2 megapixel camera, FM radio, semi-QWERTY keyboard and TrackID. It fulfilled all my requirements. I was convinced that this was my new mobile.

During this period I also considered the Sony Ericsson G900. The G900 is like the P1i based on Symbian and UIQ 3.0. It holds a few other applications (which has been ported to the P1i). The main difference is the form factor. The G900 has the same size as the K750. I would prefer the big screen and the semi-QWERTY keyboard.

Also Apple released their new iPhone 3G this summer. This mobile device has conquered the world since its release, and after trying it, it seemed like the obvious choice. I could live with the lack of MMS support, TrackID and FM radio. When Steve Jobs announced the iPhone 3G, he stated the fairly low price of this device as a main feature for the iPhone 3G. Unfortunately, the iPhone is sold in Denmark under license by Swedish Telia. First, Telia has the lousiest 3G coverage available on this planet. Secondly, Telia requires almost $940 for the first 6 month, and that does not include flatrate data transfer, it only includes 300 MB data. I don't know about you, but I can't just throw $940 on the desk for a new mobile.

Therefore I ended up choosing the P1i. When the P1i was realeased in Denmark it included a Wayfinder GPS module and 12 month of maps for free. Now a days it is sold without. Therefore I've spend some time finding a second-hand device with the GPS module. Fortunately, a friend of mine had just invested in the new iPhone 3G. I could therefore buy his for an acceptable price.

I've now had for a couple of weeks and I'm certain that this is the right phone for me. I use GooSync to sync the calendar with Google Calendar, it works perfect. It is so convenient to have your calendar in you pocket. I then use the Push Mail feature of the P1i to receive the headers of the mails on my GMail. I have prioritized the data connections, as WiFi has first priority, then 3G and finally GPRS.

I'll write another port later on about the apps I've installed.

ErrorProvider providing localization difficulties

2008-07-24T12:05:25+00:00

The .Net framework provides several mechanisms for indicating invalid user inputs. You can use a MessageBox to indicate that the state of the control is not valid. A MessageBox can then provide the reason and remedies in the popup dialog box. Having several controls that needs user input this approach can be both cumbersome and intrusive for the user. Other approaches could be a balloon message, using the status panel or giving an audio clue of the invalid input. The .Net framework also provides a control named ErrorProvider, which is a control you can attach to any control that needs validation logic. If the error description string is set, an icon will appear next to the control. Hovering the mouse over the icon, a tooltip will display the error description string.

How to use the ErrorProvider

You can either drag the control from the ToolBox or you can programatically create an instance of the ErrorProvider. To modify the behavior, you can set the following properties:

BlinkRate: This is the rate in milliseconds with which the icon will blink.
BlinkStyle: This property can have one of the following values, AlwaysBlink, BlinkIfDifferentError or NeverBlink.
Icon: The icon that is displayed when the error description string is set.
IconAlignment: Where the icon should be placed relative to the control.
IconPadding: The extra space between the error icon and the control.

Whenever the control's state is invalid, you set the error description string, by using the SetError method on the ErrorProvider control.

if (!validUserInput(textBox.Text))
{
  errorProvider1.SetError(this, "Invalid user input");
}
else
{
  errorProvider1.SetError(this, "");
}

This displays the error symbol next to the control.

Localization difficulties

This is a very useful control for providing non-intrusive feedback to the user. But, there is something that bothers every time I'm using this control. Why do you have to set a 'string' to display an icon?! I don't get it. Its the only control in the .Net framework that uses this "mechanism". Elsewhere its either a Start() method, Enable() method etc.

By combining a string with control display features it is difficult to use localization. In many applications it is evident to provide error descriptors in different languages, but when you cannot set the descriptor in whatever language without displaying the icon, you face additional work. Fortunately there are multiple options to come around this. One neat and clean solution is to create a user control that inherites the ErrorProvider. The new user control holds the local error descriptor string, which you can change whenever you'd like to without displaying the icon. Then you provide an Enable() method which calls SetError with the local string and displays the icon.

class NewUserControl : ErrorProvider
{
  private string errorDescriptor;

  ...

  string ErrorDescriptor
  {
    set
    {
      errorDescriptor = value;
    }
    get
    {
      return errorDescriptor;
    }
  }

  void Enable()
  {
    base.SetError(errorDescriptor);
  }

Another option is to use the ResourceManager. When using the ResourceManager, you add a resource file, .resx file, to your project. Name it this way, Res.XX.resx, where the XXs are you language you're writing strings for, e.g. 'en' for english, 'da' for danish. When using the ResourceManager's GetString() method, you can receive the correct localized string. To use this method across the whole solution, a satellite assembly should be used. I'll make a post of this on another occation.

Registered for Microsoft PDC 2008

2008-07-02T11:02:47+00:00

A couple of weeks ago I pursuited my employer to let me register for Microsoft Professional Developers Conference in Los Angeles. The conference is set to rumble from the 27th - 30th of

October. It will be held at the Los Angeles Convention Center. I've registered for pre-conference as well, which is a day-long session on a specific issue. I've chosen Advanced Windows Debugging, of which I'm having high expectations.

I still haven't made any specific plans for which sessions to attend, but I do know that I'll attend the session where Anders Hejlsberg is given a speech under the title, 'The Future of C#'.

Connected or not...?!

2008-07-01T06:33:02+00:00

A few days back, my wife experienced a weird network issue on her laptop. Usually the laptop receives an IP address immediately on start-up, but this day she received the following network error message: "Limited or no connectivity." What does limited connectivity mean, is there a connection or not? The message did not say anything about the origin of this.

At first I told her to repair the connection to renew the IP address. This has helped in the past. But no luck this time. I then consulted my wireless router to see if there should be anything that could hint a solution. In the device list I could see the correct MAC address, but there were no IP address related to that MAC address. Everytime a repair was attempted the device left the list and came back with no IP address. I reviewed the security settings to see if the wireless filter was messing up things or the DHCP was not working properly.

Well, GIYF (Google Is You Friend), so I started hunting a solution. One solution was that malware had replaced the tcpip.sys file. My tcpip.sys file seemed in fine form. Just to be sure I made a full computer scan with AVG, no luck. I then uninstalled the network driver, and re-installed the latest version. This neither solved the issue. After reading several forum posts I realized that this issue is related to Windows XP Service Pack 2, and the Microsoft patch (KB884020) should do the work. Again, no luck, this patch only seems to work with a specific language version of Windows XP. Another hint I got was to use the Winsock XP Fix, but unfortunately this neither solved the problem. At this point frustration started creeping in on me.

Another hint sent me check out which services there where running (services.msc from command line). I then realized that the DHCP Client was not running. Trying to start it manually gave me an error saying that a dependent service could not be started. Checking the Dependencies tab under the DHCP Client Properties reviled an unknown service. These services should be removed through the registry. I navigated to the following keys in the registry:
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\DHCP

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\NetBT

For each of these, on the right side, double-click: DependOnService
I then deleted SYMTD. In the post where I read this, it also said that it could have NISDRV instead. I was now able to start the DHCP Client service again. After a reboot, the laptop was able to receive an IP address.

So what is this SYMTDI? The SYMTDI service appears to get installed by Norton Antivirus, where it is added as a dependency for DHCP client. The unistall of Norton removes the file: C:\WIndows\System32\Drivers\SYMTDI.SYS, but it does NOT remove the entry for SYMTDI in the DependOnService value for DHCP. So, SYMTDI won't start because symtdi.sys has been removed. I had actually uninstalled Norten Antivirus just before I ran into this issue.

just another blog...?

2008-06-27T08:00:31+00:00

So what am I going to write on my blog?

At this blog I'll be writing about stuff from my job, sparetime, etc. It's going to contain the following elements:

.Net issues
C# snippets
Gadgets of interest
Computer oddities
... and maybe something about football

Hope you'll come back...