http://brendanforster.com/ brendan forster 2013-05-20T12:27:05+00:00 Brendan Forster me@brendanforster.com Should I make this object a singleton? 2013-05-20T00:30:00+00:00 http://brendanforster.com/blog/should-i-make-this-object-a-singleton.html Note: This is just a first pass on the post, as I need to touch on various tools I've used in the past to identify these constraints. But let's start with the concepts.

Someone asked me a question yesterday along the lines of, well, this:

Singletons? My first instinct was to reach for the hose and dampen such discussion down immediately before someone got hurt.

But no, that's not right. I need to explain myself.

So I wanted to put together a simple guide on how to determine when the Singleton pattern is a suitable use case - yes, it gets a bad reputation due to misuse, but there are some scenarios where it does add value (and is often necessary).

How expensive is it to create?

Imagine you have a database connection - say SqlConnection - and you create an instance of it to connect to a database?

TODO: show windbg object dump of a SqlConnection object

Inside this SqlConnection object you should see a bunch of underlying resources - these are the components which make the magic happen when you perform a "SELECT * FROM Table" in your application.

Many of the objects you create in your application are probably simpler than this - classes to hold data, for example - but once you start interacting with the underlying platform and identify various bottlenecks in your applications understanding what resources are hiding where is invaluable knowledge.

The other thing to keep in mind with objects is what they encapsulate. If your classes interacts with the network, storage or attached devices, for example, you are likely to face specific rules with how you use access these resources.

An example: if you're ever making concurrent web requests to a specific domain, .NET will actually throttle you to two concurrent requests. You can change this if you know where to look but the defaults are designed to be "good enough" for most scenarios.

Another example: database connection pools - a finite number of connections which are managed and reused over the lifetime of an application - instead of arbitrarily creating, using, and then destroying connections each time we need them.

What about my memory footprint?

So assuming the above constraint isn't affecting your classes, you might be able to get away with creating objects whenever necessary.

But what if you're making a mobile app? Memory becomes a significant constraint on any mobile applications - and the more moving parts you have in a mobile application, the more you need to optimise to reduce the impact of those moving parts.

I don't need to worry about that, my stack has generational garbage collection (GC).

But that's not actually a solution - more like a crutch. GC isn't a free lunch - it's overhead that you're now invoking periodically (technically GC will run whenever it needs to, which is often at the worst possible time due to memory pressure) because you were lazy with how you structured your application.

TODO: demonstrate .NET performance counters around GC, with a sample that does stupid things

What about multi-threaded code?

This is the hardest part to discuss, because multi-threaded code is hard. Really hard.

If your object is immutable (that is, you can call the same function on an object as many times as possible until the end of time and you'll always get the same result) then it might be possible for it to be used as a singleton object.

TODO: discuss the simplest gotcha - two threads entering a function at the same time

TODO: discuss where basic locking will cause you different sorts of headaches

TODO: what would Ayende do?

But I just want to use it as a global object

Please don't. This introduces unnecessary coupling into your application, at the value of saving a few keystrokes.

TODO: explain the god object pattern and why it is bad

TODO: outline where this is utterly unavoidable and you need to suck it up and just God Object that sucker

What's the damn answer, Brendan?

Ok, so if you've read this far - I thank you.

So when should you consider wrapping an object in the singleton pattern?

  • Firstly, beware of how multi-threading actually works - no, the TPL is cheating.
  • If it's expensive to create, consider it.
  • If it's touching underlying system resources, consider it.
  • If you need to optimise for memory usage, consider it.

Feedback is Welcome

Did I miss something? Get something wrong?

Leave a comment and let me know.

]]> Yet Another "Add LESS to your ASP.NET MVC Project" Post 2013-05-12T13:00:00+00:00 http://brendanforster.com/blog/yet-another-implement-less-in-aspnetmvc-post.html You've probably done this too

If you kicked off a new ASP.NET webapp recently, somewhere after File -> New Project you probably got excited about using a CSS preprocessor like LESS or SASS because:

  • nobody writes CSS directly anymore
  • it's supposed to make your life easier
  • something with unicorns and rainbows

This post isn't about that. This is about the little quirks I had to jump through to get a usable development environment for writing LESS code.

NOTE: This uses the bundling features in MVC4. If you're using a version of MVC which is older than that, go upgrade. Bundling is so nice.

Step 1 - The Installer-ation

To NuGet!

PM> Install-Package dotLess

Go run that in a new project. I'll wait.

Done? Great, so go write a little LESS code (I've just called this file sample.less for the purposes of this demo):

@color: #4D926F;

.site-title a {
  color: @color;
}
h3 {
  color: @color;
}

And then include it in your Razor layout...

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title>@ViewBag.Title - My ASP.NET MVC Application</title>
        <link href="~/favicon.ico" rel="shortcut icon" type="image/x-icon" />
        <meta name="viewport" content="width=device-width" />
        @Styles.Render("~/Content/less")
        @Scripts.Render("~/bundles/modernizr")
    </head>
    <!--  and more stuff here obvs -->

But you're application doesn't know about how it can transform LESS code into CSS. That's where bundles come in.

Step 2 - Dude, where's my bundle?

Bundles are an easy way to merge and minify resources in your application (such as JavaScript files and CSS stylesheets). In addition to being a lovely convenience, it's actually a great way to improve site performance (fewer HTTP requests, reducing size of response payload).

So go back to NuGet and use this:

PM> Install-Package System.Web.Optimization.Less

And add your bundle to the appropriate location within BundleConfig.cs

public class BundleConfig
{
    public static void RegisterBundles(BundleCollection bundles)
    {
        // NOTE: existing bundles are here 

        // add this line
      bundles.Add(new LessBundle("~/Content/less").Include("~/Content/*.less"));
    }
}

Bundles support a limited subset of wildcard syntax, but you can include multiple folders within a bundle.

So this LessBundle gives you the ability to combine and minify files when running the application in <compilation debug="false" /> mode, and it takes care of transforming LESS code into CSS - without needing to update the layout everytime you add a new file to the project.

Editor's note: I wasn't aware of this package on the last runthrough - instead I found this LessBundle code in a gist from @benfosterdev which looks very similar to the source for that package, so I'll give him kudos for it.

Step 3 - But wait, there's more!

But what about when testing locally? Well, bundles are rather lazy in development mode:

  • no minification
  • no bundling
  • in fact the files just appear as LESS resources to the browser

So you still need to tell your application how it can serve LESS files to the browser, independent all this bundling work.

dotLess will apply transforms to your web.config when you install it through NuGet to provide handlers which can process a specific LESS file:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="dotless" type="dotless.Core.configuration.DotlessConfigurationSectionHandler, dotless.Core" />
  </configSections>
  <!-- these probably do something useful -->
  <dotless minifyCss="false" cache="true" web="false" />
  <system.webServer>
    <handlers>
      <!-- for IIS7+ -->
      <add name="dotless" path="*.less" verb="GET" type="dotless.Core.LessCssHttpHandler,dotless.Core" resourceType="File" preCondition="" />
    </handlers>
  </system.webServer>
  <system.web>
    <httpHandlers>
      <!-- for IIS6 -->
      <add path="*.less" verb="GET" type="dotless.Core.LessCssHttpHandler, dotless.Core" />
    </httpHandlers>
  </system.web>
</configuration>

Editor's Note: when I last ran through these steps I didn't get these config transforms applied on install. I was really looking forward to a rant here because I'd gone through the hard yards to add these handlers by hand - but of course it worked this time.

So these handlers allow you to compile an individual LESS file and see the results in the browser.

Oh, and don't forget to remove the handlers in your config transforms when you go to production (this is an example of the Web.Release.config transforms file).

<?xml version="1.0"?>
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
  <system.web>
    <compilation xdt:Transform="RemoveAttributes(debug)" />
    <httpHandlers>
      <add xdt:Transform="Remove" xdt:Locator="Match(type)" path="*.less" verb="GET" type="dotless.Core.LessCssHttpHandler, dotless.Core" />
    </httpHandlers>
  </system.web>
  <system.webServer>
    <handlers>
      <add xdt:Transform="Remove" xdt:Locator="Match(name)" name="dotless" path="*.less" verb="GET" type="dotless.Core.LessCssHttpHandler,dotless.Core" resourceType="File" preCondition="" />
    </handlers>
  </system.webServer>
</configuration>
]]> Custom server headers - bad for your health? 2013-05-04T06:00:00+00:00 http://brendanforster.com/blog/custom-server-headers-bad-for-your-health.html I just finished another project with a customer which involved a pentest (penetration testing) review for their upcoming launch. And as usual, this involves hiding a bunch of headers that IIS and ASP.NET serve up on each response.

In particuar:

  • Server (from IIS)
  • X-Powered-By (from IIS)
  • X-AspNet-Version (from ASP.NET)
  • X-AspNetMvc-Version (from ASP.NET MVC)

Why? Because sending these headers in your response exposes information about your server to clients (including the bad guys). Troy Hunt explains it in more detail but our approaches differ slightly:

  • I've just focused on the ASP.NET stack
  • this approach doesn't require any changes to IIS
  • I don't care about IIS 6 (it shipped with Windows Server 2003, so that'll be 10 years soon!)

NuGet all the pain away

So I was going to write a NuGet package to solve this problem but I was then pointed to this package from David Duffett - Dinheiro.RemoveUnnecessaryHeaders. Thanks for saving me the time, David!

So go grab it from NuGet:

PM> Install-Package Dinheiro.RemoveUnnecessaryHeaders

You can do this by hand if you want - in fact, I'll explain the package behaviour here.

First, it applies a config transform to remove the X-Powered-By and X-AspNet-Version headers:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.web>
    <httpRuntime enableVersionHeader="false" />
  </system.web>
  <system.webServer>
    <httpProtocol>
      <customHeaders>
        <remove name="X-Powered-By" />
      </customHeaders>
    </httpProtocol>
  </system.webServer>
</configuration>

Next, we use WebActivator to hook into the PreApplicationStart event to run some custom behaviour:

[assembly: WebActivator.PreApplicationStartMethod(typeof(MyWebApplication.App_Start.RemoveUnnecessaryHeaders), "Start")]

This method takes care of two things. The first is disabling the X-AspNetMvc-Version header, and then registering a module to remove the Server header.

public static class RemoveUnnecessaryHeaders
{
    public static void Start()
    {
        DynamicModuleUtility.RegisterModule(typeof(RemoveUnnecessaryHeadersModule));
        MvcHandler.DisableMvcResponseHeader = true;
    }
}

And there's an important note about this code - it's only supported for IIS7+. Just a heads up.

public class RemoveUnnecessaryHeadersModule : IHttpModule
{
    public void Init(HttpApplication context)
    {
        // This only works if running in IIS7+ Integrated Pipeline mode
        if (!HttpRuntime.UsingIntegratedPipeline) return;

        context.PreSendRequestHeaders += (sender, e) =>
        {
            var app = sender as HttpApplication;
            if (app != null && app.Context != null)
            {
                app.Context.Response.Headers.Remove("Server");
            }
        };
    }

    public void Dispose() { }
}

That PreSendRequestHeaders event is the last opportunity ASP.NET gets to intercept the response (including reading headers set by IIS) before it gets sent to the client.

Defaults are good - except when they're not

Just about all of the teams I've worked with have had this requirement as part of their go-live checklist (or raised by a security review) which made me think...

Why aren't these headers disabled by default?

And why does it require changes in so many different places in IIS and ASP.NET?

A footnote on X- Headers

If this is the first you are reading about this issue, HTTP headers which are prefixed by X- are custom headers which are not part of the HTTP spec. It allows servers, frameworks and applications to include custom metadata in HTTP requests and responses.

My favourite example of this is Twitter's Rate Limiting API, which sends custom headers with each API call that an application makes:

X-RateLimit-Limit: 350
X-RateLimit-Remaining: 350
X-RateLimit-Reset: 1277485629

As a consumer of Twitter's API, my application would need to look for these headers and understand the values.

Recently Cristian pointed me at RFC 6648 which, as it clearly states, is about:

"Deprecating the "X-" Prefix and Similar Constructs in Application Protocols"

It's very RFC-y in it's wording - and it's also only a year old which is really young in RFC time - but it's definitely something to keep in mind when designing custom headers for your application to serve or handle in the future.

]]> Internet Sabbatical - An Experiment 2012-11-26T12:00:00+00:00 http://brendanforster.com/blog/experiment-internet-sabbatical.html As this year comes to a close (a few more things to do yet) I wanted to try something different over the holiday season - an internet sabbatical.

A What?

From 21 December (when I jump on a plane for the holidays) to 6 January (when I jump on a plane to come back for work) I plan to "go to ground" and avoid the internet.

Why?

I am burned out - plain and simple.

I would love to just "power on through" like it wasn't a problem but I've been doing that for the past few weeks already and its not changing much.

Plus I intend to spend a bunch of time here:

Doing stuff like this:

And it has terrible phone reception anyway (yay!)

The Ground Rules

Here's the low-down:

  • No Internet Access
  • No Twitter/Facebook
  • No checking emails
  • No computers or things that will let me code

But I won't go completely off the reservation:

  • Phone - to keep in contact with friends and family, but that's it
  • Xbox - I'm keen to play some Assassin's Creed III (or other games) so that's included

And given I won't have technology to report on my progress (pen and paper perhaps?), you'll just have to wait and see how I go.

Happy Holidays

If you need to get in touch with me over the holidays, there are "old-school" methods (see above) but otherwise I wish you all a happy and safe holiday season and we'll see you all in 2013!

]]> What's my secret? An unoffical unconfirmed guide 2012-09-23T12:30:00+00:00 http://brendanforster.com/blog/unofficial-unconfirmed-awesome-guide.html Introduction

After surviving TechEd Australia - as well as hitting some important deadlines for a client - I was looking forward to getting back into various side-projects again now that things are coming back to (realtively) normal.

I fired off an email looking for tips from my colleagues what they do to help get creative, and one of the replies I got back was this:

I find the third question silly coming from you. You are one of the the most productive and creative people I know and I wish I knew your secret to it.

Sorry mate; but you don't get to be an MVP, a main member on Code52, talk at conferences and so on and then ask others how they are productive and creative :p

Share your secret already ;-)

So I owe someone a blog post to explain myself.

Brendan's Unofficial Unconfirmed Guide To Being Awesome

First up, some warnings:

  • This is me speaking from my experiences only.
  • I will often suggest things which I do not do. Yes, that makes me appear hypocritical. No, it is not intended.
  • Please consult with a medical professional before taking any of the below advice.
  • This is all subject to change.

Without further ado, let's dive in...

Make time for it

While I appreciate that there are many developers who are happy "dark matter" developers, I've always seen a correlation between awesome developers and developers who will spend time improving themselves outside of work hours.

Don't feel bad if you're not someone who obsesses over code outside of work. But don't feel that it's out of reach.

Not sure where to start? Start small. Set aside a half hour once a week.

Can't find time in the evenings? Why not try and get up earlier instead?

Note: As many people who know me will testify, I am not a morning person. I'll generally find a couple of evenings each week to hack on various things late into the night - it's an old habit I still haven't shaken from my university days - as that's when things are quieter and I can focus better on things. Your milage will vary.

Set yourself goals (even small ones)

To ensure you're making the best of youur spare time, set some goals up front to ensure you work towards something tangible and useful. Starting small with your goals will help.

To illustrate this, here's a few goals which I would like to work on over the coming weeks/months:

  • learn about Neo4J and graph database concepts by building a proof-of-concept accounting webapp
  • learn about DirectX and de-rust on my C++ skills by building a Windows 8 app

See how they can be considered daunting goals?

Let's break that first item down a bit:

  • Read up on concepts behind graph databases
  • Getting Neo4J setup on my local machine
  • Experimenting with working with Neo4J and the REST API
  • Getting a simple webapp setup to interact with Neo4J (Ruby/Python?)
  • Sketching out the app idea
  • Build out a small piece to demonstrate the app

You get the picture - take a big piece of work and break it down into manageable chunks.

By tackling something in chunks you also get a number of other benefits:

  • be able to demonstrate learning earlier on (e.g. interacting with an API first before building the app)
  • get feedback without investing significant amounts of time (and put it aside if its not fun)
  • be able to work on multiple goals at the same thing (rather than procrastinating because you're stumped on something)

Of course it looks like Dave Tchepak beat me to the punch on this with a more detailed post earlier in the year, so I'll defer to him on this.

Don't just read and watch

It's easy to sit down and read some blogs on a topic and think to yourself "Well that was easy!" It's easy to watch some screencasts on a subject and think "I know X now, great!"

I want to challenge you to go beyond the passive learning and build something based on what you've learned. The size of it doesn't really matter, but I've always found it important to take the things I've learned and apply them to the real world.

This helps in several ways:

  • demonstrating that I was paying attention
  • leaving the hand-holding of the blog posts/screencasts and work without that safety net
  • reinforcing the learning while it is fresh in my mind

I love blog posts and screencasts, but these days I try and balancing consuming posts/screencasts and creating things.

Don't be afraid to fail

It can be daunting when faced with something completely new and unfamiliar. With the amazing pace that technology and software moves at these days, it's impossible to keep up with everything. And that's OK.

Focus on what you could use at work.

Focus on what you're interested in.

Focus on what might make you a better developer.

Dive in, try something, don't be afraid to make a mistake. Because you will. And that's OK.

Just make sure you learn from your mistakes, or that you make different mistakes.

Here's a couple of little experiments I've worked on in the past that haven't come to fruition (yet?):

I could weep for things that didn't eventuate, but life's too short.

Share all the things!

And how will we know how awesome you are if you don't tell us?

After parking my blog ages ago (mostly because I was never really "happy" with it and I'd compulsively tweak things), I've started to come around to Hanselman's words: "Every developer should have a blog". I'm a habitual Twitter user and thoroughly enjoy the medium for what it is, and I know that I spend time which I should be spending on blogging.

To compensate for this, I publish a lot of my stuff on GitHub. Yeah, its lazy. But its out there at least. Even this blog is public - and its just a static site generated using Jekyll and hosted on Heroku.

Don't be afraid to write - for example, my last post on git aliases got several "Hey you missed X" comments on it because I wrote it in a rush and missed a couple of details with the end script.

If people only blogged perfect posts I'd never end up blogging anything.

Feedback

I'm running out of words and I bet you guys are getting tired of me over-sharing, so I'll tie this one off here. What have I missed? What did I say wrong? Let me know in the comments.

]]> Why You Should Care About Git Alias 2012-09-16T12:30:00+00:00 http://brendanforster.com/notes/git-alias.html Why do I need alias?

One of my favourite bits of "feedback" from Mercurial users is that "you don't need to type out the full command with hg - git is dumb" or something like that. While they're not totally incorrect here, they are comparing the out of the box experiences between git and hg.

Mercurial will recognise shorthand for commands when you type enough characters to distingush the right command, like:

hg com -> hg commit
hg sta -> hg status
hg sum -> hg summary
hg ci -> hg commit

That's right, hg does aliases too...

Git however will scream at you when you mistype a command. And you will swear in return (either at yourself or at git).

So to save yourself from screaming in the future, you can customise git to recognise custom commands. It will save you so much time.

Aliases are stored per-user in the .gitconfig file - or in the .git/config file for a repository. All the below scripts will install in the global config file - but you can drop the --global parameter if you don't want that behaviour.

Adding shorthand as aliases

Here's some shorthand commands for the common git tasks:

# git st
git config --global alias.st "status"   
# git co 
git config --global alias.co "checkout" 
# git ci
git config --global alias.ci "commit"   
# git br
git config --global alias.br "branch"   
# git df
git config --global alias.df "diff"     
# git lp
git config --global alias.lp "log -p"

These are some of the common examples from the here.

Customising existing commands

My favourite example of this is a prettier output from git log - so you can see at a glance the activity on the branch you are currently working on:

# git lg
git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%Creset' --abbrev-commit --date=relative"

Of course, someone far smarter than me wrote this one...

A few simpler ones:

# git com -> checkout master
git config --global alias.com "checkout master"

# git fe -> fetch latest changes
git config --global alias.fe "fetch origin"

# git hr -> hard reset state of master
git config --global alias.hr "reset origin/master --hard"

# git me -> get my user name
git config --global alias.me "config user.name"

And you can even embed scripts into an alias. Here's a couple of simple scripts to see what commits have been added for today (by me any by others):

# git today
git config --global alias.today "!git all --since='12am' --committer=\"`git me`\""

# git today-all
git config --global alias.today-all "!git all --since='12am'"

# git bn -> get current branch name
git config --global alias.bn "!git for-each-ref --format='%(refname:short)' `git symbolic-ref HEAD`"

Do you see where we're going with this? :)

Mashing commands together

Remember how in my last post I mentioned a rather verbose workflow for merging in changes?

Well let's take it away with one simple command: sync

# git sync
git config --global alias.sync "!git update && git co master && git pull && git co @{-1}"

But that's rather basic - it doesn't actually rebase my branch that I'm on.

Let's do a slightly different command: resync

# git resync -> sync repository and rebase current branch    
git config --global alias.resync "!sh -c 'BRANCH_NAME=$(git bn) && git com && git fe && git hr && git rebase master $BRANCH_NAME'"

Note how this one uses aliases defined earlier in the post for readability? Yeah, it's rad.

I'm lazy, give me the gist of it (lol pun)

I'm checking some other git repos I have lying around to ensure I have all my aliases in one spot, but in the meantime open your ~/.gitconfig file (check C:\Users\{username}\ if you're on Windows) and paste these values under the [alias] node. If the [alias] node doesn't exist, create it.

Got a cool alias you want to share? Fork the gist above!

]]> My Git Habits 2012-09-16T06:30:00+00:00 http://brendanforster.com/notes/my-git-habits.html First up, a disclaimer: This is just one person's opinion and should be treated as such.

If you workflow is similar, that's great. If you workflow is radically different, that's great too. With things like git its very easy to have different workflows, so I'll just be speaking from my experiences here.

Introduction

Generally speaking, my git flow is based off the documentation for contributors to the NancyFx project. When working on features, this is my high-level flow:

  1. Create a local branch for the feature
  2. Work on your feature and get it reviewed -- you do code reviews, right?
  3. Merge the changes into master
  4. Push the changes up to the remote repository

How does that look from the comamnd line?

  • git checkout -b ReallyCoolFeature master
  • ... stuff gets done ...
  • git add -u . -- add all removes and modifies to the staging area
  • git add . -- add new files to the staging area
  • git commit -m "#1234 implemented" -- associating commits with work items is awesomely helpful
  • git checkout master
  • git pull origin/master
  • git merge ReallyCoolFeature
  • git push origin master

Note: Yeah, I like to be explicit with my remotes and branch names in these commands. Haters gonna hate.

But that's all fairly straight-forward and not really leveraging the new states of mind that git makes possible.

Rebase all the things

Where git truly comes into its own is with rebasing. For those who aren't familiar with it, rebasing allows you to change the history of a branch. This is generally considered very bad™ to do with public repositories but when you use it only locally it gives you so much control over everything.

For example, have you ever:

  • used a branch for multiple, disparate tasks that you wish you could reorder for readability?
  • accidentally forgot to save a file and had to spread a task over multiple commits as a result?
  • wanted to update an old branch to the latest changes and avoid merge conflicts?
  • wanted to split out a branch into multiple branches and process them separately?

If you consider a branch to be a chain of commits - with a parent commit representing the creation point of the branch - then rebasing is the operation to:

  • change the creation point of a branch
  • change the order of the commits in a branch
  • change the commits in a branch - squash commits together
  • remove commits from a branch

At this point you are probably thinking "Oh man, I'm going to nuke my branch and lose all my work" but if you look more closely at what the rebase does, you'll find that its a lot safer than you think.

A rebase operation will

  • set the repository to the new creation point
  • create a temporary branch just for this rebase operation
  • apply the commits one by one to ensure they apply cleanly
  • update the pointers for the branch and remove the temporary branch
  • set the repository to the last commit of the new branch

When I say "ensure the commits apply cleanly" here, I indicate that git will ensure that additions and subtractions to each file make sense. If they don't (for example, the file has changed significantly enough), it will pause and ask the user to manually confirm the commit.

At any point during a rebase that requires user input, you can abort and git will roll back to the state it was in before the rebase operation started.

Speak English, Brendan!

So I got side-tracked a bit just then. Apologies.

So what do I use rebasing for?

  • reordering - if I do a bit of code cleanup during my work, that remains separate from the current task and can be put before/after when reviewing code
  • squashing - generally speaking, your commits should be granular enough to be easy to follow. But sometimes things go too far and you want to bring related commits together (e.g. missed deleting a file from the previous commit)
  • splitting - if you've got a complex branch you could split it up into multiple branches and integrate them in gradually.

All of this is possible by using interactive rebase - before it kicks off the operation, it displays the commits available and allows you to specify the operations to perform.

Note: There's two minor differences when you squash commits together. One operation, fixup, is intended to merge a commit without including the commit message. The other, squash, will bring the commit message across and allow you to edit the commit message after the squash.

Merging is overrated anyway

Yes, that might be a controversial thing to say at this point. Merges are considered important to indicate when two branches have been brought together. But I submit to you, the jury of the internet - do we really need it? I'm not advocating abandoning merges at all - they have a purpose, which is to indicate changes additional to the branch being merged in.

If I can rebase a branch on top of the current master, I've just avoided the need for a merge commit completely (it becomes a fast-forward merge and the pointers are moved forward). I can then push and get on with the next task.

I guess this comes back to how you use branches. Git works excellently when you create a branch for a task, integrate the code into master, and delete the branch once its reached the end of its useful life.

Not everyone can work that way (that might be a rant for another day), but I see this a discipline issue rather than a pro/con of the tool itself.

My Opinionated Git Flow

So with a slight tweak to step 3, my flow becomes:

  1. Create a local branch for the feature
  2. Work on your feature and get it reviewed -- you do code reviews, right?
  3. Rebase the branch on master
  4. Push the changes up to the remote repository

How does that look from the comamnd line?

  • git checkout -b ReallyCoolFeature master
  • ... stuff gets done ...
  • git add -u . -- add all removes and modifies to the staging area
  • git add . -- add new files to the staging area
  • git commit -m "#1234 implemented" -- associating commits with work items is awesomely helpful
  • git checkout master
  • git pull origin/master master
  • git rebase master ReallyCoolFeature
  • git checkout master
  • git merge ReallyCoolFeature --ff-only
  • git push origin master

Combine that with some hot git alias action (this is getting fairly long as-is), you can strip away much of those commands into a simple "sync" step which you run against the branch you are working on.

What's next?

I could go on about using reset and cherry-pick commands and head further down the git rabbit hole, but I think the next posts should cover these things:

  • git alias - seriously, this is like crack for scripters
  • a general rant about discipline when managing commits - git has corrupted my brain, and I've found myself applying concepts to situations where I have used other VCSes (even TFS, not using git-tfs or tf-git)
]]> Sharing my personal backlog with the world 2012-07-16T10:30:00+00:00 http://brendanforster.com/visible-personal-backlog.html Ever since I got back from holidays a few weeks ago I've been in a bit of a rut trying to tackle the backlog of stuff I've been meaning to do (projects half-done, contributions I've promised other people, things I've been meaning to blog about).

The Experiment

This experiment comes down to three simple things:

  • maintain a list of tasks which need to be done (ordered by priority)
  • focus on one thing at a time
  • make it visible to the world to add some peer input to the situation

For the tool to make this happen, I've decided to use Trello. After using Trello for the Code52 projects in the past, I felt that it was the best fit between ease of administration and ease of viewing.

The board is hosted at https://trello.com/board/public-backlog/50039c94fe5e1f8037b9b583.

What can you do?

You should be able to leave a comment on any of the items currently there. What sort of comments would help? Things like:

  • "Can you explain this one?" (I've been too brief with a task which may be complex)
  • "Can you do this sooner?" (this is something you are interested in)
  • "Can I help out with this?" (this is something you might be able to help out with)

Caveats

This is something that I'll flesh out over the next few days and there may be some details missing.

There are some items on the list which are deliberately vague - I'll indicate which tasks are "teasers" at this point in time, but I've got no issues with you seeing where they sit in my priority queue.

And there are some things which I just can't plain talk about (but really need to do anyway) so I'll need to figure out a way to represent them properly. Not everything on my plate at the moment is OSS work :)

]]> So I accidentally a web guy MVP 2012-07-08T10:30:00+00:00 http://brendanforster.com/so-i-accidentally-a-web-guy-mvp.html So I just had this little email land in my inbox last week.

Congratulations! We are pleased to present you with the 2012 Microsoft MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others. We appreciate your outstanding contributions in ASP.NET/IIS technical communities during the past year.

After the chaos of first half of the year (which I still want to get back to, just trying to summon the energy again after a brief respite to head over to NDC this year) this caught me off-guard, but has been an honour to accept nonetheless.

I'll comment a bit further on the details once I've signed away my life and get an idea of what's involved, but given the ASP.NET dev stack (well, the good bits anyway ::smileyface::) is now on Codeplex I'm keen to spend some time digging into that and helping out wherever my powers might be of benefit.

There's also shiny things coming along in the upcoming release (I've hacked a bit on Web API, and Single Page Apps is on my radar but I haven't used in anger) which are on my never-ending TODO list.

]]> Introducing code52 2012-01-03T10:30:00+00:00 http://brendanforster.com/introducing-code52.html Back from a self-imposed internet break (taking a phone which doesn't do 3G coverage and going rural is a good way to do this) and Paul and Tobin couldn't wait to kick off our new collaborative project.


There's a bit more of a blurb on the website - its an idea we're still wrapping our heads around by using a bit of trial and error.

We're already hard at work on our first project and we'd love to see people drop into the Jabbr room and get involved. Amd pf course, there's a Twitter account too to follow.

]]> 2011 - Where did the time go? 2011-12-20T12:00:00+00:00 http://brendanforster.com/2011-recap.html

Three more days til Christmas. I intend to unplug completely from the internet from then until the end of the year (place a bet with your nearest bookie on the odds I'll crack before then) so I'm writing this now over a cold beer, wondering where the hell the year went - as well as the hot weather.

So where did 2011 go? Let's recap:

Perth

Work sent me over to Perth to work with a client between February and April. It was an interesting project, but the real fun was catching up with the developer community over beers (and they love their beer over in Perth). Particular shout outs to Jake Ginnivan (a "brother from another mother" according to someone who shall remain nameless) and JT for making the non-work hours as entertaining as humanly possible.

I also managed to catch up with relatives over there over there (my cousin, her husband and three young kids live in Perth) and see some bands:

The only downside of my time in Perth was that my grandma passed away after having a stroke last year - it felt weird being away from the family when it all occurred, but I went back for the funeral to say my farewells.

NDC and Europe

While I was over in Perth, I was also madly planning my Europe trip. It coincided with NDC which was an amazing conference in itself.

In no particular order:

  • pre-drinks with Richard Campbell, Rob Conery, Shay Friedman and others (fairly certain I still owe Richard a Famous Grouse for something).
  • three days jam packed with content - I can't recall another event where I'd have three or more sessions in the same timeslot I wanted to see.
  • some great parties after the official one ;)
  • hammocks to recover in after! (while mocking certain Brits on Twitter)
  • an epic technical discussion over post-conference drinks with Krzysztof, Philip and Gael (I tried to keep up but my brain had been melted over the previous days) before we all went our separate ways.

After the conference I headed up to Stavanger with Philip - it was a lot of fun to talk shop while hiking for a couple of hours to what is essentially a giant rock in the middle of nowhere. I was also invited to stay a few days with Thomas Johanson's family in rural Norway - which was capped off with a Norweigan BBQ and aquavit!

After Norway, I spent a weekend in Copenhagen seeing the sights and ran into some Umbraco guys doing whatever those Umbraco guys do.

Then it was onward to Germany (a week of beer and sight-seeing) and France (a week of wine and beer and sight-seeing).

Highlights:

  • the quickest blog post I've written (about 20 minutes), which still gets mentions in odd places
  • having dinner and drinks with a group of Romanian retirees in Berlin. I didn't speak Romanian, they didn't speak English, but the staff were excellent mediators and fun was had by all.
  • our pub crawl group being scolded by a German/French waiter in Hofbrauhaus Munich for being too loud with our chanting - "Zis is not Oktoberfest!".
  • visiting the Dachau concentration camp outside Munich and standing inside a gas chamber - an experience I still can't put into words.
  • drinking the train's bar cart dry of beer with a gang of tourists when the train from Munich to Paris broke down at Metz for a few hours.
  • wandering around Paris and accidentally finding Voltaire's tomb (as well as other famous French figures like Marie Curie) at the Pantheon.

BUILD and Los Angeles

Aside from unveiling the new version of Windows, and causing a collective conniption of the .NET community with their marketecture diagrams, it was an entertaining conference to chat with the guys behind the products. They'd been very quiet for a while, and were keen to talk to anyone at the conference who'd lend them an ear.

Ed: I'll come back to this discussion. I do want to fuel someone's rage on the topic :)

On top of that there was Legoland - if I was ten years old, it would have been paradise. But I still enjoyed a bunch of things there - the Star Wars Lego was particularly good.

The Cantina Bar from A Lost Hope (complete with animatronic band)

Ran into some Aussie friends who are now state-side, like Jeremy Thake, Damian Edwards (again) and Will Robertson.

Community Stuff

I branched out into doing more presentations this year - not something deliberate, just opportunities crop up and I do enjoy jumping into the deep end:

  • dddMelbourne - Ruby and .NET for fun and profit
  • Newcastle Coders Group - XAML - past, present and future.
  • RDN Dev Day - Practical Applications of the Modern Web
  • ALT.NET Sydney - Recap from BUILD
  • Windows Phone 7 Workshops (Sydney and Perth)
  • dddBrisbane - Windows 8 - Who Moved My Cheese?

What's next for 2012?

Can I have a good nap and get back to you on that?

Image: http://www.flickr.com/photos/opethpainter/2866967426/
]]> ALT.NET Open Spaces Recap 2011-12-03T08:00:00+00:00 http://brendanforster.com/alt-net-open-spaces-2011.html I flew down to Melbourne this weekend to catch up with the locals and talk about various topics around the .NET space. Here's the abridged recap - each session was scheduled for about 30 minutes and we (mostly) stuck to the schedule during the day.

Disclaimer: I was sleep deprived and recovering from a party the night before. I may be recalling things differently to how they actually happened. Hell, I'm fairly certain I have the sessions listed out of order.

There's supposed to be a photo here, but the only one I found (that's right, I didn't bother to take photos myself) was on lockerz.com, which seems to be a site that wants your Facebook details in exchange for something called "grab it". I'm not even going to link to it, that's how disappointed I am...

User Groups

We started off the day with a discussion on how everyone perceived the user groups they attend - what works, how to grow a user group, discussions and war stories and whatnot. A lot of good ideas came out of this, which will hopefully materialies in the new year.

We had tacked on a session for talking about open source, but that seemed to have fallen through the cracks when the discussion for user groups went on longer than expected. Sadface.

Code Dojo

As a follow up of the ALT.NET code dojo recently, the group discussed this kata and how to solve the problem. Unfortunately things got sidetracked (I was most annoyed I hadn't heard about this 'trigram' concept before) and we didn't get to demonstrate a good TDD design before the session expired. But it was still an entertaining discussion on how to tackle a problem, even if we didn't agree on much.

New Frontiers

After a quick break, we discussed how languages outside the .NET ecosystem have impacted on .NET and what might be coming down the pipe. A few takeaways from the discussion - some people wanted more concepts to be brought into C#, while others were feeling that the "one language to rule them all" didn't feel right.

Refactoring

I teamed up with Richard to talk about refactoring existing code, R# tips and tricks, and Richard shouting at me to "no no, go down, not up" when navigating some sample code from ages ago. Was fun.

RAD Frameworks

And here's where things got entertaining. What started out as a discussion of tools and libraries to simplify building apps.

First things first: as soon as 'RAD' was mentioned, it was a red rag to much of the audience. It wasn't the intent, but all attempts to refocus the discussion failed miserably.

Secondly: I was fascinated by the number of people who were anti-third party libraries for their UIs. They preferred to roll their own, but I didn't push the discussion into why. Perhaps this is my background in client apps clouding my perceptions...

Lastly: data access. Oh man, I'm sick to death of this discussion. There's so many choices that whenever someone asks why I'm not using XYZ I have to physically force myself to listen. Can we move on as a society?

"What if this is as good as it gets?"

This was a neat discussion about how someone might go about staying in a technical career with software development and avoid the whole "management" position in the hierarchy. Of course, he was currently doing Sharepoint, so that was noted and made fun of.

A few dedicated souls continued on this thread of discussion at the pub after and came to a concensus that there was a correlation between architect-style roles and a conservative approach to new technologies. We had a number of ideas around how to bridge this gap, but its always been a tricky challenge in my experiences when working with clients.

Code Coverage and Analysis

Shaun discussed some of his work with code coverage tools and some gotchas with the code. This was the first time I'd heard of OpenCover (audible gasp), an OSS project he works on, and it was awesome to catch up with him after and have my brain melted by another IL junkie :)

Agile Discussion

This was the point where I ran out of steam - 4:30am starts will do that to a guy. We discussed how agile projects manage the relationships with stakeholders, scene missing and something about estimation?

Anyway, as we wrapped up at about 3ish a few of the group headed to the pub up the road for further discussion. I'd worked in Melbourne last year, so it was great to catch up with the locals again and talk shop.

Wrapup

Big thanks to @pjimmy for organising the event and to Richard for helping with herding cats in the morning. It was a great event, and hopefully it'll be back bigger and better next year - there's rumours abound about a Sydney event next year.

]]> jQuery and KnockoutJS in Win8? Sure, why not! 2011-10-25T13:00:00+00:00 http://brendanforster.com/jquery-knockout-win8.html Apparently this is old news to some. Trendsetters...

With Windows 8 supporting HTML/JS (I refuse to call anything HTML5 these days - the words have lost all meaning to me, but that's another topic) applications, I was asked if jQuery is supported - with a goal to making JS applications more maintainable.

As I'd heard it mentioned at BUILD - and hadn't heard a major drama since people have been using the Developer Preview bits - I expected that it worked. However, to confirm this for myself, I found this forum thread on MSDN with a couple of caveats.

No fire and brimstone? Oh well, I'll just double-check...

After adding the jQuery file to the project, I modified the default.html file to include the jQuery file before the default.js file. The default.js file contains the bootstrapping code for the application:

   <link rel="stylesheet" href="/css/default.css" />
    <script src="/js/jquery-1.6.4.js"></script>
    <script src="/js/default.js"></script>
</head>

And at the bottom of the default.js file, I use a simple selector to find a DOM element:

            // other code

            WinJS.UI.process($('#appbar')[0])
                .then(function () { 
                    $('#home').click(navigateHome);
                });

            WinJS.Navigation.navigate(homePage);

            var host = $('#contentHost');
        }
    }

    WinJS.Navigation.addEventListener('navigated', navigated);
    WinJS.Application.start();

})();

and started making use of selectors elsewhere instead of document.getElementById to make the code more concise...

And what of KnockoutJS?

I've only had basic experience with Knockout, but found an easier scenario to support. I dropped in the code and modified the detailPage template.

   <link rel="stylesheet" href="/css/default.css" />
    <link rel="stylesheet" href="/css/detailPage.css" />
    <script type="ms-deferred/javascript" src="/js/detailPage.js"></script>
    <script type="ms-deferred/javascript" src="/js/knockout-1.2.1.js"></script>
</head>

And then went to work making changes:

In detailPage.js

Before

function fragmentLoad(elements, options) {
    var item = options && options.item ? options.item : getItem();
    elements.querySelector('.pageTitle').textContent = item.group.title;

    WinJS.UI.processAll(elements)
        .then(function () {
            elements.querySelector('.title').textContent = item.title;
            elements.querySelector('.content').innerHTML = item.content;
        });
}

After

function fragmentLoad(elements, options) {
    var item = options && options.item ? options.item : getItem();
    WinJS.UI.processAll(elements).then(function () { ko.applyBindings(item); });
}

In detailPage.html - declared some bindings using the data-bind attribute

<div class="detailPage fragment">
    <header role="banner" aria-label="Header content">
        <button disabled class="win-backbutton" aria-label="Back"></button>
        <div class="titleArea">
            <h1 class="pageTitle win-title" data-bind="text: group.title"></h1>

        </div>
    </header>
    <section role="main" aria-label="Main content">
        <article>
            <div>
                <header>

                    <h1 class="title win-contentTitle" data-bind="text: title"></h1>
                </header>
                <div class="image" data-bind="style: { color: backgroundColor }"></div>
                <div class="content" data-bind="html: content"></div>
            </div>

        </article>
    </section>
</div>

So by moving the binding expressions to the UI (like the MVVM pattern that is popular with XAML application) we can lean on frameworks to make our Javascript code easier to maintain. Other components of the default templates have their own binding attributes - data-win-bind - which I'll explain later, but I find the KnockoutJS syntax more concise.

In particular the use of textContent instead of text to denote a text value? Why? Drop the 'Content' part unless there's a real good reason - it feels like ceremony.

I'll formulate some more opinions on the WinJS side as I delve deeper....

]]> I'm speaking at DDD Brisbane 2011-10-22T13:00:00+00:00 http://brendanforster.com/ddd-brisbane.html

The dddBrisbane organisers sent out a call over the weekend to finalise the schedule - some very cool talks that I'm looking forward to seeing (look for the schedule to appear early this week).

I'm especially honoured to see my session was picked - especially after seeing the depth of Windows 8 talks submitted.

So what am I talking about?

Windows 8 - Who Moved My Cheese?

The slides are available on Heroku.

The source code for the slides are available on Github.

]]> Doing the build server dance with NuGet 2011-07-08T04:00:00+00:00 http://brendanforster.com/doing-the-build-server-dance-with-nuget.html I started exploring NuGet package building yesterday evening, as a strategy for managing dependencies between projects I'm involved with.

And with NuGet in the enterprise being the upcoming hotness, I thought I'd see how I could get companies I work with to start doing similar things with their internal projects. It was much easier than I'd expected, with a couple of hurdles.

The Goal

I have two projects, A and B. A has no upstream dependencies (that have NuGet packages, anyway), but B requires A.

So, after A builds and passes its tests, I want to:

  • Create a new package for A, using it's build number.
  • Publish the package for A somewhere
  • Trigger a new build for B, using the newest version of A.
  • Verify B builds and passes tests.
  • Create a new package for B, using it's build number.
  • Publish the package for B somewhere.

After a couple of hours work, I'm 95% of the way there.

Defining the package specification

As I wasn't really familiar with the process of creating the .nuspec file (sorry Damo, your NDC talk was a long time ago :)) I decided to go and craft it by hand. I used this blog post by Joshua Flanagan (including a good reference nuspec file) to get started.

And that's about it. Put that into my build folder along with the NuGet.exe - I grabbed the latest one from the 1.4 OOB build on NuGet CI server due to an issue with how it parses the <files> element. This should be part of the next release.

Building the package on the server

So, I'm using TeamCity to build the project. Thus, I can use the build number directly against the NuGet package.

NOTE: Using the default value TeamCity provides for a project, which is just an incrementing integer, will fail with a "Version string portion was too short or too long" error. To fix that, go to General Settings and make it something more descriptive:

General Settings

With that in place, the next step is to add in a post-build step:

Post Build Step

The script I've used (duplicated for two different packages):

del *.nupkg

.\NuGet.exe pack Package.nuspec -Version %system.build.number%

That script is courtesy of Scott Kirkland, who also has a decent guide to using NuGet on TC here

Publishing the package

I didn't want to publish these packages to the NuGet gallery immediately, so what other options do I have? I could set up my own NuGet gallery. Or I could use MyGet and skip all the hassle.

For those who aren't familiar with MyGet, its a service to create custom NuGet feeds. All I've done so far is create a private feed (which anyone can consume) and obtained an API key.

Post Build Step

While MyGet supports the ability to upload or create packages within the admin UI, I was feeling lazy and wanted to push packages from the build server.

This required an additional line in the script:

del *.nupkg

.\NuGet.exe pack Package.nuspec -Version %system.build.number%

forfiles /m *.nupkg /c "cmd /c NuGet.exe push @FILE <your-key> -Source https://www.myget.org/F/mahapps/"

which will find all .nupkg files and invoke push against the specific repository - in this case, my private feed.

Trigger a new build

This isn't directly related to NuGet, but I wanted to force a new build when upstream packages change in TeamCity.

Under Build Triggering in the Project Configuration, add a trigger for "Finish Build" and select the upstream project.

Add Build Trigger

Update the package for A and test

Right, this is where things get rough.

I added a step before building the project, and executed this command:

.\Nuget.exe update ..\MahApps.Twitter.sln -Source http://www.myget.org/f/mahapps

which will look through all the projects in my solution and update to the newest packages it can find. I've added in my MyGet feed URL to grab the latest packages from the specific feed.

And this works. Kinda.

Success?

It updates my projects, but doesn't store updated packages locally. Which causes my build to break.

Oops

Scouring the forums produced this discussion on this issue, which recommended this workaround:

nuget install MyProj\packages.config -o packages

NOTE: a minor grievance with the install command. Unlike the update command, this works against a project's repository. This seems subpar, when I can call update against a solution file. Can we get some consistency with this? Or have I missed something with how install behaves?

Fine, not all workarounds are pretty.

Let's modify my script to suit:

.\Nuget.exe update ..\MahApps.Twitter.sln -Source http://www.myget.org/f/mahapps -Source https://go.microsoft.com/fwlink/?LinkID=206669 -o ..\packages

.\Nuget.exe install ..\src\Identica\packages.config -Source http://www.myget.org/f/mahapps -Source https://go.microsoft.com/fwlink/?LinkID=206669 -o ..\packages

.\Nuget.exe install ..\src\NET4\packages.config -Source http://www.myget.org/f/mahapps -Source https://go.microsoft.com/fwlink/?LinkID=206669 -o ..\packages

.\Nuget.exe install ..\src\Tests\packages.config -Source http://www.myget.org/f/mahapps -Source https://go.microsoft.com/fwlink/?LinkID=206669 -o ..\packages

.\Nuget.exe install ..\src\WP7\packages.config -Source http://www.myget.org/f/mahapps -Source https://go.microsoft.com/fwlink/?LinkID=206669 -o ..\packages

Icky. Whatever, I've got awesome to do.

https://go.microsoft.com/fwlink/?LinkID=206669 is the path to the official NuGet feed (the build server couldn't find some packages), and it is explicitly after my local feed (I may have some custom packages which I prefer). And I've added the "-o" parameter to point to the default packages location, just in case.

Aaaaand...

Success!

Booyah!

]]> Soapbox: INotifyPropertyChanged - Stop the Madness 2011-06-18T04:00:00+00:00 http://brendanforster.com/inotifypropertychanged-stop-the-madness.html Its time to stop with this madness.

Apologies again to Ian as I picked on him unnecessarily when I read yet another "Let's make OnPropertyChanged compile safe" blog post yesterday.

I don't have an issue with the approach, but I had an issue with the bigger picture - how little had changed for XAML developers in this regard. Keep in mind that lambdas were first made available in C# 3.0 - which itself was made available in 2007, with .NET 3.5.

I've been summoned into this debate before (and was assumed to be a "cool kid") so I thought I'd put down some thoughts on the issue, and what I think needs to change:

Stop writing plumbing code

Every time you write logic in the setter of a property, an angel disappoints her family by taking up stripping.

There have been compelling reasons to do so. After dealing with the resulting pain, I've explored other options to take all those needs away. So let's break it down:

To start off with the worst case scenario, we have:

private string _someProperty;
public string SomeProperty
{
    get { return _someProperty; }
    set 
    { 
        _someProperty = value;
        OnPropertyChanged("SomeProperty");
    }
}

Make it refactor-friendly - let's use a lambda instead!

Yes, this is better than magic strings - that's about it. Don't you get that sinking feeling when adding a new property to the viewmodel, and the code inside the setter looks almost identical to all the others?

So let's change the property to look like:

private string _someProperty;
public string SomeProperty
{
    get { return _someProperty; }
    set 
    { 
        _someProperty = value;
        OnPropertyChanged(() => SomeProperty);
    }
}

For an example implementation that accepts lambda statements, this Stackoverflow answer is a good starting point.

I only want to raise the change when the backing value actually changes!

"Wait," the audience exlaims in shock, "you're going to raise the event each time now." The author relents, and adds some code to end the pain for the audience:

private string _someProperty;
public string SomeProperty
{
    get { return _someProperty; }
    set 
    { 
        if (_someProperty == value)
            return;

        _someProperty = value;
        OnPropertyChanged(() => SomeProperty);
    }
}

I'd better ensure this is defined in all the setters, and that the right backing field is used in each case. I'd look pretty silly if I'd used the wrong field, like this:

// elsewhere in the codebase
private string _someOtherProperty;

// ...

private string _someProperty;
public string SomeProperty
{
    get { return _someProperty; }
    set 
    { 
        if (_someOtherProperty == value)
            return;

        _someProperty = value;
        OnPropertyChanged(() => SomeProperty);
    }
}

so I'd better do it real carefully...

We need caching now!

Really? That's what comes to mind next? You crazy developers.

Fine, let's add a dictionary to capture the event arguments, instead of recreating them each time (adapted from this blog post):

public class ViewModelBase
{
    protected void OnPropertyChanged(Expression<Func<object>> lambda)
    {
        // magic happens here
    }

    private IDictionary<string, PropertyChangedEventArgs> _handlers = new Dictionary<string, PropertyChangedEventArgs>      

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventArgs args;

        if (!_handlers.ContainsKey(propertyName))
        {
            _handlers.Add(propertyName, new PropertyChangedEventArgs(propertyName));
        }

        args = _handlers[propertyName];

        PropertyChanged(this, args);
    }
}

Have we saved much? Perhaps. Perhaps not...

Wait, what about cross-thread issues? I do a lot on the background thread!

Ah yes. Have you ever been bitten by this one - a background thread updates a property, which triggers the PropertyChanged event, which asplodes because the UI can only be updated from the main thread?

Stop. Put down the keyboard for a minute.

See how quickly all these features around INotifyPropertyChanged can spiral out of control? You've worked out the code and classes necessary to solve a common problem, but some overhead remains for writing boilerplate code everywhere the solution is required. And while it is a manual process, it is prone to human error.

Go back and read that last sentence again. Did something click about what you've been doing all along with INotifyPropertyChanged?

Huzzah!

A what?

INotifyPropertyChanged is a very specialised example of a cross-cutting concern.

We use INotifyPropertyChanged in many places when doing XAML-based applications - as it is critical when databinding POCO objects without requiring the use of DependencyProperty instances. Although we spent a lot of time optimising the behaviour of invoking INotifyPropertyChanged, we didn't improve how this code is used - we're still copying-and-pasting the same code around, and having to make manual changes to each instance to suit the property.

We need the ability to apply the INotifyPropertyChanged behaviour in an automatic way. Of course, there are various tradeoffs to consider - which I'll outline from my experiences.

Further Reading

I need to wrap this post up before it becomes even longer, but you can go and read on about these concepts:

Sacha Barber - Aspect Examples (INotifyPropertyChanged via Aspects)

Philip Laureano linked me this yesterday. A large read, but lots of demo code for people who want to see something more concrete.

NotifyPropertyWeaver - a .NET library for weaving INotifyPropertyChanged code into IL

This is my library of choice for automating INotifyPropertyChanged usage. I definitely owe Simon a beer (or drink of choice) next time we cross paths - its been a joy to use.

]]> On the Windows 8 Preview Video 2011-06-08T04:00:00+00:00 http://brendanforster.com/on-the-windows-8-preview.html For those who haven't seen it, this video was announced last week about how the Windows 8 UI is changing: http://www.youtube.com/watch?v=p92QfWOw88I

It was the trigger for significant backlash - and not for what was said, but for what wasn't said around the other options available for building Windows applications.

Yes, MSFT could have handled it better

Since the video dropped, developers and possibly everyone with a blog has been raising concerns about the other options available to developers for building Windows apps. The underlying vibe has been "everything else has been abandoned, the only option is now HTML5, the sky is falling and I have nothing to wear". I haven't watched the Sinofsky video (if it was even recorded), but when you see reporting like:

"The development platform is based on HTML5 and JavaScript." Source

and constrast with a different source:

"Windows 8 essentially supports two kinds of applications. One is the classic Windows application, which runs in a desktop very similar to the Windows 7 desktop." Source

then you know something got lost in the message.

The sky is falling for insert technology here

That thread. Oh dear $deity, that thread.

I appreciate that the MSFT guys "in the field" are stuck between a rock and a hard place currently - they cannot provide details to answer people's concerns or questions, but are dealing with a large backlash due to the large amount that is not know currently.

As one of those in the audience who has to wait, in uncertainty, between now and BUILD to have these questions answered, I wish they would rethink this decision and respond to questions and help change the course of discussion.

While the video does mention:

"Windows 8 also runs the existing Windows apps that you know and that you love"

it then follows up with running Excel.

Yep. Excel.

While an Excel demo is a good indicator of the backwards compatibility that Windows is famous for, it was a jarring change from the rest of the video, and I'm not sure it was the best application to demonstrate.

Perhaps the developer story is not ready to show. Perhaps it was supposed to be about the shell, and HTML5 was only mentioned in passing. Perhaps, perhaps, perhaps. I suspect a demonstration of how a WPF/SL/Winforms/native application could look/feel/behave within the new shell would provide some information without giving much away.

The video was about creating interest in the new platform and discussing the opportunities it provides. Now is the time to talk more broadly, while everyone is talking about it.

So instead of drumming up more drama, I thought I'd share some takeaways for both sides on this:

Devs: pay attention to the user experience

I hope developers took away from this story how the user experience of applications has changed, and how the classic WIMP (Windows, Icons, Menu, Pointer) applications will be impacted. Much like the transition from Windows Mobile 6.5 to Windows Phone 7, I anticipate some growing pains once developers get their hands on the development tools.

Touch input is also something that many Windows developers may not be familiar with. While it has been available to native developers since Windows 7 launched, and was added to WPF and Silverlight with subsequent product releases, it hasn't really been utilized to anywhere near its full potential.

Get familiar with how gestures work - as a starting point, the WP7 emulator turns mouse inputs into touch inputs. Touch will be mandatory if you want an application to be usable on different form factors (Windows 8 is taking an iOS-ish route with the same codebase running on desktops, tablets and devices).

MSFT: don't let the echo chamber continue

I'm still baffled by the decision to stonewall. Developers are customers, and they have questions. Why not be pro-active and help smooth the transition over the coming months?

With all the strong and passionate opinions flying around, wouldn't it be good to plant some seeds of confidence and turn the conversation from "Where is XYZ?" to "What can I do with Windows 8 using XYZ?"

Give the community a baseline of information so they can start planning and start providing feedback. It doesn't have to be revealing all the cards, but the developer story for Windows 8 is (mostly) unknown currently. That's why people are concerned.

MSFT: don't forget the hardware

I've been looking for a kick-arse tablet device to run Windows on for a while, but have been stuck in Goldilocks-mode - "too large, too heavy, the battery is too short, etc" - and continue to sit on the fence. Much like with WP7, I'm curious about the involvement of hardware vendors to support the new features coming in Windows 8.

Windows 7 was launched with support for touch input, but it never really gained traction due to lack of a compelling tablet device - the Touchsmarts were a nice device, but were primarily for kiosks, rather than daily usage.

Compare Windows 7 to the WP7 launches - which have been done with device announcements involving hardware vendors - and it gives me hope that the launch can be done in a more "complete" fashion.

And I want to see more presentations from MSFT about Windows 8 using touch - drive the presentations from a tablet, demonstrate how the new UI supports touch, and compel me to put it everywhere.

]]> slsvcutil - Workaround StackOverflowException 2011-05-06T04:00:00+00:00 http://brendanforster.com/slsvcutil-stackoverflowexception-workaround.html I've hit this issue before, but it took a bit of googling to remember the fix - especially since that little site called stackoverflow came into the mix :)

D:\Readify\Hg\ReadifySample\src>"C:\Program Files (x86)\Microsoft SDKs\Silverlight\v4.0\Tools\Slsvcutil.exe" http://localhost:47862/Services/ParentService.svc

Process is terminated due to StackOverflowException.

No configuration options set. No informative error message. Annoying.

The solution, which was initially posted here over a year ago, is to add in a configuration file alongside slsvcutil.exe, called slsvcutil.exe.config, which will point to the neutral-culture assembly.

<configuration>
  <satelliteassemblies>
    <assembly name="SlSvcUtil, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
  </satelliteassemblies>
</configuration>

That's right. If you have set your system language to something other than US English, you will probably encounter this issue.

Enjoy.

]]> Musing - Simpler UI Testing for WPF Apps 2011-03-26T03:00:00+00:00 http://brendanforster.com/simpler-ui-testing-for-wpf-apps.html After spending some time this week getting to know Ruby and some of its testing frameworks (Shoulda, rspec, and TestCase), I thought I'd put pen to paper and revisit why I started down this path.

Some background

The current project I am working on is a large data-driven WPF application, with a lot of complex scenarios to identify, develop and test. There is a group of testers on the project, but I can see an opportunity to use automated testing to verify functionality and allow testers to focus on areas of better value - exploratory testing, for example.

Yes, there are frameworks like White or Coded UI Tests, but these tools were designed with developers in mind. You have to write code like this to drive the tests, and the tests are commonly written after the feature is implemented.

Enter Automated Acceptance Testing

In an ideal world, business users would define tests in an English-like language, which can then be translated into an executable script and run against the application.

What I'm looking for in a framework for defining use cases:

  • define the test first, so that the high-level scenario is set before development occurs
  • flexible with syntax for test cases - tailor scripts to suit people involved, while remaining declarative
  • integrate into deployment process to verify builds automated

Some inspiration from obscure corners

When I first saw the syntax for webrat, I was intrigued and jealous. To declare a test like this:

class SignupTest < ActionController::IntegrationTest

    def test_trial_account_sign_up
        visit home_path
        click_link "Sign up"
        fill_in "Email", :with => "good@example.com"
        select "Free account"
        click_button "Register"
    end
end

was not far off what I'd had in mind for something that was easy to follow and easy to write.

So I spent some time this week experimenting with various ways of achieving this against a sample WPF application.

I'm using rspec at the moment to run the test cases, and IronRuby and White to support the integration with the hosted WPF application.

What does a test for the WPF application look like?

describe "new customers screen" do

    subject { Host.new(File.expand_path('./app/WpfTestApp.exe', File.dirname(__FILE__)))

    before(:each) do
        click "Add Customer"
    end

    it "cannot save empty form" do
        cannot_click "Save"
        can_click "Cancel"
    end

    it "can enter details for customer" do
        fill "FirstName", :with => "Brendan"
        fill "LastName", :with => "Forster"
        # and some other fields
        can_click "Save"
    end

    it "can save and return to main screen" do
        fill "FirstName", :with => "Brendan"
        fill "LastName", :with => "Forster"
        # and some other fields
        click "Save"
        assert_title "Dashboard"
    end

    after(:each) do
        cleanup
    end

    def method_missing(sym, *args, &block)
        subject.send sym, *args, &block
    end
end

The fields used here are based off the UI Automation features of the .NET Framework (some reading here on recommendations) which I'll dig into a bit later if people are interested.

The method_missing method is used to reduce the noise of writing "subject." to start each line - I'm not quite sold on the approach, but it was cleaner than the previous approaches I'd tried. Also, rspec has a huge set of features which I've barely scratched the surface on.

So with a set of files like the file above, the testrunner is a simple script to load specific files found in the current directory:

require 'rubygems'
require 'rspec'
require 'host'

Dir[File.dirname(__FILE__) + '/*tests.rb'].each do |file| 
    load file
end

I'll share some more as I polish additional features (I'm most certainly doing Ruby wrong at the moment, so I keep refactoring code), just needed to write this post.

]]> Arguments about Project Structure 2011-02-23T03:00:00+00:00 http://brendanforster.com/arguments-about-project-structure.html Whenever it comes time to kick off a new project, how do you structure it?

Given a greenfields situation - or even one of my side projects - I go for this layout:

  • build
  • lib
  • src
    • samples
    • Project.ModuleA
    • Project.ModuleB
    • Project.Shell
    • Project.sln
  • tools

And what do those these folders represent?

build - scripts for building and deploying the application. As soon as the application is required to be deployed to different environments, this should be scripted and added to source control.

lib - dependencies required by the application. I generally group the dependent assemblies if required, but will generally drop the dll-xml combination into the root folder.

samples - once the main solution gets beyond a specific size, it may be beneficial to separate the sample code out rather than compiling it within the main build.

src - there be code.

tools - dependencies required to build the application. This does not mean including every tool required to set up the developer baseline, but any special tools used during the build process

For example, these would not belong:

  • Visual Studio
  • .NET Framework

But I'd happily include these tools:

  • FxCop
  • NCover
  • MSBuild Community Tasks

as not all developers would have them installed on their machines.

Why this structure?

Folder Names

Remember the days of 8.3 filesystems? I do. But thankfully this isn't about that.

This structure also borrows from Unix conventions for arranging their codebases. I don't like how the necessary make files are hosted at the root.

As we're using Mercurial, we don't need to worry about using trunks or tags in the structure.

Experience

When I challenged @aeoth's project structure for the next version of MahTweets, he wanted to make it so that a developer with little experience in .NET (or programming) could download the source and try it out.

I'd argue the best introduction to a codebase is two things:

  • a README file to provide some notes about the application
  • a batch file or script to run the application and execute tests
  • sample projects to complement the source

The build is important

We had various pain points with the last version of MahTweets around managing loosely-coupled modules under development, and then building a signed ClickOnce installer with a custom script.

It ended up being a painful few nights bashing against MSBuild (have you ever tried to use SignFile manually?), but the effort burnt reminds me everytime I come across a new team or project to ask two simple questions:

  • how can someone build and run the application with limited knowledge of the codebase?
  • how can someone test the application with limited knowledge of the codebase?

If that process is known and documented, it highlights all the quirks with getting the application out. If it isn't documented, then typically you need to find the right person at the right time...

Putting the build components separate, but easily visible, makes everyone's life easier.

Habit

And lastly, this is my personal opinion. Having spent a lot of time playing around with Linux OSS in the past, I keep coming back to that style of structure when setting up my own projects. Seeing things like uppercase folder names at the root just feel odd.

]]> Using Rx to Implement Filtering in MahTweets 2011-02-19T03:00:00+00:00 http://brendanforster.com/using-rx-to-implement-filtering-in-mahtweets.html As we're kicking development off for the next version of MahTweets in the coming weeks, the team has been looking at experimenting with new technology and bringing the most useful stuff into the application.

Filtering is one of the things that MahTweets is famous for, but we're always looking for ways to make it better and easier. We've been experimenting with using the Reactive Extensions (Rx) for .NET to simplify the entire pipeline and provide more freedom in the application.

The Current Status

MahTweets allow the user to filter streams by update type, contact or text. Filters can be applied to individual streams or globally.

Roughly speaking, this is how the filters are applied.

Updates from external services are added to the queue, which then raises CollectionChangedEvent notifications to each views. The view is responsible for running an update through its configured filters.

Limitations about this approach:

  • Global Ignores were implemented separately.
  • Custom filtering was implemented per update type.
  • UI was coupled to stream container and specific parameters.

First Cut using Rx

FYI: If you're not familiar with the Observer Pattern, check out the Wikipedia article for starters. Rx uses the Observer pattern heavily.

We had a habit of using the phrase "filter" in many places of the application. To clarify our intent, we introduced two specific interfaces:

  • IStatusSubscriber - an extension which subscribes to a stream of incoming requests.
  • IConditionalSubscriber : IStatusSubscriber - an extension which filters the updates before propogating to its consumers. Pass-thru or exclude filters can be specified.

Replacing the Queue of messages with an IObservable/IObserver dual allows the application to leverage the Subject<T> class to manage the interactions between the services and the clients. This class resides in System.Reactive.dll and implements both IObservable<T> and IObserver<T>.

MahTweets also had some demo plugins for stream analytics, and abstracting away the queue support allows the application to plug in additional "global" services, using the same interfaces. Rx also allows observers to specify which thread to execute on, so the usage of the Dispatcher, TaskPool or ThreadPool (depending on scenario) can be configured without any plumbing code.

The interactions between these components now looks like:

The biggest change is that subscribers interact with the IObservable, rather than being encompassed within the view. Each list still combines a set of filters, which display the combined set of results on-screen. However, when multiple filters are run in parallel, invalid items may appear.

Limitations about this approach:

  • Excluded updates may be propogated through other subscribers in the same view.
  • Global Ignores still not supported.

Back to the Drawing Board

So after some shut-eye and sun, I revisited the initial design for the IObservable implementation. What stood out to me was that:

  • Include and exclude side-by-side has always been somewhat complex - both for users to understand, and determining which takes priority.
  • Include and exclude filters didn't need to exist in the same location.
  • Rx can support chaining observers, however...
  • Chaining isn't what the Observer pattern is about.

After some more musing, I formed an opinion about subscriber rules (only mine so far):

An exclude rule is applied globally. An include rule is applied locally.

From my experiences with using Twitter, the typical use cases for exclude filters are:

  • "Great, another Twitter spam concept..." looks at paper.li
  • "Person XYZ is tweeting too much right now. I don't want to hear him for a while..."
  • "Oops, I said the i-word and the spammers are out and about..."

On the other hand, the use cases for include filters can be like:

  • "I want to see what this group of contacts is talking about..."
  • "I want to see tweets mentioning 'ABC' - (side note: more on search later)..."
  • "I want to see my mentions/messages..."

Compare and contract (perhaps your experiences differ).

Second Cut using Rx

The second cut of the design allows for three subscriber hooks:

  • Subscribers register against the source observable, without any filtering applied.
  • Subscribers register against the output observable, with the global filtering applied.
  • Exclude rules are applied closer to the source.

An internal subscriber verifies a status against a list of exclusions, and propogates the status further if it is valid. Each view only requires its inclusion rules (or a wildcard rule if no rules specified) to display results.

The Next Step

  • Debate with @aeoth on this
  • Performance Testing against a large set of data.
  • Demonstrating how external plugins can include their own rules.
  • Demonstrate user interface changes for vNext.
]]> WP7 - Memory Profiling Adventures - Navigation (Updated) 2011-02-04T03:00:00+00:00 http://brendanforster.com/wp7-memory-profiling-navigation.html In the course of wrapping up a SL-based WP7 application recently, I stumbled across a significant hurdle with memory consumption on the device...

Updated

After going back and forth with local Windows Phone guru Nick Randolph about the issue, and he blogged about the behaviour in more detail, we came to the conclusion that the garbage collection was not being triggered automatically. That's not necessarily a bad thing (see the conditions for triggering a garbage collection here) but is a concern for large WP7 applications.

The workaround I devised for this is to trigger a GC.Collect() after a number of page navigations. I would only add this to an application when absolutely necessary. The implementation of this I'll leave as an exercise to the reader.

Side note: I've seen various samples floating around which will use a timer to invoke a garbage collection call. Ignoring the use of timers on the device (which will drain the battery), a garbage collection call at an arbitrary time will likely impact on the user experience. Be smart about it, if you need to work this into an application.

Read on for the rest of the saga...

Before We Begin...

One of the requirements a WP7 application needs to satisfy is around memory consumption

5.2.5 Memory Consumption

An application must not exceed 90 MB of RAM usage, except on devices that have more than 256 MB of memory. You can use the DeviceExtendedProperties class to query the amount of memory that is available on the device and modify the application behavior at runtime to take advantage of additional memory. For more information, see the DeviceExtendedProperties class in MSDN.

Note:

The DeviceTotalMemory value returned by DeviceExtendedProperties indicates the physical RAM size in bytes. This value is less than the actual amount of device memory. For an application to pass certification, Microsoft recommends that the value returned by ApplicationPeakMemoryUsage is less than 90 MB when the DeviceTotalMemory is less than or equal to 256 MB

Source Microsoft

90 MB sounds like a lot of space - and yes, it is, when one remembers the era of 1.44MB diskettes (or earlier) you can't help but think that perhaps we are spoiled - but what can you do with that amount of memory?

Note - Disregard the "devices with > 256MB" exception mentioned, as I want to see how we can optimise memory usage on SL without sacrificing features.

How Do I Work Out My Memory Usage?

As mentioned above, the DeviceExtendedProperties class contains a lot of runtime information about the application.

I drop this method into the App.xaml.cs class so that I can get statistics at any point of the application's lifecycle.

public static void GetMemoryUsage(string task)
{
    var number = (long)DeviceExtendedProperties.GetValue("ApplicationCurrentMemoryUsage");
    Debug.WriteLine("{0} - ApplicationCurrentMemoryUsage: {1}", task, number);
    number = (long)DeviceExtendedProperties.GetValue("ApplicationPeakMemoryUsage");
    Debug.WriteLine("{0} - ApplicationPeakMemoryUsage: {1}", task, number);

    Debug.WriteLine("");
}

Oh, and don't forget the namespace

using Microsoft.Phone.Info;

This allows parts of the application to log diagnostics, like:

private void MainPageLoaded(object sender, RoutedEventArgs e)
{
    if (!App.ViewModel.IsDataLoaded)
        App.ViewModel.LoadData();

    App.GetMemoryUsage("Main - Loaded");

}

and see a message like in the Output Window:

Main - Loaded - ApplicationCurrentMemoryUsage: 39870464
Main - Loaded - ApplicationPeakMemoryUsage: 39899136

And now things get interesting...

Testing out a simple application - two screens, both use the Panorama Control and independent ViewModels which display a "large" list of items (270-ish items, but text only).

Selecting an item in the main screen will navigate to the second screen. Pressing back will return the application to the main screen.

The code is here and the sample output can be seen on Gist

Graphing the memory at each step, the graph looks like this:

But why is the memory footprint larger (by almost 10 MB) on returning to the main screen?

Note: Removing the Panorama Control did not change this behaviour - it just made the numbers smaller (a 5MB difference rather than 10MB). Just a sign that making screens leaner will certainly assist with reducing the overall footprint, but not the answer I was looking for.

Repeating the scenario a few times, and the behaviour is the same.

Puzzling...

And the adventure begins

The underlying why is what I want to understand more. Even with this simple application - which is displaying a large list of items - the size of the application is already close to the 90MB limit.

I've only been able to throw a couple of hours of spare time at this so far, but here's some notes from my investigation currently:

  • Tested this with the new emulator and SDK changes. No change to the behaviour.

  • Haven't found any memory profiling tools for SL & WP7 - if anyone has stuff in the works, I'd love to try them out. EQUATEC make a profiler for CPU performance, which works wonderfully from my limited testing.

  • Aggressive garbage collection helped somewhat, but this approach makes me feel unclean. Using timers on the device to trigger a GC Collect is bad for battery performance, and the demo above shows that memory usage can spike between events for a PhoneApplicationPage.

  • Paging data from isolated storage could be worth attempting, but I don't think this is a temporary fix - as the application would load the full file, select a subset of the data, and then dispose the file. Chunking data in isolated storage would increase complexity.

  • Avoiding the use of navigation - and rolling some custom controls to support transitions instead - is the method that needs most work, but gives more control back to the application.

]]> MEF and Chaining Dependencies 2010-12-20T03:00:00+00:00 http://brendanforster.com/mef-and-chaining-dependencies.html A question came up on the MEF discussion board recently (today?) about how to handle a complex graph of dependencies. Although it was "solved" - and I suspect it was a case of missing the required assembly, going by what info was at hand - it still prompted me to dig into how one can go beyond the basics.

Scenario

Imagine you have an application that calls off different services to execute tasks. Rather than hard-coding the services into the application, these can be defined as parts which are composed at runtime using MEF.

But the relationship between the application and the services is not straightforward, which gives a dependency graph similar to the below image:

What should we do now?

As MEF uses the concept of a "contract" to resolve the [Import] and [Export] statements sprinkled within an application, this ultimately comes down to two similar approaches.

Using Contract Names

If the Proxy and Service implementations are equivalent - so we can avoid using distinct interfaces for behaviour which is identical - then we can use the same interface and specify a different contract for each extensibiity point defined in the application.

public class ConsumingApplication
{
    [ImportMany("Contoso.Application", typeof(IServiceProxy))]
    public IEnumerable<IServiceProxy> Services { get; set; }
    
    // implementation here
}

And our simple client can use the corresponding [Export] statement.

[Export("Contoso.Application", typeof(IServiceProxy))]
public class StandaloneProxy : IServiceProxy
{
    // implementation here 
}

Our complex dependency has a bit more code, but it can be broken down into two main features:

  • The contract which it satisfies - Contoso.Application and IServiceProxy
  • The contract which it requires - Contoso.External and IServiceProxy

Which looks like this:

[Export("Contoso.Application", typeof(IServiceProxy))]
public class ActualProxy : IServiceProxy
{
    [ImportMany("Contoso.External")]
    public IEnumerable<IServiceProxy> Services { get; set; }

    // implementation here
}

So while reusing the same interface, we can specify how the parts relate.

Using Contract Types

If the behaviour of the proxy and the actual service are different, then we can just use the types to represent the contract.

public class ConsumingApplication
{
    [ImportMany(typeof(IServiceProxy))]
    public IEnumerable<IServiceProxy> Services { get; set; }

    // implementation here
}

The exported contract becomes:

[Export(typeof(IServiceProxy))]
public class StandaloneProxy : IServiceProxy
{
    // implementation here
}

And our complex part still has two contracts:

  • The contract which it satisfies - the IServiceProxy contract.

  • The contract which it requires - the IService contract (implicit due to the awesomeness of ImportMany)

Which looks like this:

[Export(typeof(IServiceProxy))]
public class ActualProxy : IServiceProxy
{
    [ImportMany]
    public IEnumerable<IService> Services { get; set; }

    // implementation here
}

And finally, InheritedExport

To really simplify the contracts, you can decorate the interface with the [InheritedExport] attribute. This declares to MEF that all types which implement the interface should be used as exported parts, using the interface type as the contract.

So I annotate both interfaces:

[InheritedExport]
public interface IServiceProxy
{
    // code here
}

[InheritedExport]
public interface IService
{
    // code here
}

and can eliminate all other [Export] attributes from the codebase:

public class StandaloneProxy : IServiceProxy
{
    // implementation here
}

public class ActualProxy : IServiceProxy
{
    [ImportMany]
    public IEnumerable<IService> Services { get; set; }

    // implementation here
}

Thoughts?

]]> MEF - [Import] vs [ImportingConstructor] 2010-10-23T03:00:00+00:00 http://brendanforster.com/mef-import-vs-importingconstructor.html A short discussion on Twitter recently started as a result of Jeremy Likness' article on MEF at InformIT. I recommend reading it for anyone who is looking for an introduction to the MEF concepts.

The healthy debate was ultimately about [Import] being easier than [ImportingConstructor] to use. I disagreed, but at the time couldn't really put my finger on why I preferred it.

After a bit of pondering, this is what I've come up with.

Compare and Contrast - [Import] versus [ImportingConstructor]

Compare these two segments of code:

The [Import] version...

public class TwitterPlugin : IMicroblog
{
    [Import]
    private IApplicationSettingsService _applicationSettings;

    [Import]
    private IStatusUpdatesService _statusUpdatesService;

    [Import]
    private IContactsService _contacts;

    public TwitterPlugin()
    {
        // some constructor logic
    }
}

Or the [ImportingConstructor] version...

public class TwitterPlugin : IMicroblog
{
    private readonly IApplicationSettingsProvider _applicationSettings;
    private readonly IStatusUpdateService _statusUpdatesService;
    private readonly IContactsService _contactsService;

    [ImportingConstructor]
    public Twitter(IApplicationSettingsProvider applicationSettings,
                   IStatusUpdateService statusUpdateService
                   IContactsService contactsService)
    {
       _applicationSettings = applicationSettings;
       _statusUpdatesService = statusUpdateService;
       _contactsService = contactsService;
    
       // some constructor logic
    }
}

So the second approach requires more code, but a good tool should have you saving many keystrokes - even Visual Studio 2010 will help out with that.

Other differences:

Design - Constructor Injection versus Property Setters

With the first approach, the properties are not populated until after the constructor is completed. If the class needs to perform tasks in the constructor which require its dependencies to be present, then you need to use the [ImportingConstructor] approach.

By using the [ImportingConstructor] attribute, the part declares to the container that it requires. Simple, easy to read, and can be used outside MEF by new'ing it up.

Maintainability

Jeremy raised a concern about the constructor signature growing over time, and that a set of properties on the class was a cleaner approach.

I see the "growing dependency count" as a design issue rather than a technical issue. Tacking on another [Import] attribute should be considered a code smell, just like adding an additional parameter to a constructor.

If your dependency count is more than a handful, then you should review the interfaces and see if they can be segregated/aggregated better. The dependency list is a representation of what the component requires to function. It should be the smallest possible set of interfaces, and no more. The interfaces should be lean and specialized, and classes can implement multiple interfaces if required.

You can still use attributes

Something these snippets don't demonstrate is that attributes can be combined with ImportingConstructor for specific scenarios:

For example, using [ImportMany]

private readonly IEnumerable<ICreditService> _creditServices;

[ImportingConstructor]
public BankService([ImportMany] IEnumerable<IProductServices> productServices)
{
    _productServices = productServices;
    
    // some constructor logic
}

Or using AllowDefault to allow for scenarios where a component is not known:

private readonly ILogger _logger;

[ImportingConstructor]
public BankService([Import(AllowDefault=true)] ILogger logger)
{
    if (logger == null)
        _logger = new DefaultLogger();
    else
        _logger = logger;
    
    // some constructor logic
}

And this still keeps all the composition "magic" in one location. MEF supports importing properties, fields and collections, which could be scattered around the same class.

Closing Statements

Ultimately, I guess I'm advocating the [ImportingConstructor] approach because once a class grows to a significant complexity (requiring some parts and providing other parts) I feel that it is the saner approach.

For getting start with MEF, [Import] works fine - the barrier to entry is lowered greatly. But as the composition graph grows in an application - e.g. A <-> B <-> C <-> D - then I'd start simplifying the classes and pushing more "magic" into the constructor for readability's sake.

While we're talking managing MEF parts

When I first started using MEF, I avoided ImportingConstructor like the plague. Every time I saw ImportingConstructor being used, I thought "Why add a constructor parameter to the constructor when I can just add an attribute?"

After all, it just worked.

It was easy to get started with MEF - as the application grows, you can sprinkle some more magic around.

I've been using MEF since the early previews (Preview 6 i think was the first drop I tried out) for various apps. One of the bigger codebases running on MEF is MahTweets, a pluggable WPF client for various social media services.

For an upcoming release, I'm currently refactoring the MahTweets internals to replace StructureMap with Autofac. The MEF integration extensions for Autofac have been a great help to simplify the integration between Autofac's ContainerBuilder and MEF's ComposablePartCatalog, and I've found ways to reduce the required MEF syntax without changing existing functionality.

On the Autofac side, we can declare components in the container to be available for MEF composition.

container.RegisterType<ApplicationSettingsProvider>()
         .As<IApplicationSettingsProvider&gt;()
         .Exported(x => x.As<IApplicationSettingsProvider>()) // make this part visible to MEF components
         .SingleInstance();

container.RegisterType<PluginSettingsProvider>()
         .As<IPluginSettingsProvider>()
         .Exported(x => x.As<IPluginSettingsProvider>())
         .SingleInstance();

...

// register external plugins for consumption
container.RegisterComposablePartCatalog(catalog);

This allows for better separation between the application and external parts, and reduces effort required to register a component with both the IoC container and the CompositionContainer.

I'll blog some more in the future on how you can use these parts to help manage MEF applications as they grow. I need to check out the MEF v2 drops first :)

]]> IoC Tips - Autofac Factory Adapters 2010-10-23T03:00:00+00:00 http://brendanforster.com/ioc-tips-autofac-factory-adapters.html Scenario

A team has a change request come in from the business. For one of their screens, a timer should count up when a user pauses the current task.

As the application was already using an IoC container (Autofac), and a timer was already implemented to provide the behaviour for a similar task in this class, the constructor was quickly changed to:

public ScheduledBackupService(
      ... ,
      ITimer elapsedTimer,
      ITimer pausedTimer)
{
      ...
      this.elapsedTimer = elapsedTimer;
      this.pausedTimer = pausedTimer;
      ...

And from there they added in the additional code required, and the business was happy. And there was much rejoicing. But the team noticed that they were duplicating the same type in the constructor. Can the team do it better?

Rather than explicitly defining the two instances, the team can replace both instances with a factory adapter. In .NET, this can be represented as a Func<T> object - a method which requires no inputs and returns an instance of type T:

public ScheduledBackupService(
      ... , 
      Func<ITimer> createTimer)
{
      ...                 
      elapsedTimer = createTimer();
      pausedTimer = createTimer();
      ...

To fix the compiler error from changing the constructor signature, the test code is updated to:

IScheduledBackupService GetScheduledBackupService()
{
    return new ScheduledBackupService(
                ... ,
                () => MockRepository.GenerateStub<ITimer>());
}

What about those unit tests?

What if we need to use the mock object in a unit test - to raise events or stub methods? We can't track them if we use the function defined above...

As our existing tests relied on verifying the messages displayed using ITimer instances, I wrote a custom function to mimic the function behaviour and support the unit tests.

Func<IDispatcherTimer> createTimers = () =>
{
    if (elapsedTimer == null) 
    {
        // first call -> mock "elapsed" timer
        elapsedTimer = MockRepository.GenerateStub<ITimer>();
        return elapsedTimer;
    }
    if (pausedTimer == null) 
    {
        // second call -> mock "paused" timer
        pausedTimer = MockRepository.GenerateStub<ITimer>(); 
        return pausedTimer;
    }
      
    return null; // subsequent calls not supported - will raise errors if used
};

IScheduledBackupService GetScheduledBackupService()
{
    return new ScheduledBackupService(
                    ... ,
                    createTimers);
}

And our tests remain clean and readable:

[TestMethod]
public void ElapsedTimer_WhenServiceResumes_StartsAgain()
{
    // arrange
    var service = GetScheduledBackupService();

    // act
    service.Start();
    service.Pause();
    service.Resume();

    // assert
    elapsedTimer.AssertWasCalled(s => s.Start(), m => m.Repeat.Twice());
    elapsedTimer.AssertWasCalled(s => s.Stop(), m => m.Repeat.Once());
}

What else can I do from the container?

Nicholas Blumhardt, maintainer of Autofac, has a detailed entry which discusses the different possible relationships between components, and how Autofac defines them. While the article is Autofac-centric, many of the other inversion of control containers for the .NET Framework support some of the features already.

It's a great read if you want to dive deeper into inversion of control concepts.

]]> Amped Web 2010 Recap 2010-10-16T03:00:00+00:00 http://brendanforster.com/amped-web-2010-recap.html Disclaimer: I'm currently running on a few hours of sleep so corrections may be required as the memories return. I'm also waiting for some of the photos to surface from the day - including @Rog42's crazy photography experiments!

Yesterday was the Amped Web day, a hack day following the Web Directions South conference held in Sydney. The day is for teams to compete in specific categories - around design and development - and put together a solution in a few hours. It may have been an all-day event, but the time flew by. The solutions were reviewed by judges over the afternoon - providing feedback and suggestions as the teams polished their ideas.

I teamed up with Tatham Oddie (@tathamoddie) and Aaron Powell (@slace) to create a platform and prototype client for a specific problem.

What was that problem? Check out the video!

All the details are available on http://openconferenceprotocol.org/.

Our solution won the Best Overall Windows Phone application, and the "product launch" was a pitch to win the Grand Prize - a trip to Tokyo next month for Web Directions East.

When the dust settled and all the teams had their pitches, the judges decided to send us to Japan! I'm looking forward to seeing the Japanese development community in action, and it will be my first trip to Japan. Time to learn some more Ruby - and some Japanese won't hurt either!

Special thanks to John Allsopp (@johnallsopp) and the other organisers of Web Directions for putting together a great event. The sponsors of the event - Windows Phone, Adobe, Paypal, SBS, the Powerhouse Museum and others - also helped make the day awesome with food, swag and prizes.

I'll have to check out the full conference - and return to defend our title - in 2011.

But now, Tokyo awaits!

Footnote:

We'll continue to polish our idea over the coming weeks - adding features, enhancing the story, getting feedback from the community - so stay tuned for more. I'll put up a higher-res video of the WP7 application for those who are having troubles seeing it clearly in the pitch.

For those who have specific questions, you can leave a comment here or reach me on Twitter (@shiftkey)

]]> Hello World 2010-09-23T00:50:44+00:00 http://brendanforster.com/hello-world.html Starting off this blog with a simple post. More styling to come during the coming days.

Side note: here's the Factorial function in F#:

let rec factorial n =
match n with
| 0 -> 1
| _ -> n * factorial (n - 1)
]]>