Apple Store Lockout

I’m in the market for a new laptop. I’ve spent a fair amount of time looking around and, despite being a 100% Windows user for my entire career, am seriously considering a 15" MacBook Pro Retina for my next upgrade. It’s a massive extravagance but I’m hoping it’ll last me even longer than my tired old Dell 6400.

Now since these things don’t come cheap, I want to have a good opportunity to play with them before I take the plunge. So I went to the Birmingham UK Bullring Apple store on Sunday to have another go with one.

As I arrived at the store, I saw the queue of die-hards outside the shop waiting patiently in line for the new iPad Mini, and decided there was no need for me to join that queue. I asked the chap at the door if I could come in to look at a MacBook.

"Oh we’re queuing just for entrance at the moment."

So I walked away. I still intend to get one of these machines at some point, but it’s safe to say it won’t be going on the monthly sales figures for that store.

I can understand making people queue to get one of the first handful of a new thing (putting aside the artificially-strangled stock availability), but I can’t understand why the store would make me queue behind them to look at something totally different?

DDD: Refactoring toward deeper insight

A good question came up on the DDD/CQRS group earlier today, and I thought I’d publish my response here.

The questioneer was asking how they should model deletions in their domain, where they might have a “Delete[Entity]Command”.

If you read Eric Evans’ DDD book, you’ll find it often talks about “refactoring toward deeper insight“. This basically means when you’re not sure which way to go when modelling the domain that you should go back and talk to your domain experts. Keep talking as the information soaks in and you’ll find yourself picking up on little seemingly throwaway phrases and bits of information here and there. They don’t think are particularly special because they’re so used to them, but to you these little facts are incredibly important. It’s like panning for gold.

In this case, “delete” might not be a use-case your domain experts need. In fact, unless your domain experts are in the domain of computers and file systems, I’d go as far as to say it’s highly unlikely. A Domain Model is just that – a model of the domain. Since most domains are in the real world, “delete” doesn’t really exist. You can’t “delete” a stock item, or a financial transaction. You can perhaps mark a stock item as “lost” or create a reciprocating financial transaction though.

Take an example of sales orders (modelled by a SalesOrder AR). If you ask your domain experts “what happens when you delete an order?” they’ll likely respond “Oh no – you can’t delete orders!”. You explain that’s not quite what you meant, and discover that orders can be “cancelled” or “completed”, in which case you can’t add any more line items.

In this example “completed” and “cancelled ” are the key words, and you’d implement the appropriate invariants in your SalesOrder aggregate root (AR). Of course that implementation may end up as a state machine, but then it’s often the case that an AR works like a state machine (i.e. favour a variable “state” rather than a heap of boolean flags).

In fact in general you should be wary of terms like “create”, “update” and “delete” when modelling your domain. If these are the only verbs in your ubiquitous language you should probably not be using DDD for that system.

Remember that DDD is allowing the Domain to Drive your Design. The Domain Experts know it best so they’re your best tool. Your domain model should reflect behaviours and rules required and defined by the domain experts and only those behaviours and rules.

Session Submission Nerves

People who know me will know that I talk a lot. They would not be surprised to hear that my school reports often included comments from teachers about being talkative to the point of distracting my classmates. I think I’m fairly personable, and enjoy being in company.

Yet I’m still nervous about the fact that last week I submitted a session for DDD10.

Don’t get me wrong; I’m very excited and will be gutted if I don’t get picked to speak (although that’s what voting is all about), but now it’s real. Now I really might have to go through with it.

I’ve got my fingers crossed that I’ll get the gig (and won’t die on my arse). Hopefully everything will go to plan and it’ll all be worth it if I’ve enthused at least a few people about my chosen subject. I’ll be putting a fair amount of preparation in, and I’m fortunate enough to be able to perform live testing on humans at the ShropshireNET user group later this month, but still it’s a new beginning for me and I just hope I’m worthy.

If you fancy finding out a bit more about the practical side of actually doing things with CQRS and Event Sourcing, please feel free to come to the user group session and/or vote for me at DDD10.

Here’s to trying new things and getting out of your comfort zone!


Disclaimer: I know those of you who’ve done computer science or software engineering at university will already know how to do this, and know the name for the pattern, but in case we don’t use it I wanted to show it off somewhere. Smile

A colleague and I just had a code-off without realising it; we were both thinking about the same problem at the same time. That problem being a way to take a list of things, and get a list of the permutations of them.

So { “P1”, “P2”, “P3” } should result in:

    { “P1” },
    { “P2” },
    { “P3” },
    { “P1”, “P2” },
    { “P1”, “P3” },
    { “P2”, “P3” },
    { “P1”, “P2”, “P3” }

I remembered an trick an old boss of mine taught me for finding combinations of items in a series, using bits. If you think of iterating a series of bytes you see the usual pattern:

  • 1 = 00000001
  • 2 = 00000010
  • 3 = 00000011
  • 4 = 00000100

So this means that iterating a numeric value (i.e. 1 to 256) and converting the loop variable to a sequence of bits on each iteration is basically going to generate all the combinations of true and false for a series of 8 boolean flags. That’s the behaviour we’re looking for. Of course, 8 is quite a limitation, but if we use Integer rather than byte we get 32, which is more than enough (in fact I get OutOfMemoryExceptions with a series of 23 items on my 8gig Quad-Xeon machine).

Here’s my implementation. Notice I’m using the trick, but I’m not iterating all the “powers of 2”, I’m iterating the items in a list, and only taking the ones where the bit representing their position in the list is set:

using System;
using System.Collections.Generic;

namespace ConsoleApplication13
    public class Combinator
        public IList<List<T>> AllCombinationsOf<T>(IList<T> items)
            if (items == null) throw new ArgumentNullException("items");
            if (items.Count > 32) throw new ArgumentException("Only 32 values are supported.", "items");

            int top = GetTop(items.Count);

            var permutations = new List<List<T>>();
            for (int combinationId = 1; combinationId <= top; combinationId++)
                AddPermutations(permutations, combinationId, items);

            return permutations;

        private static void AddPermutations<T>(List<List<T>> permutations, int filter, IEnumerable<T> items)
            var permutation = new List<T>();

            int i = 1;
            int bitIndex = 1;
            foreach (var item in items)
                if ((filter & bitIndex) == bitIndex)

                bitIndex = (int)Math.Pow(2, i - 1);


        private static int GetTop(int count)
            int result = 0;
            for (int i = 0; i < count; i++)
                result = (result << 1) + 1;
            return result;

Simplify string and path operations in FinalBuilder with PowerShell

At work we use FinalBuilder as our continuous integration server. Essentially it works like CruiseControl etc, but has software you use to build the project files rather than eating your XML raw. The basis of FinalBuilder is assembling “actions” into a build script that is executed either in the FinalBuilder software, or on a build server running FinalBuilder Server.

Now typically, performing path and string manipulation is tricky, because you need to use FinalBuilder actions like “String Trimming”, “String Replace” and “String Pos”. All of which work on the basis that they take the value of a global variable defined in the project, and set the result to another global variable defined in the project. If you have a lot of string work to do, this can quickly become unwieldy.

So instead, I propose ignoring the built-in string and path manipulation actions, and swopping them all for one or two “Run Script” actions with PowerShell scripts. In my case, I have a URL to a Mercurial repository hosted on a Kiln server passed-in to my project, and I want to apply a convention to work out what the local repository path for me to clone to and build from should be. I do this by:

  1. Adding a single “Run Script” action at the top of my project
  2. Selecting it
  3. In the “Script Editor” window (View->Script Editor), select “PowerShell” as the scripting language
  4. In the script editor window, add the following:

$RepositoriesLocation      = $FBVariables.GetVariable("_RepositoriesLocation") # Global variable configured on FB Server
$RepositoryUrl             = $FBVariables.GetVariable("RepositoryUrl") # Passed-in at runtime
$uri                       = New-Object -type System.Uri -argumentlist $RepositoryUrl

$repositoryName            = $uri.Segments[$uri.Segments.Length – 1].Trim(‘/’) # Parse the repo name
$projectName               = $uri.Segments[$uri.Segments.Length – 3].Trim(‘/’) # Parse the Kiln project name

$WorkingCopyRoot = [System.IO.Path]::Combine($WorkingCopiesLocation, $projectName)
$WorkingCopyRoot = [System.IO.Path]::Combine($workingCopyRoot, $repositoryName)

$FBVariables.SetVariable("WorkingCopyRoot", $workingCopyRoot) # The the global variable for subsequent actions to use

As you can see, this obtains the value passed-in to the project from the HgUrl variable, breaks it up and re-arranges it to produce a local path for the URL. There’s some other stuff about the location of the working copies being in a common location but that’s all there is to it.

I’ve recently gone a bit mad for this approach. How about this method of establishing the solution file to build in any given Hg repository, for example?:

$workingCopyRoot = $FBVariables.GetVariable("WorkingCopyRoot")
$solutionFileFullName = Get-ChildItem $workingCopyRoot -filter *.sln | select-object FullName -first 1
$FBVariables.SetVariable("SolutionFileFullName", $solutionFileFullName)

Happy, erm, “PowerShelling”… 🙂

Windows 8 – The end of an error?

So I hear there’s some news about a new Windows, and people are worried by the 5-minute Windows 8 press release because it mentions HTML5. Some people are really worried. I’m not in tears myself just yet, though I would be upset if the scare-mongers are proved right.

Personally I’m just (finally) starting out in WPF. I really like it and if I’m honest I’m not a great fan of HTML/CSS because of the inconsistencies between browsers. I’m aware I’m not alone in that respect. My worry isn’t about historical investment in WPF, but the fact that I’m just starting out. I hope I’m not writing the new Betamax for my new apps.

However, If one takes a deep breath, relaxes and looks at it again, one could surmise that it’s unlikely .NET will be dropped totally. MS do have a good history (often to their own detriment) of backwards-compatibility, and I reckon that in the fullness of time there will be "layers" of apps:

  1. HTML5/CSS3 for tiles and "widgets", though SL might be part of the "tile" story.
  2. LOB apps that want to talk to local databases and/or webservices etc but still solve the business problems in a RAD-fashion will be Silverlight and WPF (WinForms will surely be supported but possibly discouraged for new apps and relegated to the “legacy” UI that so closely resembles Win7 in the video).
  3. Device drivers and those apps that need to get down to nitty-gritty close-to-the-metal stuff or require super-duper high performance will be for C/C++ devs with brains far larger than mine.

It’s not much different from the decision that WP7 apps being totally SL-based. They’re trying to tidy-up a long-established line of inconsistent apps and UI tech to give "mom and pop" users a better experience. My Dad loves his iPhone but still struggles with the fact that Windows isn’t the Pit of Success when it comes to usability and stability.

Let’s face it, advanced users (application/IT support, testing teams, DBAs, developers) will not use this new HTML5 veneer all that much, because it’s not meant for them. This is MS taking a look at their customer base, comparing it with the iPhone customer base, and realising they need a simpler OS UI that allows people to watch videos, check emails, mess with their pictures etc. It’s simply moving to a "task-based UI" on a grander scale.

Of course, tooling goes a long way to calm .NET devs in these situations. At the moment many may be worried by the prospect of using Notepad to write their Windows apps and struggle with debugging and implementation inconsistencies. However I’m sure that companies like JetBrains and DevExpress will be there to help.

It will be fine, don’t worry. 🙂

Visual Studio Screen Real Estate

I have to say first that I am a total keyboard-freak. I use keyboard shortcuts for all Visual Studio and ReSharper commands. Over Christmas, my main dual-24”-screen development machine developed a fault, and I fell back to my (excellent and highly recommended) Lenovo ThinkPad X201. Of course screen real estate was suddenly an issue, and I decided to do something radical.

I got rid of all the toolbars.

Yep – all of them.

Literally, I right-clicked the toolbar, and un-checked every single one, in both design mode and debugging mode. I then found and installed the Hide Main Menu plugin for Visual Studio.

Now Visual Studio looks like this:


This is good, I like this. Then I fixed my desktop PC, and didn’t want to lose the goodness, but also wanted to make use of VS2010’s improved multi-monitor support. I exported All Settings->General Settings->Window Layouts options to SingleMonitor.vssettings, put that file into my shared DropBox folder to sync it to the desktop, imported it, and customised VS to look like this:


I’ve exported those window layouts to MultiMonitor.vssettings, so I can easily switch between them. Sometimes I move to a single screen even on the desktop in order to read documents/websites on the secondary monitor, or when screen sharing with my colleagues.

If you want my window layout files, you can find them on my page.

Additional Tips:

  1. Don’t forget when customising your window layouts to also customise them when debugging, as VS will switch between layouts as you start and finish debugging.
  2. Try closing toolwindows too. If you learn the shortcuts to get them back (or alternatives) it makes for a much cleaner feel.
  3. Try replacing the solution explorer with ReSharper’s “CTRL+T” command. It’s faster and doesn’t take up space.
  4. Try working in full-screen mode when actually coding (toggle using SHIFT+ALT+ENTER).

I appreciate I may have taken this as far as I could without using vi or something, but hopefully it serves as a little inspiration.