The Mostly Clean Coder

Brisbane Alt.Net meeting 4

steven.burman — Tue, 28 Apr 2009 07:30:00 +1000

It is time again next Thursday (May 7) for the Alt.Net meeting here in Brisbane. For all of the details please head to the EventBrite registration page - http://altnetbrisbane.eventbrite.com/.

This month we are looking to have a CodingDojo, which will be a great opportunity to put some of the theory into practice. It should be interesting.

Remember that the meeting is held on the first Thursday every month. Tell your friends.

TeamCity Command Line Runner parameters

steven.burman — Thu, 16 Apr 2009 07:06:31 +1000

When using TeamCity as my CI server, my personal preference is to use the Command Line runner. I feel that this gives me the ultimate flexibility, as it is easy to pass parameters to a batch file, and the batch file can in turn be invoked to run a Nant script. It also ensures that my local build experience is as close as possible to what is happening on the build server.

What can I say? I am a control freak when it comes to this stuff.

Recently I was setting up a new build configuration and was having trouble passing in TeamCity environment variables. I tries a stack of variations on the theme but couldn’t seem to crack the right syntax. So here preserved in all its glory is the correct way to pass the environment variables to the command line.

1. Select ‘Add New Variable’ under Environment Variables in your build configuration

2. Define your variable name and value

When saved the variable will be renamed slightly and will appear like…

3. Add the syntactically correct reference to your command line parameters

The trick is to include the '%' symbol markers and also the 'env.' prefix on the name that you defined.

Enjoy!

Brisbane Alt .Net 2

steven.burman — Tue, 03 Mar 2009 10:27:41 +1000

This Thursday is the second meeting for Brisbane Alt.Net. Heinrich has created an EventBrite registration form so that we can better handle RSVP’s and it would be great if everyone coming could take the time to quickly supply your details.

Go to http://brisbanealtnet.eventbrite.com/ to view the event details and register your RSVP.

I hope to see everyone there again, and hopefully some new faces as well.

Wise words on developing junior developers

steven.burman — Sun, 08 Feb 2009 12:56:00 +1000

I was hanging out at InfoQ.com watching some videos about software development. You know – honing my craft. If you want to call it that. Anyway, a highly recommended way to spend your weekends :)

Something struck me as inspired, particularly in relation to a discussion we touched on at the Brisbane Alt.Net meeting around ensuring software quality. It is somewhat loosely related and it relies on analogy, but below is a response by Greg Young to a question regarding his strategy for training junior developers.

I have always believed that the only way to bring up junior developers in any technology - it doesn't matter what it is - is an apprenticeship program. You bring them up from apprentices and they move on, they pair a lot, they get code reviewed a lot, they are put on fake work, just like a real apprentice.

You want to learn how to make tables? Well, you are going to make a lot of tables. Not all of them are going to end up being sold. Sometimes you'll make a leg of a table just for the sake of making a leg on a table. Over time, they will build up the skills and the main way of how to build a lot of skills is by being in other people's code, who did know what they were doing and they will start seeing the good habits of those around them. The place where it fails and it fails all the way back to the pre-industrial age era is when you don't actually have somebody who is a master of their crafts, teaching apprentices.

I thought it was brilliant (as was a lot of stuff in the interview).

And while you are at InfoQ, be sure to check out Damien Katz’s talk about the personal inspirations and challenges about going it alone on his solo project CouchDB. It is a very honest and revealing presentation.

Brisbane's First Alt.Net Meeting

steven.burman — Thu, 22 Jan 2009 11:51:00 +1000

I have been following the Alt.Net mailing list since before it was even called that (remember 'cli_dev' anyone?). It has been of undoubted assitance to my career and in the interests of 'sharing the love', a movement has been made towards building a local meetup group.

Heinrich (a former colleague of mine at Hyro) has done most of the work and now dates have been set and venues booked. Below are the details for the inaugural Brisbane Alt.Net meeting:

Date : Thursday, February 5
Time : 5:30pm for 6:00pm start
Address : Hyro offices - Level 1, 500 Brunswick St, Fortitude Valley (it is upstairs in the Timber Queensland building)
Some food and drinks provided

An RSVP would be appreciated so we know that the room and catering are sufficient. It is enough to leave a comment here as an RSVP and I can pass it on in an official capacity. I hope to see all you locals there.

View Larger Map

RPXLib 0.0.2 released

steven.burman — Fri, 02 Jan 2009 11:26:00 +1000

For those playing along at home I have built a 0.0.2 release for RPXLib. The only change is a small (but significant) bugfix around a misspelt property name.

Thanks to Willie Tilton for noticing the problem. The release can be found here.

Don't forget to check out the project home page at google code.

Announcing RPXLib for .Net

steven.burman — Mon, 24 Nov 2008 15:18:00 +1000

I have long been convinced of the worth of OpenId. I am unsure if it is the ultimate solution - but for now it is definitely the best solution we have (imho). When I heard about RPX, a new integration service from JanRain, my interest sky-rocketed. Previously, the thought of manually integrating into the current OpenId world seemed intimidating to me. RPX solves that problem - hands down.

And what does a developer do when confronted by an open API? He writes a custom wrapper in his language of choice - that's what he does.

So this post announces RPXLib, now available on Google Code. It is a .Net wrapper meant to take some of the pain out of RPX integration by handling most of the boring stuff for you. It presents a simplified service API and returns strongly-typed response objects for you to play with. Be sure to take a peek at the documentation wiki.

It is worth noting that this works well on my machine - but I am very interested to hear from others about the benefit that this provides (or lack of benefits, even more importantly). I figure it takes about 2-3 minutes to read the doco and about another 10 minutes to integrate this into your application. Your mileage may vary and I would love to hear your experiences.

Hitting the open market

steven.burman — Wed, 19 Nov 2008 22:37:00 +1000

As I approach the end of my current contract it appears less and less likley that funding will be available for my renewal. A shame really considering the progress we have made on the new version of the application - which has manifested into a pretty damn nice codebase, even if I do say so myself. But unfortunately administrivia is once again about to become the downfall of a potentially promising project.

So with that news I announce myself available. I am a little shaken by this news but I am positive that some good will come of it. If anyone knows of any suitable local or telecommutable work - please keep me in my mind.

I have uploaded my current CV to my about page.

The inevitable tweet announcement

steven.burman — Wed, 19 Nov 2008 21:57:00 +1000

For those who care to play along - I am now twittering. I don't do it that often, but when I do - pure gold baby!

Not really.

My username is sburman. Check me out here - http://twitter.com/sburman

ASP.Net MVC BeginForm - Beta API Change

steven.burman — Thu, 30 Oct 2008 16:19:00 +1000

The refactoring of the helper method Html.Form in MVC to Html.BeginForm was published in the release notes as a simple renaming. During the beta upgrade process we noticed that a lot of our forms were rendering with blank actions.

If you too are having trouble with your forms, it is worth noting that the API has changed in a subtle but EXTREMELY significant way. The orignal method, whose signature looked like:

public static IDisposable Form(this HtmlHelper helper, string controllerName, string actionName)

Has been changed to read:

public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName)

Note that the parameters have been interchanged! So if you were using magic string-ness to get actions into your forms, you now have a bigger upgrade job than you thought. You will need to switch the parameter strings and put your controller where your action is - and vice versa.

This was tracked down in my team by Simon Sanderson (who we are assured is unrelated to MVC guru Steve). There is a confession of sorts from the MVC team here.

Linq.Specifications - The Project

steven.burman — Sat, 18 Oct 2008 10:25:00 +1000

In the past few weeks I have revisited the specification pattern using Linq. I have teased it, toyed with it and tricked it up. And today I announce the public availability of a project demonstrating my current thoughts. You can grab the solution from Google Code at http://code.google.com/p/linq-specifications.

I have no doubt that improvements can and will be made if this generates any wider adoption. For now, it suits what I am currently working on quite nicely. YMMV.

Below is a class diagram of the current core of the project. Use it as a quick reference but be sure to check out the code for a more in-depth view.

Shortly I will do up a few examples on the project wiki that will flesh out some of the gotchas I have come across already and I need some more testing around some of the elements. For now, however, I just wanted to get this out in the wild. Feel free to comment/flame. I look forward to any feedback.

Basic NHibernate session management with Autofac

steven.burman — Tue, 19 Aug 2008 14:11:00 +1000

Using the container scoping capablity of Autofac makes NHibernate session management a breeze. Obviously this only handles the most basic session-per-request scenario but we know that can cover a large percentage of most peoples requirements anyway. I am sure other containers could get to this functionality as well, but I was blown away by how easy it was aith Autofac. Below is my session management configuration:

            builder.Register<NHibernateInstance>().SingletonScoped();
            builder.Register(c => c.Resolve<NHibernateInstance>().CreateSession()).As<ISession>().ContainerScoped();
            builder.RegisterGeneric(typeof (Repository<>)).As(typeof (IRepository<>)).ContainerScoped();

So the key points are:

Plug in the Autofac HttpHandler for ASP.Net integration by following the instructions here
Have a singleton instance of the NHibernate session factory (housed in my NHibernateInstance class)
Have a method on that singleton registered instance that returns an ISession (CreateSession in my example)
Configure a container scoped instance of the NHibernate ISession, thus ensuring that the created instance will not cross request boundaries
Have the container dynamically inject the ISession into your IRepository implementation

For more information on container scoping in Autofac for ASP.Net web applications check out the Autofac wiki article.

Linq Expressions, The Specification Pattern and Repositories - Part 3

steven.burman — Tue, 12 Aug 2008 12:44:00 +1000

In the previous to parts to this series (here and here) I showed the basic infrastructure framework for using Linq-based specifications with a flexible repository interface. In this article I dig deeper into the Expression based find functionality and it's implementation.

The Goal

Specification based query support on the repository is a great feature for encapsulation of any query logic. My major problem with this approach was the creation of trivial specifications on a per-domain-object basis. This would litter the code with specifications that had very little functionality contained within them. Generally this is not a bad thing but, in this instance, for the sake of maintainabilty and simplicity I wanted a to be able to perform ad-hoc queries.

The solution was to make my repository able to accept queries like :

            var repository = new Repository<Person>(session);
            var people = repository
                .FindAll(p => p.Name == "steve");

The AdHoc specification

Since I have already made the decision that my MatchingCriteria are of type Expression, the AdHoc specification is trivial - but very cool. The implementation looks like :

    public class AdHoc<T> : Specification<T> where T : IEntity
    {
        private readonly Expression<Func<T, bool>> expression;

        public AdHoc(Expression<Func<T, bool>> expression)
        {
            this.expression = expression;
        }

        public override Expression<Func<T, bool>> MatchingCriteria
        {
            get { return expression; }
        }
    }

Simplifying the repository using the AdHoc specification

By utilising this simple but powerful specification class we can simplify the api to our IRepository. We are now able to add a FindOne and FindAll overload that accept Linq based queries in an AdHoc fashion. The implementation is as simple as :

        public IQueryable<T> FindAll(Expression<Func<T, bool>> expression)
        {
            return FindAll(new AdHoc<T>(expression));
        }

This functionality is able to be consumed in the following fashion (satisfying our goal for this task) :

var people = repository.FindAll(p => p.Name == "steve");

Conclusion

In combination with the flexibility built into the IRepository interface we now have a basis for a data access layer with maximum flexibility. Sql queries are created at execution time to reflect the criteria that we have applied through domain specifications - be they concrete or ad-hoc.

Linq Expressions, The Specification Pattern and Repositories - Part 2

steven.burman — Tue, 12 Aug 2008 12:16:00 +1000

In Part 1 of this series I expressed my goal of a powerful Linq implementation for the specifications within my domain. In this part of the series I go into further detail and show I have implemented my repositories to support the pattern.

The IRepository definition

In the code below I have restricted my IRepository to be read-only for the purposes of the exercise. Obviously in reality there would be more functionality defined on this interface.

The use of the specification as a parameter to the Find methods is obvious. The use of an Expression is not so obvious at this stage and I will elaborate on this functionality later in the series.

    public interface IRepository<T> where T : IEntity
    {
        T FindOne(Guid id);
        T FindOne(Expression<Func<T, bool>> expression);
        T FindOne(Specification<T> specification);

        IQueryable<T> FindAll();
        IQueryable<T> FindAll(Expression<Func<T, bool>> expression);
        IQueryable<T> FindAll(Specification<T> specification);
    }

The Repository

Implementing the repository means tying oneself to a particular Linq provider. In my case I chose Linq to NHibernate but switching it out for another implementation should be trivial.

See in the repository implementation that work is able to be integrated with the specifications by calling either SatisfyElementFrom (FindOne) of SatisfyElementsFrom (FindAll) and providing a candidate parameter provided by the Linq provider - in this case Linq to NHibernate provides a Queryable list proxy when we specify session.Linq().

    public class Repository<T> : IRepository<T> where T : IEntity
    {
        private readonly ISession session;

        public Repository(ISession session)
        {
            this.session = session;
        }

        public T FindOne(Guid id)
        {
            return session.Get<T>(id);
        }

        public T FindOne(Expression<Func<T, bool>> expression)
        {
            return FindOne(new AdHoc<T>(expression));
        }

        public T FindOne(Specification<T> specification)
        {
            return specification.SatisfyingElementFrom(session.Linq<T>());
        }

        public IQueryable<T> FindAll()
        {
            return (from t in session.Linq<T>() select t);
        }

        public IQueryable<T> FindAll(Expression<Func<T, bool>> expression)
        {
            return FindAll(new AdHoc<T>(expression));
        }

        public IQueryable<T> FindAll(Specification<T> specification)
        {
            return specification.SatisfyingElementsFrom(session.Linq<T>());
        }
    }

Conclusion

In this article I have shown an implementation of my repository facilitated by the use of Linq to NHibernate. The most striking part is the simplicity of the code. We have nicely seperated out our query concerns and the repository provides us with flexibility and also efficiency thanks to the power of Linq.

Linq Expressions, The Specification Pattern and Repositories - Part 1

steven.burman — Tue, 12 Aug 2008 11:23:00 +1000

Disclaimer : I am unsure if what I am about to show here is a bridge too far in terms of bastardising the specification pattern ... it very well may be the case. However, Linq has provided a new paradigm that needs to be embraced, and sometimes that requires the tweaking of existing pratices and patterns.

Background Info

For some background on this article I recommend reading the following primers. I would never have to got to where I did without them. Please check out:

Implementing the Specification Pattern via Linq
[http://ubik.com.au/article/named/implementing_the_specification_pattern_with_linq]

Linq, the Specification Pattern and Encapsulation
[http://www.iridescence.no/post/Linq-the-Specification-Pattern-and-Encapsulation.aspx]

Implementing ORM-independent Linq queries
[http://rabdullin.com/implementing-orm-independent-linq-queries/]

The Goal

I wanted a flexible way to leverage the deferred execution power of Linq in my application. The logical place for this to occur was deep in the data access layer at the repository level. Also, as always, I wanted the ability to encapsulate my query logic into specifications and this became the real integration challenge with linq.

Specifications are easy to apply to existing in-memory collections - they fit that paradigm well. But at the lower level I knew linq could provide more power than what was previously possible with the traditional specification pattern. I wanted a way to leverage the deffered execution of Linq to drive my specifications for querying.

The Specification Class

My specification class is not dependent on any particular Linq to SQL provider. I chose to use Linq to NHibernate but that was a personal choice. I am quite sure that a switch to Linq-To-SQL would result in no modifications to any existing specifications. This provider agnostic specification implementation is a nice example of what a common language paradigm like Linq can provide.

Notice that the base abstract specification class handles all of the matching work for the specification. Any inheriting specification simply needs to specify their relevant MatchingCriteria. The SatisfyingElementFrom method (singular) simply enforces that a single result is returned. The bulk of the work is done in SatisfyingElementsFrom, which actually applies the criteria. Note that it is critical that the Matching criteria is of type Expression. This ensures we have access to the expression parsing power of Linq. Simply using a Func or a Predicate will break this implementation.

    public abstract class Specification<T> where T : IEntity
    {
        public abstract Expression<Func<T, bool>> MatchingCriteria { get; }

        public T SatisfyingElementFrom(IQueryable<T> candidates)
        {
            return SatisfyingElementsFrom(candidates).Single();
        }

        public IQueryable<T> SatisfyingElementsFrom(IQueryable<T> candidates)
        {
            return candidates.Where(MatchingCriteria).AsQueryable();
        }
    }

A simple specification

Below is the code for a simple specification implementation. Notice how it has no responsibility apart from specifying the criteria that it represents.

    public class PersonById : Specification<Person>
    {
        private readonly Guid id;

        public PersonById(Guid id)
        {
            this.id = id;
        }

        public override Expression<Func<Person, bool>> MatchingCriteria
        {
            get { return p => p.Id == id; }
        }
    }

Conclusion

So far I have demonstrated how to implement specification classes that have the potential to harness the power of Linq. Please follow the other parts of the series to see further implementation details - specifically the repository.

Collapsing and Expanding Regions in Visual Studio

steven.burman — Wed, 06 Aug 2008 13:34:00 +1000

Whilst there is still ongoing debate about the merit of using regions, I have to admit that I have no strong leaning towards any side of the argument. However, I do need the ability to hide and show all of the regions in a class quickly and easily.

A trick that I first picked up when using VS2003 still works for me today and can quickly push you towards indifference in the debate as well.

This article written by Roland Weigelt (in 2003!) lists the code for some macros that can be simply assigned to a keyboard shortcut to help manage any regions you come across. Because, regardless of your stance on the issue, you will always come across regions somewhere.

Below I have assembled a short guide to installing and using the macros -

1. Copy all of the macro source code from the original article but only the module code itself (i.e ignoring the import statements and module declaration - these are added by VS automatically when you create a new module). The code below has been stolen from the original article and reproduced here for convenience.

' Toggles the current region surrounding the cursor
    Sub ToggleParentRegion()
        Dim objSelection As TextSelection
        objSelection = DTE.ActiveDocument.Selection
        Dim objPosition As EnvDTE.TextPoint
        objPosition = objSelection.AnchorPoint
        objSelection.SelectLine()
        If (InStr(objSelection.Text.ToLower(), "#region") <> 0) Then  ' Updated 14.08.2003
            objSelection.MoveToPoint(objPosition)
            DTE.ExecuteCommand("Edit.ToggleOutliningExpansion")
            DTE.ActiveDocument.Selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn)
        ElseIf (objSelection.FindText("#region", vsFindOptions.vsFindOptionsBackwards)) Then
            DTE.ActiveDocument.Selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn)
            DTE.ExecuteCommand("Edit.ToggleOutliningExpansion")
            DTE.ActiveDocument.Selection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn)
        Else
            objSelection.MoveToPoint(objPosition)
        End If
    End Sub

    ' Expands all regions in the current document
    Sub ExpandAllRegions()
        DTE.ExecuteCommand("Edit.StopOutlining")
        DTE.ExecuteCommand("Edit.StartAutomaticOutlining")
    End Sub

    ' Collapses all regions in the current document
    Sub CollapseAllRegions()
        ExpandAllRegions()
        Dim objSelection As TextSelection
        objSelection = DTE.ActiveDocument.Selection
        objSelection.StartOfDocument()
        While (objSelection.FindText("#region"))
            objSelection.StartOfLine(vsStartOfLineOptions.vsStartOfLineOptionsFirstColumn)
            DTE.ExecuteCommand("Edit.ToggleOutliningExpansion")
            objSelection.StartOfDocument()
        End While
        DTE.ActiveDocument.Selection.StartOfDocument()
    End Sub

2. In Visual Studio (VS2008 in this example) open the Macros IDE (Alt-F11 or under Tools -> Macros)

3. In the Macros IDE, add a new macros module called RegionTools by right-clicking on MyMacros and select Add -> Add Module

4. Paste the code copied from above inside the module definition

5. Save and the close the Macros IDE

6. Now assign your keyboard shortcuts. Open the Options menu by opening Tools -> Options in Visual Studio

7. Under Environment in the tree menu (left hand side of the Options dialog), select Keyboard

8. Filter all of the available commands by typing RegionTools in the filter box

9. You should now see the 3 new macros that you added to the Macros IDE. And now you can assign them keyboard shortcuts at your whim. Personally I only use CollapseAllRegions (mapped to Ctrl+Shift+Num -) and ExpandAllRegions (mapped to Ctrl+Shift+Num +). But they are both of enormous benefit.

Now all that is left is for someone to tell me this has been built in to VS2008!

TDD Screencast 2 has crashed and burned

steven.burman — Tue, 29 Jul 2008 16:09:00 +1000

No good deed goes unpunished and my attempt to create a second screencast adheres strongly to that rule.

Late last week I stayed up and recorded 45 minutes worth of footage only to discover that the wrong microphone input was selected! This means that I had TDD video with no TDD soundtrack. To soften the blow I thought I would save the video and maybe record a voiceover in a seperate session.

Strike 2! Camtasia crashed whilst saving the video file so I was left with precisely no fruits from my labour.

I intend to get around to it eventually but have to admit that my motivation has dipped significantly.

Test Driven Development Screencast (1 of x)

steven.burman — Sun, 13 Jul 2008 15:23:00 +1000

So after a lenghty layoff and many broken promises I am back into the blogging fold with a brand new screencast. I have been keen to demo Camtasia for a while and am pretty happy with the results. And it should make for a better end user experience because I am not a very good writer!

The video shows off some of the tricks, tools and techniques for TDD in .Net. It was cool to play with Gallio for the first time and I am loving its integration with Resharper. Very nice.

For best result watch the video in its original size (the quality if you do that is surprisingly good). To access the original size -

Click the full screen button in the top right corner.
Click the menu button in the bottom left corner.
Then in the menu along the top of the screen click 'Original size'.

Alternatively, if you prefer to watch the video offline you can download from Viddler by clicking here.

Windsor Container AddComponentInstance bug

steven.burman — Thu, 14 Feb 2008 10:12:00 +1000

I am reliably informed that this error has been fixed on the trunk but it is most definitely still occurring in the assembly version that I am referencing. Assuming that others arent working from the latest version of the trunk I thought it would be worth recording here both the bug and the workaround.

In my tests I typically attempt to mock my dependencies. Then I inject the mock into the container so that it is retrievable by my calling code. But alas, calling AddComponentInstance with the following method signature failed.

AddComponentInstance<IExceptionHandler<NotImplementedException>>(mockHandler);

The error reported :

No component for supporting the service Project.Web.Controllers.ExceptionHandlers.IExceptionHandler`1[[System.NotImplementedException, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] was found Castle.MicroKernel.ComponentNotFoundException

The workaround is to simply use a different method signature which assumedly under the covers registers the component and the instance correctly. See:

AddComponentInstance<IExceptionHandler<NotImplementedException>>( typeof(IExceptionHandler<NotImplementedException>), mockHandler);

Ta da.

Is today MVC day?

steven.burman — Fri, 07 Dec 2007 22:30:00 +1000

After a barrage of blog posts and primers from the guys on the other side of the fence, it appears that today might be the day that System.Web.MVC is released.

To say that I am excited would be an understatement. Mainstream acceptance and support (from the big machine) means that we can now propose this style of development without fear of recrimination from cowering/OSS averse decision makers. To me this is the most powerful component of this release as it is by no means revolutionary from a technology standpoint.

I have the perfect project for MVC sitting in the wings and I can now unleash. Thanks Microsoft for having the vision to support the concepts that we developers hold dear. I accept that things from MS will never be on the bleeding edge, but at least they are beginning to get a lot closer.

I can't wait. Bring on the CTP!