Programmer Beekiping

Programmers are like bees :) "You can't exactly communicate with them, but you can get them to swarm in one place and when they're not looking, you can carry off the honey". This quote is from a great article by Orson Scott Card: How Software Companies Die. A must read for all who wants to know how to scarry away good programmers and kill a software business.

Scritchy - CQRS without the plumbing?

There is a new lightwight CQRS framework/library that claims to allow quick building of CQRS applications for beginners or intermediate developers: Scritchy. It's a .NET project. The source code can be found at https://github.com/ToJans/Scritchy. There is also an example of a stocklist app that uses Scritchy: http://scritchyexample.apphb.com/. On that page there is also a video that shows how to build a CQRS application within few minutes using Scritchy. Since there is a widespread opinion that CQRS is hard to understand and an overkill for most applications let's hope that this micro framework can help to encourage developers to delve into CQRS.

Change the Target Framework for all Projects in a Solution

There is a great Visual Studio macro written by Scott Dorman that can be used to automate the changing of the target framework of all projects in a visual studio solution: Visual Studio 2010 and Target Framework Version. The macro is available on Scotts Sky Drive: ProjectUtilities.vb. Download it to \Documents\Visual Studio 2010\Projects\VSMacros80\MyMacros. Then open the the Macro IDE (Alt+F11), add the downloaded .vb file to MyMacros and run it. The solution must be opened in Visual Studio when you run this macro of course. The macro works well with 4.0 as target version (haven't tested it with other framework versions yet). Have fun!

Barrelfish: A New Open Source OS

On 8th july a new operating system called Barrelfish was released by ETH Zurich in Switzerland, with assistance from Microsoft Research. The source code is available in a Mercurial repository at http://hg.barrelfish.org. The system seems to be optimized for multicore architectures.

DDD Exchange 2011

Videos of sessions from DDD Exchange 2011 are now online on skillsmatter.com: DDD Exchange 2011 SkillCast videos. Great stuff! Definitely worth watching! Among others Udi Dahan talking about Composite Applications and Domain Models and showing how to turn monolithic applications with big and cluttered models into composite applications with lean domain models using Bounded Contexts. Also Greg Young showing great things you can do with tests and Event Sourcing: Assert.That(We.Understand).

Speeding up WCF Discovery

With the version 4.0 of the .NET framework Microsoft has enriched WCF with an implementation of the WS-Discovery protocol. Discovery allows WCF services to announce their availability and client applications to find these services at runtime without knowing the endpoint addresses. The WCF Discovery supports two modes the managed and the ad-hoc mode. In the managed mode there is proxy server that manages the information about available services. With the ad-hoc mode you don't even need a centralized server! In this mode services and client applications use multicast messages to announce their availability or to query available services. For more information about WCF discovery see WCF Discovery Overview on MSDN. This site also provides some usage examples.

In my opinion the second discovery mode (ad-hoc) is more interesting for loosely coupled distributed scenarios because you don't have to bother about a central point of failure (the discovery proxy). But playing around with WCF discovery I noticed that it takes some time on the client to discover suitable services. It's not really a big problem because you would usually do it only once e.g. during the application startup and cache the proxy or the endpoint address somehow. But if you only need only one service instance with a certain contract and you don't care which instance it is (if there are many of them) you can considerably reduce the time needed to discover the service address. You just tell the framework that you only need one result. To do so you have to setup the FindCriteria accordingly:

// Create DiscoveryClient
var discoveryClient = new DiscoveryClient(
                            new UdpDiscoveryEndpoint());
var criteria = new FindCriteria(typeof(IContract));
criteria.MaxResults = 1; // we only need one instance!
var findResponse = discoveryClient.Find(criteria);

If there is a service instance wich implements IWantedService the Find()-call would return much sooner than without adjusting the MaxResults property.

Unity: passing constructor parameters.

Unity is a dependency injection container from Microsoft. The version 2.0 is now available for download at codeplex: patterns & practices - Unity. You can use it to reduce dependencies in your .NET applications. Say you want to decouple your 'high level' code from the implementation details of the data access. With Unity you can define an interface like IDataContext and register the actual implementation in the Unity container:

var container = new UnityContainer();
container.RegisterType<IDataContext, SqlDataContext>();

In the 'high level' code you don't have to know the concrete type that implements the data access but just the contract: IDataContext. Unity will resolve the implementation you have registered at runtime:

var dataAccess = container.Resolve<IDataContext>();

Pretty easy so far but what if you want to pass a parameter to the constructor of your IDataContext implementation, e.g. a connection string? Just pass the value you want to be injected as a parameter when registering the type:

container.RegisterType<IDataContext, SqlDataContext>(
  new InjectionConstructor(connectionString));

Unity will pass the value you have defined here to a matching constructor of SqlDataContext when you will request an instance of it.