I’ve struggled to write this week. On the one hand, I want to get on with explaining the motivations behind the creation of a new Institute to promote Stewardship in business. I’m particularly excited as things progress and come together. However, the news is awash with the collapse of Thomas Cook, a company within the sector I work.

When the Malvern Group collapsed in August, taking LateRooms and Superbreak with it, I was upset. The 250 employees that lost their jobs were people I knew. Some of them I count as friends. It felt wrong reducing their story to a morality tale to promote an agenda. I feel the same about Thomas Cook and its 21,000 employees. Their pain is genuine and incredibly fresh. What they need are jobs not platitudes, nor wagon hoppers keen to grab attention.

There are a lot of sensationalist articles out there, decrying the executive pay, the role of investors and shareholders. A sentiment to which I’m naturally inclined. However, I need to resist the temptation to pile on. I wasn’t in the room, and so I’m not going to pass judgement on anyone involved. The story of the collapse is unquestionably far more complex than the headlines. Their stories will come out in time, and there will be an opportunity for reflection and presumably condemnation. I hope that individuals will not be allowed to get rich off the pain caused by this failure. It seems a vain hope, a ship that has probably already sailed.

The unavoidable truth is that our world is becoming less fair. Greed and self-interest are on the rise, and that indulgence has an inescapable cost that is too often paid by the most vulnerable. We have become obsessed with the acquisition of wealth, rather than the enrichment of character. Instead, I encourage you to take 5 minutes to watch the incredible Greta Thunberg remind us of the real cost of chasing “money and the fairytales of eternal economic growth.”

At some point, as business leaders, we have to stop looking towards tomorrow to fix the problems of our making. Procrastination is not the painless solution it promises. We have to be willing to make tough decisions today and follow through with them. It is not enough to point at the greed of others and forgive our own with a Trumpesque Whataboutism.

As Greta says, so prophetically, if we don’t change, we won’t be forgiven.

Related Images:

Anyone who has visited me at work has probably had the pleasure of meeting our two favourite volunteers, Bea and Bo. I say “volunteers” as we recently converted to a Living Wage employer, so we no longer consider them part of the staff!

In the UK, dogs are legally considered as property, and as such, I legally own my dogs (see the Theft Act 1968 clause 4 (4) in case you’re wondering). 

Ownership is a word that is banded about a lot, it’s all about rights, and in many cases, exclusive rights. It’s about what an owner is allowed to do with their property. It’s not about what rights that property has. As a concept, ownership sits at the very foundation of our capitalist society.

However, if you’re a pet owner like me, you hopefully don’t feel much like an owner, after all owning a pet is a huge responsibility. Walking dogs, feeding them, taking them to the vet, is an exhausting job – particularly when they bark at 2AM to let you know they’re still on watch. As I write, Bo is making it quite clear that she expects to go play in the garden at work. You do such things, and many more, because you care about your pets, they matter, you love them. I’m their steward.  Stewardship is “the responsible overseeing and protection of something considered worth caring for and preserving”.

As I mentioned in my last post, I recently gained 100% ownership of Web Applications UK. Legally, it became my company exclusively. Just like Bea and Bo though, it came with a considerable burden of responsibility (for example, see the Companies Act 2006). It’s a responsibility I carry because I care about it, it matters, I love it. Sadly though, I see too many cases where companies are just a resource to be exploited. Not all dog owners are good dog stewards, but, in my experience, far fewer company owners are good stewards.  

Social media and the news outlets rightly explode in anger when they see a dog being mistreated. However, when a business owner rips the heart out of his own business, through greed, that’s expected. After all, are not companies there to serve their masters, isn’t that how to get ahead? Should we care about the impact on the employees, the customers, or the wider community?

There’s an exception to the pervasive nature of ownership – you can’t own people. On 26 July 1833, the Slavery Abolition Act had its third reading in the House of Commons.  William Wilberforce died 3 days later, having waged a successful 46-year war against slavery, horrified at the “greed and avarice of the owners”. We should never be surprised when focussing on what we can take, on our exclusive rights, leads to such greed.

For many pet owners, they consider their pets to be like children. As can be seen, the law currently sees it differently. You don’t own your children. Like Wilberforce, I think that’s an excellent thing; and so, just because I legally own Bea and Bo, I don’t consider myself their owner. As far as my company goes, it shouldn’t be surprising I feel precisely the same way. Web Applications UK is not mine, it’s ours. I’m not really giving it away, it was never mine to give – regardless of what the law says on the matter. If you believe, as I do, that a Company is, at its core, a group of people, it begs an important question. Why can we own a Company? After all, has the ownership of Companies really been a net positive for our society?

We can’t all be Wilberforce – I certainly can’t compare my underwhelming achievements to date with his. I’m unlikely to abolish pet ownership and the idea that I could eliminate company ownership appears laughable. People laughed at Wilberforce though, and like him, I am “too young to realize that certain things are impossible… So [I] will do them anyway”. Children prove that ownership is an unnecessary pre-requisite to success. Indeed, ownership is more frequently an obstacle. I believe a focus on Stewardship over Ownership is a good thing, and though it’s not easy, putting Stewardship at the heart of companies is a worthwhile mission.

It’s evident in the creation of Employee Ownership Trusts that the government is starting to grapple with that same avarice and greed that Wilberforce fought. In fact, the structures I’m in the process of creating to gift my company to are based firmly on EOTs as a vital step forward. I’m just not convinced that the solution is more ownership. That’s why I’m fighting to create a new form of EOT called an Employee Stewardship Trust. Maybe, by changing the emphasis, one day, we can abolish corporate slavery too.

Related Images:

On 7 October 2019, I’ll be looking back over 14 years at Web Applications UK, and celebrating my last day as Chief Executive.

When I joined the company all those years ago, it was as a Consultant, working just four days a week. Within 18 months, I was asked to take over as Managing Director and became Chief Executive in February 2009. The ensuing decade has been a trial by fire and a great big mirror in which to discover who I am. An experience for which I am profoundly grateful.

From the outset, my goal has been to innovate – to try something new. The relentless pursuit of profit has never driven me; instead, I have sought to have a positive impact on the lives of those around me. I’ve certainly not always succeeded, but I’ve learnt and grown and made some wonderful friends along the way. When we work for each other, instead of for ourselves, we all benefit. As I said back in 2012, “If one can accept people can rise above selfishness, surely it is a small step to believe that business can too. And if we admire animals for morality, and we clearly admire people for the same traits, then why do we not judge businesses – the ultimate endeavour of our collective efforts – in exactly the same way. Surely the last measure of a business should be its level of self-interest?”

The truth is, self-interest already dominates too much of business, and it is profoundly damaging – something I have frequently experienced first hand. I don’t accept it has to be that way though, and I believe I can’t be the only one who feels that way. Indeed, the focus on people over profit has allowed Web Applications UK to be profoundly successful over the last 20 years. On taking the reins in 2007, one of my first acts was to attempt the formation of an Employee Benefit Trust, which led to the creation of our profit share scheme. I have always wanted to go much further though, and earlier this year, I gained 100% control of Web Applications UK and its assets. It’s at such times in life that we face the hard choice of staying true to our convictions or taking the easy path. I now have the opportunity to follow my dream of creating a new kind of business. That opportunity comes with the temptation of holding on to all I’ve fought so hard to create.

It should come as no surprise that my wife and I have decided to take this fantastic company and place it into the hands of an Employee Ownership Trust. We’re doing it a little differently though.

For a start, we’re not selling the company; it’s a gift. Secondly, we prefer to call it a Stewardship Trust. The Trust’s members (the Employees) may legally own the assets, but it’s in the same way that we legally own our beloved dogs, Bea and Bo. Stewardship is a beautiful responsibility of care, where we invest into something other than ourselves for the joy of it – where the reward is the effect, not the goal. The Trust will be made up of Stewards.

What we are giving away is worth significantly more than we’ve earned over the last fourteen years. We still live in Chadderton, in a modest home, with a mortgage. We are not wealthy, but we are grateful to have the opportunity to do something truly unique and original. Building something that outlasts us makes us far richer than holding tightly to the control we now have. When you love something as much as we love this company and its people, you only want the best for it, and them. Eventually, you have to let things go – to fly on their own.

Over the next few months, our focus will be on the creation of the Trust, and the preparations necessary to affect the transfer of the company and properties into it. We will continue to advocate for the movement and be there to support and encourage the directors and staff. We remain committed to working for the success of the Trust and its members. We hope to see more businesses join us in time as we demonstrate the benefits of allowing people to work for each other – rather than to enrich a chosen few. It’s an end of an era, but the start of something new and exciting. One of my last acts as Chief Executive will be to consign the old name for the company to history. The signs are already coming down, the branding being cleared away to make way for something new. Web Applications UK will be stepping down with me. What rises in its place will be something far better. It’s a grand experiment, a beautiful risk, a new way of doing business. After all, that’s what life should be about right?

Related Images:

If you ask the average business owner whether they have internet access, they are very likely to answer ‘yes’.  If you ask them if they have broadband, most, but not all will continue to answer confidentially in the affirmative.  If you ask them if they have ‘superfast broadband’ a look of confusion slowly spreads across their face.  This isn’t that surprising, as the term is little more than a marketing peg used to upsell consumers, but it is a term readily adopted by OfCom and Whitehall.

OfCom define ‘superfast’ as 25Mb/s or greater, which at first glance seems a helpful clarification.  This definition is based, in part, on the fact that the maximum speed of an ADSL2+ line is 24Mbit/s.  When OfCom talk of ‘superfast’ they really mean the signal is being carried by a fibre optical cable, at least until the cabinet, so the distance travelled over copper wires is minimised.

Unfortunately, megabits per second is not a great way to measure connection value.  It’s equivalent to measuring a car’s performance based on its top speed in feet per second.  Firstly the average consumer is already educated to think of bytes not bits when purchasing IT equipment such as RAM and hard drives, a bit is 1/8^th of a byte, so 8Mb/s is actually only 1 MB/s (megabyte per second).  More importantly, a savvy car purchaser will look at acceleration, fuel economy, and a host of other features when purchasing a car, top speed is actually not that important (so long as it’s over 70mph), and every car buyer knows that it’s not just the make and model that matter, it’s the actual performance of the specific car you’re buying.  Just like cars, identical packages can have very different performance for the end user, based on a number of factors, especially distance to the cabinet, and contention.  Contention, or how many people are trying to use the same connection at the same time, is the least well understood, and yet clearly vital factor when assessing the true value of your internet connection.  In our car analogy contention is the difference between wide open roads and congested country lanes.

When connecting to the internet there are actually two ‘top speeds’, download and upload speed – and they are rarely the same.  When ISPs publish their ‘speeds’ they often refer to the maximum theoretical download speed, which isn’t surprising as these are frequently 10-20% higher than the actual average speed over 24hrs (and worse at peak contention times, around 8-10PM) and are normally at least four times faster than the average upload speed.  In August 2013 the average download speed for the UK was 14.7Mbit/s compared to 1.8Mbit/s upload (over 8 times slower uploads).

For consumers, the asymmetry between download and upload speeds isn’t actually that big a problem, in fact it’s a deliberate design decision.  Consumers largely download from the internet, they send very little back, in comparison.  The problem is that many businesses are ‘producers’ not consumers, for them the upload speed is absolutely critical, but our networks are not designed to meet this need, forcing many businesses to purchase extremely expensive leased lines to get the upload speeds necessary.  Our small businesses are very much second class citizens in the digital age.

A trawl through statements made by our policy makers demonstrates a complete lack of understanding about the subtleties around internet connectivity.  It seems impossible to have vital discussions about improving our digital infrastructure when few understand the difference between 2Mb and 200Mbit, never mind the importance of upload speeds to companies trading over the internet.  This leads to an overly cosy relationship between regulators and the ISP industry and needs to be addressed urgently.  There are huge factors affecting our future ability to compete in the digital age, from net neutrality, to the importance of fibre to the premise verses fibre to the cabinet.

Until our policy makers understand the details, it’s hard to see how they can influence the outcomes positively.

Related Images:

In my last post I introduced the AsyncLock and AsyncDebouncedFunction.  AsyncLock is a fantastic way of asynchronously holding a ‘lock’ without actually blocking threads.  It is the natural go to class for resource synchronization, but there are alternatives (with caveats).

In .Net 4.5 the ConcurrentExclusiveSchedulerPair was introduced, offering a powerful approach to concurrency control.  Using this class, we can schedule tasks to run concurrently or exclusively, and at first glance it appears to offer a powerful alternative to my AsyncDebouncedFunction.

Consider the following code:

int a = 0;
Stopwatch s = new Stopwatch();
// Create a task factory that schedules tasks to run exclusively.
TaskFactory exclusiveFactory = new TaskFactory(new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler);
Func<cancellationtoken, task<int="">> runner = token => exclusiveFactory.StartNew(
	() => {
		int run = Interlocked.Increment(ref a);
		Console.WriteLine("{0}: Started {1}", s.Elapsed, run);
		Thread.Sleep(1000);

		Console.WriteLine("{0}: Completed {1}", s.Elapsed, run);
		return run;
	}, token);
Console.WriteLine();
Console.WriteLine("Testing ConcurrentExclusiveSchedulerPair");
a=0;
s.Restart();
try {
	await Task.WhenAll(
		runner(new CancellationTokenSource(TimeSpan.FromSeconds(0.5)).Token)
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion),
		runner(CancellationToken.None)
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion),
		runner(CancellationToken.None)
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion));
} catch (TaskCanceledException e) {
	Console.WriteLine(e.Message);
}

This creates a new TaskFactory which makes use of the ConcurrentExclusiveSchedulerPair‘s ExclusiveScheduler.  Any tasks created on this factory will run sequentially rather than concurrently, which looks like a great start.  In fact, running this code we get the following result:

Testing ConcurrentExclusiveSchedulerPair
00:00:00.0012267: Started 1
00:00:01.0013490: Completed 1
00:00:01.0014078: Started 2
00:00:01.0017885: Result 1
00:00:02.0019925: Completed 2
00:00:02.0021238: Started 3
00:00:02.0024653: Result 2
00:00:03.0022518: Completed 3
00:00:03.0026929: Result 3

Showing each task runs one after the other, as we expect.  The first problem is that this doesn’t take into account when we created each task, so we don’t get the result re-use we had with AsyncDebouncedFunction.  For that we’d have to create a slightly more involved class, that only runs the inner function on the ExclusiveScheduler.  Before we jump into such an implementation though, consider what happens if we run asynchronous code on the scheduler that yields, for example:

int a = 0;
Stopwatch s = new Stopwatch();
// Create a task factory that schedules tasks to run exclusively.
TaskFactory exclusiveFactory = new TaskFactory(new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler);
Func<cancellationtoken, task<int="">> runner = token => exclusiveFactory.StartNew(
	async () => {
		int run = Interlocked.Increment(ref a);
		Console.WriteLine("{0}: Started {1}", s.Elapsed, run);
		await Task.Delay(1000, token);

		Console.WriteLine("{0}: Completed {1}", s.Elapsed, run);
		return run;
	}, token).Unwrap();
Console.WriteLine();
Console.WriteLine("Testing ConcurrentExclusiveSchedulerPair");
a=0;
s.Restart();
try {
	await Task.WhenAll(
		runner(new CancellationTokenSource(TimeSpan.FromSeconds(0.5)).Token)
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion),
		runner(CancellationToken.None)
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion),
		runner(CancellationToken.None)
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion));
} catch (TaskCanceledException e) {
	Console.WriteLine(e.Message);
}

Here, we’ve told the

runner

  to run asynchronous code that uses Task.Delay() instead of Thread.Sleep().  Note the Unwrap() call as we’re running an asynchronous operation asynchronously!  The result of running this code is not what you might hope (unless you’re paying attention):

Testing ConcurrentExclusiveSchedulerPair
00:00:00.0017058: Started 1
00:00:00.0022739: Started 2
00:00:00.0022872: Started 3
00:00:01.0161957: Completed 3
00:00:01.0162235: Completed 2
00:00:01.0165797: Result 2
00:00:01.0166038: Result 3
A task was canceled.

At first glance there doesn’t appear to be any concurrency at all!  In fact, that’s not entirely true at all, the ExclusiveScheduler is in fact exclusively scheduling the tasks, however Task.Delay() is non-blocking and so yields execution back to the scheduler which allows a waiting task to execute, we can best illustrate this by tweaking our function slightly:

async () => {
		int run = Interlocked.Increment(ref a);
		Console.WriteLine("{0}: Started {1}", s.Elapsed, run);
		Thread.Sleep(100);
		Console.WriteLine("{0}: Yielding {1}", s.Elapsed, run);
		await Task.Delay(800, token);

		Console.WriteLine("{0}: Restarting {1}", s.Elapsed, run);
		Thread.Sleep(100);
		Console.WriteLine("{0}: Completed {1}", s.Elapsed, run);
		return run;
	}

Our function now blocks for 100ms on either side of the 800ms delay, which should illustrate the exclusivity nicely:

Testing ConcurrentExclusiveSchedulerPair
00:00:00.0015790: Started 1
00:00:00.1020952: Yielding 1
00:00:00.1029492: Started 2
00:00:00.2035512: Yielding 2
00:00:00.2036396: Started 3
00:00:00.3043756: Yielding 3
00:00:01.0145095: Restarting 2
00:00:01.1156219: Completed 2
00:00:01.1156772: Restarting 3
00:00:01.1160992: Result 2
00:00:01.2159296: Completed 3
00:00:01.2163921: Result 3
A task was canceled.

Now we can see that each task doesn’t start until the preceding task yields control to the scheduler, so we do still have exclusivity, and the tasks are not running at the same time as each other.  However, they are free to interleave each other.  The take home from these examples is that the ConcurrentExclusiveSchedulerPair‘s ExclusiveScheduler can prevent concurrent access to a shared resource, but the resource may be accessed by another thread at any point you yield control.  When you need to hold a resource across yields then AsyncLock is a more appropriate choice.

The other advantage of ConcurrentExclusiveSchedulerPair is that is also has a ConcurrentScheduler that allows concurrent scheduling (with a configurable concurrency limit, like AsyncSemaphore), that won’t overlap with tasks run on the ExclusiveScheduler, in this way you can easily simulate a reader/writer lock, with the same caveats as above.  Of course, Stephen Toub also provides an AsyncReaderWriterLock for holding locks across yields.

Related Images:

[See image gallery at thargy.com]

With the introduction of the async and await keywords, asynchronous programming has finally become achievable by any .Net developer.  Building on the TPL, async and await extend the C# language specification to make task based programming relatively straight forward, and is a huge step forward from APM.

However, being able to write code that runs asynchronously is only the first step, thinking asynchronously is a whole new set of skills that developers have to master.  For example, how should you access a shared resource from asynchronous code?

There are some great resources out there and one of my favourite blogs is produced by Microsoft’s Stephen Toub who works with the PFXTeam.  A while ago I came across a real gem in this blog, the AsyncSemaphore, which allows us to create an AsyncLock; which, in turn, helps you answer the question above.

But what else can we use an AsyncLock for?  Lots of stuff!

One particularly useful use is to debounce an asynchronous function.  Imagine we have a long running asynchronous function that goes and gets the latest stock price from a web service, if we allow multiple threads to execute the method then it would result in many calls to the same web service, all of which would return the same answer.  A better approach is to run the method once and allow anyone else that asks for the result to wait for the first execution to complete, and return the same result.

Using AsyncLock we can create a class for that:

#region © Copyright Web Applications (UK) Ltd, 2013.  All rights reserved.
// Copyright (c) 2013, Web Applications UK Ltd
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of Web Applications UK Ltd nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL WEB APPLICATIONS UK LTD BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion

using System;
using System.Diagnostics.Contracts;
using System.Threading;
using System.Threading.Tasks;
using JetBrains.Annotations;

namespace WebApplications.Utilities.Threading
{
    /// 
    /// Debounces an asynchronous function.
    /// 
    public class AsyncDebouncedFunction
    {
        /// 
        /// The semaphore controls concurrent access to function execution.
        /// 
        private readonly AsyncLock _lock = new AsyncLock();

        /// 
        /// The asynchronous function to run.
        /// 
        private readonly Func<cancellationtoken, task<tresult="">> _function;

        /// 
        /// The duration ticks is the number of ticks to leave after a successfully completed function invocation, from the start of the last successful invocation.
        /// 
        private readonly long _durationTicks;

        /// 
        /// The gap ticks is the number of ticks to leave after a successfully completed function invocation, from the end of the last successful invocation.
        /// 
        private readonly long _minimumGapTicks;

        /// 
        /// The next run is the earliest tick that the function can be run again.
        /// 
        private long _nextRun;

        /// 
        /// The last result.
        /// 
        private TResult _lastResult;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        ///The function.
        ///The duration is the amount of time the result of a successful execution is held, after the point a successful request was made.
        ///The minimum gap, is the time left after a successful execution before the function can be run again.
        public AsyncDebouncedFunction(
            Func function,
            TimeSpan duration = default(TimeSpan),
            TimeSpan minimumGap = default(TimeSpan))
            : this(token => function(), duration, minimumGap)
        {
            Contract.Requires(function != null);
            Contract.Requires(duration >= TimeSpan.Zero);
            Contract.Requires(minimumGap >= TimeSpan.Zero);
        }

        /// 
        /// Initializes a new instance of the  class.
        /// 
        ///The function.
        ///The duration is the amount of time the result of a successful execution is held, after the point a successful request was made.
        ///The minimum gap, is the time left after a successful execution before the function can be run again.
        public AsyncDebouncedFunction(
            Func<cancellationtoken, task<tresult="">> function,
            TimeSpan duration = default(TimeSpan),
            TimeSpan minimumGap = default(TimeSpan))
        {
            Contract.Requires(function != null);
            Contract.Requires(duration >= TimeSpan.Zero);
            Contract.Requires(minimumGap >= TimeSpan.Zero);

            // Calculate the gap ticks, based on stopwatch frequency.
            _durationTicks = duration.Ticks;
            _minimumGapTicks = minimumGap.Ticks;
            _function = function;
        }

        /// 
        /// Runs the function asynchronously.
        /// 
        ///The token.
        /// An awaitable task, that completes with the debounced result.
        /// If the function is currently running, this will wait until it completes (or
        ///  has been cancelled),
        /// but won't run the function again.  However, if the original function is cancelled, or errors,
        /// then it will run the function again immediately.
        /// 
        public async Task Run(CancellationToken token = default (CancellationToken))
        {
            // Record when the request was made.
            long requested = DateTime.UtcNow.Ticks;

            // Wait until the semaphore says we can go.
            using (await _lock.LockAsync(token))
            {
                // If we're cancelled, or we were requested before the next run date we're done.
                token.ThrowIfCancellationRequested();

                if (requested <= _nextRun)
                    return _lastResult;

                // Await on a task.
                TResult lastResult = await _function(token);

                // If we're cancelled we don't update our next run as we were unsuccessful.
                token.ThrowIfCancellationRequested();

                // Set the next time you can run the function.
                _lastResult = lastResult;
                _nextRun = Math.Max(requested + _durationTicks, DateTime.UtcNow.Ticks + _minimumGapTicks);
                return lastResult;
            }
        }
    }
}

This allows you to create an asynchronous function that will only have one instance running at any time, any multiple calls to the same function will all wait for the result of the currently executing function.  You can also use the

minimumGap

 and

duration

 parameters to cache the result of a successful execution for a period, this is great when you know that an expensive operation’s result doesn’t change too frequently, or that it’s not necessary to have real time, ‘fresh’ results (e.g. when serving a web page).

For example, the code below:

int a = 0;
Stopwatch s = Stopwatch.StartNew();
AsyncDebouncedFunction adf = new AsyncDebouncedFunction(
	async token => {
		int run = Interlocked.Increment(ref a);
		Console.WriteLine("{0}: Started {1}", s.Elapsed, run);
		await Task.Delay(1000, token);

		Console.WriteLine("{0}: Completed {1}", s.Elapsed, run);
		return run;
	});

try {
	await Task.WhenAll(
		adf.Run(new CancellationTokenSource(TimeSpan.FromSeconds(0.5)).Token)
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion),
		adf.Run()
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion),
		adf.Run()
			.ContinueWith(i => Console.WriteLine("{0}: Result {1}", s.Elapsed, i.Result), TaskContinuationOptions.OnlyOnRanToCompletion));
} catch (TaskCanceledException e) {
	Console.WriteLine(e.Message);
}

Produces the following output:

00:00:00.0007214: Started 1
00:00:00.5006508: Started 2
00:00:01.5147577: Completed 2
00:00:01.5151857: Result 2
00:00:01.5152295: Result 2
A task was canceled.

The code tries to run the function three times at once.  The first execution is set to timeout after 0.5s, whereas the second and third executions don’t have a timeout.  The function itself is set to take 1s, therefore the first task will be cancelled before it get’s the opportunity to complete (after 0.5s), which is OK, because the 2nd task will now start immediately, as the first task failed and there is no result yet.  The second task runs to completion, which means the third task (which was also waiting can make use of the result without running the function again.

Debouncing operations can have a huge impact on the performance of real world systems, so I hope you find this piece of code as useful as I do!

Related Images:

[See image gallery at thargy.com]

In my last post I introduced Memory Mapped Files, and discussed how you could mark them as sparse.  Today, I would like to talk a little about performance.  Using LINQPad (my favourite tool!), I created a rough and ready test script which can be downloaded at the end of the article.

The idea was to check the raw read performance of getting an array of bytes from a memory mapped file.  As a control I used Array.Copy to copy the same number of bytes from one

byte[]

to another.  I also was only interested in accessing the same block of memory each time, and took measurements after an initial read, the idea being that I’d expect the data to be in memory and not on disk.

There are two ways of accessing data on a memory mapped file – using a MemoryMappedViewStream and an MemoryMappedViewAccessor.  The former is optimised to provide sequential access (e.g. when reading or writing a block of data) and the later is optimised for random access reading and writing.

Another area of concern for me was to determine how important it was to hold onto the stream/accessor.  That is, what is the cost of creating the stream/accessor on demand, or keeping hold of the disposable object and using it repeatedly.  Clearly, it was highly likely that re-using the same stream/accessor was going to be faster, but doing so could complicate designs so quantifying the relative cost was useful.

You can run the code yourself, but here is the summary of my findings, where each figure represents a factor of how much slower each operation is.  ‘Single’ indicates that multiple loops made use of the same view or accessor, whereas multiple indicates that a new view or accessor was created for each iteration:

All these figures are approximate, and you’re results may vary but they can allow us to draw some general conclusions:

1. Accessors are always slower than streams when reading/writing data sequentially, the difference gets worse as the size of data increases.  Therefore, performance can be greatly improved by always writing data sequentially and in large chunks, however the choice is less important for small amounts of data (less than a kilobyte).
2. There is a cost to creating and disposing accessors, this cost becomes acceptable for accessors when the size of the data being read is in the order of kilobytes, and quickly becomes negligible over 32K.  The benefit of keeping hold of a stream remains significant.
3. When reading a large stream the performance is equivalent to raw memory access.
4. The proportional cost of creating an accessor increases as the size of the buffer is increased, this is the opposite of creating streams – where the cost is fixed and therefore the relative cost decreases.
5. All of this needs to be taken alongside the reality that the slowest operation, reading 32K with a freshly created accessor, took a total of 0.49ms, that’s slow compared to the ~3ns required to copy a 32K

   byte[]

   , but it’s certainly not slow in the grand scheme of things.

These overall conclusions will hopefully help you when designing any systems that leverage memory mapped files.

The code is availabvle as a Gist, or can be downloaded using the button below:

Related Images:

[See image gallery at thargy.com]

Memory mapped files are a powerful addition to the .NET framework in version 4.0.  They’ve been a key part of the windows Operating System since Windows 95, but using them required a working knowledge of COM Interop, as they weren’t exposed directly through the framework.  It’s well worth reading up on them, especially if you’re considering working with files across multiple processes, etc., but one of their biggest features is how efficiently they let you interact with extremely large files.

NTFS has a feature called sparse files, which is particularly useful with large files that mostly contain zero-data (that is where there are large blocks of zeroes in the file).  Combining memory mapped files with sparse files can be extremely powerful.  Unfortunately, .NET doesn’t expose this ability yet, so it’s back to good old COM Interop.  The following snippet will give you an extension method that can be applied to any FileStream to turn the underlying file into a sparse file.

public static class Extensions
{
	[DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
	private static extern bool DeviceIoControl(
		SafeFileHandle hDevice,
		int dwIoControlCode,
		IntPtr InBuffer,
		int nInBufferSize,
		IntPtr OutBuffer,
		int nOutBufferSize,
		ref int pBytesReturned,
		[In] ref NativeOverlapped lpOverlapped
	);

	public static bool MarkAsSparseFile(FileStream fileStream)
	{
		int bytesReturned = 0;
		NativeOverlapped lpOverlapped = new NativeOverlapped();
		return DeviceIoControl(
			fileStream.SafeFileHandle,
			590020, //FSCTL_SET_SPARSE,
			IntPtr.Zero,
			0,
			IntPtr.Zero,
			0,
			ref bytesReturned,
			ref lpOverlapped);
	}
}

There’s a great article about sparse files at http://www.flexhex.com/docs/articles/sparse-files.phtml, which is well worth a read.  One particular caveat of note is that once a file is marked as sparse, the operation cannot be undone, the only way to make it ‘not sparse’ is to rebuild the file from scratch (i.e copy the data into a new file).  As such the best way to use the above is when you create the file initially:

using (FileStream f = File.Create(@"C:\MySparseFile.tmp"))
{
	// Try to mark file as sparse, if this fails then the SetLength will allocate the full file size.
	if (!MarkAsSparseFile(f))
		Log("Failed to create world as sparse file.");

	// Set file length
	f.SetLength(size);
	f.Close();
}

Now we can create our memory mapped file from our newly created sparse file:

using (MemoryMappedFile m = MemoryMappedFile.CreateFromFile(@"C:\MySparseFile.tmp"))
{
	// TODO Use our file!
}

Related Images:

[See image gallery at thargy.com]

We do a lot of interviews at Web Applications, especially with the launch of our Apprenticeship scheme.  Over the years I’ve seen the best and worst of what candidates bring to the table.  Unfortunately, there’s far more bad than good, and it’s so unnecessary.

Every now and then I get invited to speak at conferences and seminars about interview technique, and back in October I found myself speaking at the Engineering, Science & Technology Fair at Manchester Central.  The University of Manchester recorded it for their students to refer to and I’ve finally got my hands on a copy, so apologies for the poor quality.  If you’re looking for a new job I really hope you find this helpful, and if you’re applying for a job with us here then, to be frank, you’d be an idiot not to watch this!

Related Images:

OK, so yesterday I returned with a really simple piece of code that’s convenient when building stack frames.

After stacks, the next easiest/most convenient structure has to be the queue.  No surprise then that .NET has a similarly generic

Queue 

 class.

It seems appropriate to give it the same treatment –

public class Queue<T1, T2> : Queue<Tuple<T1, T2>>
{
    public void Enqueue(T1 item1, T2 item2)
    {
        Enqueue(new Tuple<T1, T2>(item1, item2));
    }
}

public class Queue<T1, T2, T3> : Queue<Tuple<T1, T2, T3>>
{
    public void Enqueue(T1 item1, T2 item2, T3 item3)
    {
        Enqueue(new Tuple<T1, T2, T3>(item1, item2, item3));
    }
}
public class Queue<T1, T2, T3, T4> : Queue<Tuple<T1, T2, T3, T4>>
{
    public void Enqueue(T1 item1, T2 item2, T3 item3, T4 item4)
    {
        Enqueue(new Tuple<T1, T2, T3, T4>(item1, item2, item3, item4));
    }
}
public class Queue<T1, T2, T3, T4, T5> : Queue<Tuple<T1, T2, T3, T4, T5>>
{
    public void Enqueue(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
    {
        Enqueue(new Tuple<T1, T2, T3, T4, T5>(item1, item2, item3, item4, item5));
    }
}
public class Queue<T1, T2, T3, T4, T5, T6> : Queue<Tuple<T1, T2, T3, T4, T5, T6>>
{
    public void Enqueue(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
    {
        Enqueue(new Tuple<T1, T2, T3, T4, T5, T6>(item1, item2, item3, item4, item5, item6));
    }
}
public class Queue<T1, T2, T3, T4, T5, T6, T7> : Queue<Tuple<T1, T2, T3, T4, T5, T6, T7>>
{
    public void Enqueue(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
    {
        Enqueue(new Tuple<T1, T2, T3, T4, T5, T6, T7>(item1, item2, item3, item4, item5, item6, item7));
    }
}
public class Queue<T1, T2, T3, T4, T5, T6, T7, TRest> : Queue<Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>>
{
    public void Enqueue(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
    {
        Enqueue(new Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>(item1, item2, item3, item4, item5, item6, item7, rest));
    }
}

I won’t insult you with example usage, but hopefully I’ve saved someone some typing.

Related Images:

[See image gallery at thargy.com]

OK, clearly I have been remiss in my bloging duties and owe you all some code.  To be fair, it’s because I’m head down developing a brand new platform that will form the basis of our future products and it really has been all go.

One of the most fundamental structures in programming languages is the stack.  It’s an insanely useful structure, particularly for analysing hierarchical data, but also for removing recursion from code (because recursion is oft times bad).

C# has a handy generic 

Stack

  class – which can be used like so-

Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
Console.WriteLine(stack.Pop()); // Outputs: 2
Console.WriteLine(stack.Pop()); // Outputs: 1

Basically, you push things onto the top of the stack, and pop them off later.  It’s amazing what you can do with such a simple concept, but that’s not the topic of this post.

When you start doing more complex operations, you often find you want to put quite a bit of data onto the stack, rather than just a simple class.  I often find, in this particular scenario, it’s time to create a custom class/struct to hold the data.  However, sometimes, you just need something really simple.  It’s at times like those our old friend the Tuple comes in handy.  However, the code starts looking really unwieldy alarmingly quickly-

Stack<Tuple<int, string, bool>> stack = new Stack<Tuple<int, string, bool>>();
stack.Push(new Tuple<int, string, bool>(1, "One", false));
stack.Push(new Tuple<int, string, bool>(2, "Two", true));

Tuple<int, string, bool> frame = stack.Pop();
// Outputs: 2, Two, True
Console.WriteLine(string.Format("{0}, {1}, {2}", 
    frame.Item1,
    frame.Item2,
    frame.Item3));

frame = stack.Pop();
// Outputs: 1, One, False
Console.WriteLine(string.Format("{0}, {1}, {2}", 
    frame.Item1,
    frame.Item2,
    frame.Item3));

We can solve this really easily though, by extending

Stack

  to support multiple values:

public class Stack<T1, T2> : Stack<Tuple<T1, T2>>
{
    public void Push(T1 item1, T2 item2)
    {
        Push(new Tuple<T1, T2>(item1, item2));
    }
}

public class Stack<T1, T2, T3> : Stack<Tuple<T1, T2, T3>>
{
    public void Push(T1 item1, T2 item2, T3 item3)
    {
        Push(new Tuple<T1, T2, T3>(item1, item2, item3));
    }
}
public class Stack<T1, T2, T3, T4> : Stack<Tuple<T1, T2, T3, T4>>
{
    public void Push(T1 item1, T2 item2, T3 item3, T4 item4)
    {
        Push(new Tuple<T1, T2, T3, T4>(item1, item2, item3, item4));
    }
}
public class Stack<T1, T2, T3, T4, T5> : Stack<Tuple<T1, T2, T3, T4, T5>>
{
    public void Push(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
    {
        Push(new Tuple<T1, T2, T3, T4, T5>(item1, item2, item3, item4, item5));
    }
}
public class Stack<T1, T2, T3, T4, T5, T6> : Stack<Tuple<T1, T2, T3, T4, T5, T6>>
{
    public void Push(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
    {
        Push(new Tuple<T1, T2, T3, T4, T5, T6>(item1, item2, item3, item4, item5, item6));
    }
}
public class Stack<T1, T2, T3, T4, T5, T6, T7> : Stack<Tuple<T1, T2, T3, T4, T5, T6, T7>>
{
    public void Push(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
    {
        Push(new Tuple<T1, T2, T3, T4, T5, T6, T7>(item1, item2, item3, item4, item5, item6, item7));
    }
}
public class Stack<T1, T2, T3, T4, T5, T6, T7, TRest> : Stack<Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>>
{
    public void Push(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
    {
        Push(new Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>(item1, item2, item3, item4, item5, item6, item7, rest));
    }
}

Now we can write the same code in a much nicer way:

Stack<int, string, bool> stack = new Stack<int, string, bool>();
stack.Push(1, "One", false);
stack.Push(2, "Two", true);

var frame = stack.Pop();
// Outputs: 2, Two, True
Console.WriteLine(string.Format("{0}, {1}, {2}", 
    frame.Item1,
    frame.Item2,
    frame.Item3));

frame = stack.Pop();
// Outputs: 1, One, False
Console.WriteLine(string.Format("{0}, {1}, {2}", 
    frame.Item1,
    frame.Item2,
    frame.Item3));

Simple, but very effective.  Let me know if it helps you out in the comments below.

Related Images:

[See image gallery at thargy.com]

For those interested in another sample of our in-house training here is a snippet where I introduce the singleton pattern:

Related Images:

[See image gallery at thargy.com]

Every couple of weeks I give an ‘off the cuff’ talk on .NET fundamentals.  Its always fast paced, irreverent, opinionated and completely unprepared (you can tell).

Aimed at our developers – as part of their continuous professional development – the 1hr+ talks are recorded and used as part of our training regimen. It’s not for the feint hearted.

Every now and then our design team cuts them down to 15 minutes of raw ramblings to give people a taste of what its like being a developer at Web Apps.

The latest one, covering structs, is here:

Related Images:

[See image gallery at thargy.com]

So the current BBC naval gazing is kind of getting old, but today’s public outcry on the reported £450k pay off to the outgoing Director General of the BBC raises the kind of questions that I can’t resist letting pass without comment.

What has driven me to write this post (on my iPhone no less) is the ignorance of the ministers and MPs concerned. The reality being that this particular mess is likely entirely of their causing.

Over the last decade the Employment Tribunal has become so skewed and one sided against employers that dismissing anyone is nearly impossible, particularly anyone who has any claim to continuous service. Entwistle, as a career Beeber, was an untouchable. Moreover, he was clearly a politically expedient scapegoat – being in post for a mere 55 days, he was only as personally responsible as the vast array of Senior Managers drawing huge salaries from a typically top heavy publicly funded institution. His crime was that of too many bureaucrats, avoiding decisions rather than making them.

So to the £450k (an amount that exceeds my career earnings), not a bad hall for a 55 day stint. The Chair of the BBC Trust, Chris Patton, has revealed that the Trust expressed its concern to Entwistle on the Saturday and made it clear that they were considering his dismissal. At this point very few outcomes remained. In such a position Entwistle would find it near impossible to return to a place where he enjoyed the trusts confidence, had nothing happened, over time he would have been forced out, or at least edged out.

Having the threat of dismissal over his head Entwistle could resign and immediately claim constructed dismissal. In the modern world he would have won, and the BBC would have paid out a full severance package, plus loss of earnings, potential damages and legal fees. The mess would have been significant, the BBC would sustain further damage to its reputation, and the costs would have been greater than those of a straight dismissal as he had a contract which required the £450k severance amount.

What happened (probably!) is a confidential voluntary agreement. These are the norm these days, as businesses do not win at tribunal. Instead a business pays off the leaver, letting them resign, so as to avoid a tribunal and its associated costs. By its very nature the existence of the agreement can never be revealed by either party. This lets the BBC remove the man they shouldn’t have appointed, and to move on, without fear of repercussion.

It is modern day piracy and it occurs daily across the country. The only people that get these agreements are, in my bitter experience, the same selfish, manipulative, devious leeches that deserve them the least. That said it is a foolish executive that willingly faces a tribunal no matter how true their cause. Tragically, even winning at tribunal is entirely Pyrrhic, and victory is never guaranteed in the skewed halls of ‘justice’.

So don’t criticise the BBC for being pragmatic. In reality the £450k has saved the public purse a future pay out that would undoubtedly have been worse. Criticise the weak executive for appointing Entwistle in the first place and criticise the government for creating a tribunal system that believes the ‘right to work’ comes independent of a ‘responsibility to work’. Criticise a contract for having a one year severance clause, even criticise the size of the salary for an ‘honourable man’.

As for Mr Entwistle, we should judge him by the amount of money he draws down. I suspect he’ll take every penny, despite being so ‘honourable’. I hope that in a similar situation I’d have the moral fortitude to take what I deserve morally and not what I may be ‘entitled’ too, but how many of us would honestly walk away from such a pay out, after all he no longer has to clean up the mess that’s left.

The way these things work, I suspect Mr Entwistle will appear on some board somewhere in a few months when people stop paying attention.

Related Images:

[See image gallery at thargy.com]

When it comes to my favourite ‘new^*’ classes in the .NET BCL, one of my top ten is definitely the ConcurrentDictionary .  So much so, that (after IEnumerable) it’s probably one of the classes I go back to most frequently to solve any particular problem (particularly caches).

I still remember the frustration and failure I felt when I realised my own lovingly crafted solution to the problem of concurrent dictionaries was so enfeebled (particularly in performance, but also design) by this truly beautifully crafted class, and it didn’t take me long before I turned the power of reflection onto the class to unlock it’s dirty little secrets.  This is one of those gems that was written by the smarter guys at Microsoft, trust me they didn’t write everything in the BCL!

So it was with huge surprise that, a month or two ago, this Wunder-Klasse revealed another little beauty from behind its polished exterior.  The concurrent dictionary is fantastic for storing singular values in, but what happen when I want to store something more complex, in particular, an enumeration?  My solution was to create a ConcurrentLookup that implements ILookup.  I’d like to revisit the solution in a later post, but for now, let’s talk about what I discovered…

You see, ultimately the ‘standard’ public methods of the ConcurrentDictionary only get you so far before you come up against a big problem.  When removing a key, how do I make sure it only get’s removed if the value is what I think it is?

Well, the answer (in brief) is best illustrated by some example code –

// Create the dictionary
ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();

// Add [1, 2] and [2, 3]
dictionary.GetOrAdd(1, 2);
dictionary.GetOrAdd(2, 3);

// This will succeed
Assert.IsTrue(((ICollection<KeyValuePair<int, int>>) dictionary)
.Remove(new KeyValuePair<int, int>(1, 2)));

// Let's get the value from 2 and confirm it's 3.
int value;
dictionary.TryGetValue(2, out value);

Assert.AreEqual(value, 3);

// Meanwhile, imagine this runs on another thread...
dictionary.AddOrUpdate(2, 4, (k, v) => 4);

// This remove will fail as value still equals 3, but the dictionary now contains 4!
Assert.IsFalse(((ICollection<KeyValuePair<int, int>>)dictionary)
.Remove(new KeyValuePair<int, int>(2, value)));

// The dictionary keeps it's key nice and safe.
Assert.IsTrue(dictionary.ContainsKey(2));

This little horror shows that by casting the dictionary to one of its interfaces you can access an underused interface method explicitly.

I’ve known from day zero that ConcurrentDictionary implements the ICollection interface for the corresponding KeyValuePair, but it wasn’t until I was snooping around inside the source code that I stumbled across the private TryRemoveInternal  method, that had a mysterious matchValue  parameter.  It was a short hop to putting two and two together.  The method is technically in MSDN, but it’s not something you’d spot and the implications are not particularly obvious.  The fact that the designers chose to implement the method explicitly so that it wouldn’t be accessible without casting, is normally a hint that it is not a good idea to use it.  In fact, the BCL is littered with examples where such methods throw an exception, however, this one is designed to work as advertised, but you’d never know if Microsoft didn’t publish the source so readily.

Just another good reason to spend a bit of time digging deeper.

I hope this little gem solves a problem for you today if it does, let me know!

^* ‘New’ as in it wasn’t in the first version of .NET I ever used!

Related Images:

[See image gallery at thargy.com]

Well it’s been a while since my last post, frankly I’ve been heads down in a code rush (maybe I’ll let you in on it a little later), so I figured for my first post back I best make it a big one.  Following, from the success of my guest lecture at Manchester, I was invited to speak to the students at Salford University.  Whenever I manage to trap someone within ear shot I can’t help but bombard them with my views on education, let’s just say it’s something I’m genuinely passionate about, so the theme was similar to my last one.  Hopefully though, it was more focussed, as instead of trying to cover too much I zoomed in on talking about a career in IT.

It’s in my nature to stimulate debate, and I’m a sucker for throwing in the odd controversial comment to garner a reaction, but my motivation is an honest one.  I genuinely believe the best course of action for a graduate developer is to find a job where they are inspired by their peers to become the best they can be.  In my experience, that doesn’t come from being the ‘hero developer’ in a one man team, there’s a place for such people, but it’s not working for me.  The real greats stand on the shoulders of giants.

Anyway, it was literally standing room only at Salford and the nearly ninety strong cohort of students (from all years) seemed genuinely interested as it took me a good half an hour to get away after I’d finished.  I’ve included the video below for everyone who missed it, hopefully it will encourage more graduates to seek out careers working with people who will inspire them.

Related Images:

The first time I came to this great state was in September 2001.  The first time I came to Denver was to visit the airport on 10 September 2001.  The 18th African Children’s Choir were set to fly back to West Africa, via Belfast and Choir 19 (that I was chaperoning) met up with them to hand over some equipment and say goodbye.  We had a concert that evening in Colorado Springs but went with the choir to say goodbye.

A month before we had been in Albuquerque, New Mexico.  I had stayed with a wonderful host family, a brother and sister, and one morning I awoke to see a sky full of 750 hot air balloons, as the Albuquerque International Balloon Fiesta got under way.

As always we were performing a concert in a local church, and I always made a point of helping the local sound engineers out with tuning, repairs and set up – most are volunteers and always appreciated the help.  This time I struck gold, as the engineer was actually a registered flight instructor and a jumbo pilot for one of the major airlines.  Before I knew it I was in the cockpit of a Cessna flying over the New Mexico plains.  I often repeat this story to young people as being mostly blind in one eye I can ‘never be an airplane pilot’, but on that day in 2001 I was just that.

A month later though, I was standing at the gate waving goodbye to Choir 18.  Airports in America were no different to bus stations, it was so different to Heathrow or UK airports were we lived under the shadow of the IRA bombings.  It was friendly and fun.

Choir 18’s flight was just past the point of no return when the planes hit the Twin Towers, so they weren’t turned around and made it to Belfast.

The next few weeks in Colorado will remain with me for ever.  I couldn’t go a night without a host family asking me why ‘everyone hated America so much’.  It was a country waking up to the idea that they weren’t universally loved, that there were people out there that would do them harm, and like most people there initial reaction was horror and a genuine fear that meant they had no concept of the scale of the issue.  The next attack could come at any second, they were in a war they don’t remember entering.  In 2001 you would rarely see any news about the world outside the US, by October that all changed.  The conversations I had were haunting, painful, people were genuinely scared.

During that time, I fell in love with Colorado, and when we left to continue our tour in Utah, the memories of those conversations and the place stuck with me.  A beautiful state, with beautiful people.

Ten years later, I was in a completely different life.  Instead of a volunteer sound engineer with the African Children’s Choir, I was Chief Executive of Web Applications UK – a rapidly growing IT company expanding into the US.  When the question came as to where we would base our new head office, Colorado was always going to be first choice.  We came out in May 2011 and stayed in Colorado Springs for the first time since that 2001 trip, and I fell in love with the state once again.

Today we’re back signing paperwork and preparing the final steps of launching Web Applications US.  It’s and arduous complex process, countries don’t make it as easy as possible for foreigners to form businesses and create jobs.  Vivienne and I are staying in Denver for the first time since I was here with the Choir.  Late last night a young man walked into a midnight premier of “The Dark Knight Rises” and shot and injured seventy men, women and children, twelve of them died, and a number remain in critical condition as I write.  The cinema is just down the road from where we’re staying, and once again I find myself in the heart of a community struggling to come to terms with inexplicable tragedy.

A lot is being said about gun control and second amendment rights.  The media is obsessed with the gunman and his potential motives and wild stories are flying around.  The scale of the tragedy is growing with each fresh announcement, and people are reeling.  I’ll leave those conversations for others, instead I want to focus on the two things that made me fall in love with Colorado all those years ago.  The people and the place.

The Coloradoan spirit is indomitable, they will reel, they will mourn, they will grieve, but they will ultimately survive.  The night of the tragedy I was in Parker meeting with members of the Parker Chamber of Commerce.  We wanted to meet business men and women from the town to get a sense of the spirit of the place.  Web Applications UK is committed to Oldham and it’s local community, it defines the kind of business we want to be.  For Web Applications US we want to ensure that same anchor to the local community exists.

The people I found weren’t suspicious, unfriendly, wary.  They were warm, welcoming and kind.  For a state and a community that has lived through Columbine, September 11 and now the Aurora Shooting, I have no doubt that the people will remain true to themselves and to their spirit.

Finally, I fell in love with the place.  The beautiful Rockies, the lakes, rivers and streams, the rolling hills and grasslands; Colorado is one of the most beautiful places in the entire world.  No crazed gunman will ever change that.  When Web Applications US finally opens shop fully, it will have a beautiful home and employ beautiful people.

Related Images:

[See image gallery at thargy.com]

When it comes to the Queen, I’m a big fan.  It’s become fashionable to mock the pomp and circumstance and to view her Highness as a dusty old relic of a bygone age, but to do so is to misrepresent a monarch that has done more to modernise and adapt than any predecessor – and she’s had to, reigning through the Commonwealth’s must turbulent and transitional period.

When asked to attend Oldham’s Jubilee celebration at Oldham Parish Church I jumped at the opportunity.  I was hugely privileged to represent Oldham Business and light a candle, alongside the Lord Lieutenant of Manchester and Mayor of Oldham.  A last minute addition also saw me representing one element of life in borough when I got to present two parts of a PC as symbols of Oldham’s history as the first town to manufacture and build computers at Ferrantis.  I had a quick look as I took my seat, and both were PCI-133 cards, one a modem (circa 2003) and one an aging SCSI connector (circa 2004).

Earlier in the day we hosted the Olympic Torch on it’s way around the country in advance of the upcoming games.  Just like the Queen it’s easy to point at Oldham and see a town of past glories, of little relevance in the modern world.  Cynics bore me with their lack of imagination!  When I see Oldham, I see a town full of talented and great people, full of optimism about our collective future.  These new Oldhamers are the only people I want to associate with.

As the Oldham Choir and Oldham Music Centre Brass Ensemble blasted out Handel’s “Zadok the Priest” I was taken back to a time when community mattered and coming together in acts of celebration were commonplace.  Too easily we sit at home throwing stones when what’s needed is a willingness to step out of our comfort zones and work together to make something truly special.  If our Queen has taught us anything, it’s that a life dedicated to service and quiet humility can survive the stones and arrows of the harshest critics, and that determination can bring about transformation in seemingly immutable institutions.

God save our Queen, long to reign over us!

Related Images:

[See image gallery at thargy.com]

Today I had the privilege of addressing the graduating cohort of about forty-five students and their police trainers from the Natural Born Leader’s programme being run by Greater Manchester Police.  This great programme takes young people on a week-long course to develop their natural leadership skills.

The speaker before me was Duane Bryan, who was a candidate on this years ‘The Apprentice’ and he talked about his experiences on Alan Sugar’s show.

I was asked to explain how I had ended up as a business leader and to wrap up the week for the students by summing up my thoughts on leadership.

Leadership ultimately relies on an ability to understand what drives people, and I made reference to one of my favourite animations from the RSA “Drive: The surprising truth about what motivates us”.

In brief, I asserted that people are motivated by 3 things (the alternative PMA definition):

Purpose – the belief that what they are doing is for a reason and will ultimately have impact.
Mastery – the ability to continue to improve to a point of mastering a skill.
Autonomy – the authority to make the decisions required to achieve your goals.

And leaders display 5 key qualities:

Cohesion – the ability to inspire a group of people towards a common purpose.
Decisiveness – the acceptance of the value of failure, empowering a leader to make decisions.
Persistence – the determination to give strategies enough time to succeed.
Opportunism – the ability to recognise and grasp opportunities as they present themselves.
Service – the genuine desire to produce positive outcomes for those you lead.

The whole talk is embedded below –

[youtube http://youtu.be/e_5uhpN8aP8]

Related Images:

[See image gallery at thargy.com]

This article first appeared as a guest blog on the GMCC Blog on 22 June 2012.

I’m a technologist. I have an iPad and an iPhone, I have Android and Windows devices, I have an Xbox, a PS3, a Wii and even an AppleTV. It would be natural to think that I believe in technology as the solution to our woes. You would be very wrong. I believe in people.

When gadgets ‘do something clever’ it is because a genius told them to. Why worship the created when you can admire the creator? The only problem is that creators are distressingly in short supply. The reason for this is not a lack of desire or passion, according to the CRA the number of Computer Science graduates continues to rise. Young people still see I.T. as a rewarding career. The problem is our failure to inspire and develop the next generation to their true potential. Traditional training has flourished in industries which change little from year to year but it is wholly inappropriate for the world of I.T., where what you know today is out of date tomorrow. The concept of I.T. courses delivered by trainers is dated and unsuccessful, what developers are crying out for is I.T. courses delivered by developers not trainers.

Developers are too expensive to waste time on ineffective training, but something has to break the impasse. For that reason, we’re training our software engineers to train rather than trying to teach trainers to develop. It’s a revolutionary concept and requires some juggling, but it is vital to the future of our industry.

On the 29th June we’re opening the Centre of Excellence, an I.T. training facility where you won’t see any trainers. The professionals delivering the courses all work in industry – writing software all day – they’re taking a break to introduce you to an exciting new world. I hope you’ll join us.

Related Images:

[See image gallery at thargy.com]

Right, let me start by apologising for being a bit lax on the blogging front.  To be fair the Wi-Fi connection in Rhodes was a little underwhelming, and although I did pen an article it disappeared into the ether.  However, I’ve not been wasting my time off!  Thanks to everyone who left me so many positive comments about my last article, it was really encouraging to see so many people agreeing with the need for us to rethink the concept of shareholdings and I have a number of follow ups planned.

In the meantime, it has been a hugely exciting week here in Oldham.  For years we have talked about the Metrolink and it’s pending arrival.  There have been naysayers a plenty, but on Wednesday the first tram ran from Oldham mumps through Victoria station into the heart of Manchester, on a line that will eventually continue all the way to Manchester Airport!

Vivienne and I, joined a host of Webbies on Thursday evening at The Comedy Store for one of our many staff night’s out.  For the first time we decided to use the newly opened line and jumped on at the Freehold stop, a brisk 5 minute walk from home.  In just over half an hour we got off at the Deansgate stop, which sits (quite literally) atop The Comedy Store.  Oldham has officially arrived!

Levity aside, why does this matter?  I’ve been an avid supporter of Metrolink and its arrival in town.  As one of the larger land owners in the Mumps area, Web Applications has had every reason to join the ranks of bemoaners who have sniped continuously about the disruption, traffic issues and delays that have accompanied this huge infrastructure project.  There are few companies that can have been more effected by road closures.  Yet we chose to move to Mumps in 2009 believing (at a time many didn’t) that the Metrolink would indeed come, and being fully prepared for it’s impact.

We did so because we believe that change is necessary and, although painful, is vital to our town’s resurgence.  Too often it easy to criticise change, and in doing so it invariably discourages future investments.  Instead by having belief, by making do and being creative during the disruption (with flexible starting hours) we now stand to reap the benefits of improved transport links – right to our doorstep.

I genuinely put Web Applications’ success to a willingness to not only accept change positively, but to a willingness to drive change.  In the modern economy it’s not about Change Control it’s about Change Driving.

Andy Crane interviewed me for BBC Radio Manchester just over a week ago about the opening –

Related Images:

[See image gallery at thargy.com]

OK, call me nostalgic, but I loved this game back in the day, so I decided to become a kickstarter backer, I really hope this sees the light of day, only a little more money to raise!

Related Images:

[See image gallery at thargy.com]

As I’ve mentioned before, I just don’t buy the fallacy that profit is the sole driving force of great businesses.  If you are a business owner (like I am), then it’s easy to understand why profit is such a motivation; profitable companies frequently equate to wealthy owners (though they don’t have to).  In my own case I (and my fellow owners) don’t rip the heart out of the business with huge dividends, instead we use profits to drive growth and reinvest in the business.

The concept of profit focused businesses is ultimately a selfish one.  A drive to profit at all costs devalues investment, growth, job creation and CSR for the sake of enrichment.  It’s also a view that ultimately derives from the common belief that people are inherently selfish.  I don’t buy that either, it’s a flawed projection of what Darwin was saying, rather than a substantive fact.  In my travels around the world I have spent time with literally thousands of people from numerous cultures, and I just can’t subscribe to such a view.  In my own experience, most of the people I meet are a complex mixture of selfish and selfless desires.

Gordon Gecko got it wrong –

“The point is, ladies and gentleman, that greed – for lack of a better word – is good.
Greed works.
Greed clarifies, cuts through, and captures the essence of the evolutionary spirit.
Greed, in all of its forms – greed for life, for money, for love, knowledge – has marked the upward surge of mankind.
And greed – you mark my words – will not only save Teldar Paper, but that other malfunctioning corporation called the USA.”

In fact, in his book “The Age of Empathy: Nature’s Lessons for a Kinder Society “, Frans de Waal (the dutch primatologist and ethologist) debunked the belief that humans are inherently selfish, demonstrating selfless traits in other species.  I particularly like the following quote –

“The possibility that empathy resides in parts of the brain so ancient that we share them with rats should give pause to anyone comparing politicians with those poor, underestimated creatures.”

He also alludes to the admirable quality of empathy when he talks about my favourite subject (dogs) –

“I’ve argued that many of what philosophers call moral sentiments can be seen in other species. In chimpanzees and other animals, you see examples of sympathy, empathy, reciprocity, a willingness to follow social rules. Dogs are a good example of a species that have and obey social rules; that’s why we like them so much, even though they’re large carnivores.”

If one can accept people can rise above selfishness, surely it is a small step to believe that business can too.  And if we admire animals for morality, and we clearly admire people for the same traits, then why do we not judge businesses – the ultimate endeavour of our collective efforts – in exactly the same way.  Surely the last measure of a business should be its level of self-interest?

Which is why we need to rethink public companies.  For too long the role of the collective ‘shareholder’ has been an obsession over profitability.  I’m somewhat ambivalent to the recent government consultation on executive pay, which aims to hand yet more control to the shareholder masses.  On the one hand it helps prevent executives seeing businesses as a personal bank, to be leached for their own gain, on the other it reinforces the idea that the role of a shareholder is to stay out of the way unless it comes to issues regarding profitability.

Would that it were possible to come up with a concept where shareholders were rewarded based on their level of impact within an investment.  Shareholders, as a general collective, are focused purely on the return on their investment. I’m sure there are individual shareholders who would disagree – that take interest in the ethical impact of their investments, and indeed their are companies that offer ethical investment opportunities – but as a collective whole the evidence is pretty damning.

Jack Welch, former CEO of General Electric, gave a speech that launched the concept of shareholder value.  To quote wikipedia –

On August 12, 1981, Jack Welch made a speech at The Pierre in New York City called ‘Growing fast in a slow-growth economy’.  This is often acknowledged as the “dawn” of the obsession with shareholder value. Welch’s stated aim was to be the biggest or second biggest market player, and to return maximum value to stockholders.

In March 2009, Welch criticized parts of the application of this concept, calling a focus on shareholder quarterly profit and share price gains “the dumbest idea in the world”.  Welch then elaborated on this, claiming that the quotes were taken out of context.

In reality, the legal premise of a publicly traded company is to maximise profits, in such a context public traded companies should not be deserving of our highest respect.

Does that mean I’m anti-profit?  Far from it!  In fact the danger of such polarising articles is that they can state one side of a coin too vehemently.  In reality profit is a necessity for thriving business, it is a key component of stability and growth.  In that context, profit is vital.  But it should never be the sole measure of a company any more than the ability to breathe is the true measure of a man.

We should aim higher, and we should look long and hard at how we judge companies.

Related Images:

[See image gallery at thargy.com]

If you haven’t done so so already, start with –

Simulating SQL Server (Part 1)
Simulating SQL Server (Part 2)

In the first two posts, I introduced the SqlTester library, which can be downloaded at the bottom of this post.  I also showed a series of classes that implemented IDataRecord and IDataReade to allow the creation of ‘fake’ database connections when testing code in unit tests.  For anyone who has tried messing around with compact databases (and the like) in their test projects, the resulting library can be a real time saver.

I also showed how the library could be used to quickly generate random data, using the same techniques first discussed in Generating Randomness.  That means we have the tools to create real test data and create lots of random data.  There is still one thing missing in our arsenal if we want to achieve a reasonable level of code coverage with our data layer tests.  We need to be able to simulate exceptions.

In the first post in the series, I introduced the IObjectRecord interface without comment, whilst introducing the ObjectRecord  class that implemented the interface.  It may have seemed strange that I placed an interface there, why not just use the class itself?  In the second post, I also introduced the IObjectSet , but this time, I showed two implementations – ObjectSet  and RandomSet .  The beauty of using the interfaces is it makes it easy to extend the base library yourself with further implementations.

It should come as no surprise then that I’ve included another implementation of IObjectRecord  as well – ExceptionRecord .  As the name suggests this record will throw an exception whenever it is accessed.  Unlike our other records, though, we don’t need to supply a record set definition.  Just like with a normal error we won’t be able to access any columns or data without this error being thrown anyway, so knowing the record set definition is irrelevant.

// Create an exception record (note it also implements IObjectRecord but does not require a record set definition
IObjectRecord exceptionRecord = new ExceptionRecord(new InvalidOperationException("Throw me throw a record set."));

// Add it to a new record set somewhere.
ObjectSet recordSet = new ObjectSet(recordSetDefinition)
{
    ...,
    exceptionRecord,
    ...
};

With this one class we can now ‘poison’ any record set, and make it fail exactly when we want to, and in the way we want to.

Of course, we still have a small problem here, what if we want to simulate an actual SQL Server error?  Perhaps your code (correctly) only intercepts exceptions descending from SqlException.  Unfortunately, there is no public constructor for creating a SqlException, after all, you shouldn’t normally be able to create one yourself as it’s reserved for errors coming from SQL.

Thankfully, using the power of reflection, pretty much anything is possible, so I created some prototype classes to solve this particular conundrum for you easily.  As a technique you can use this for any such similar problem, but bare in mind people make classes private for a reason, so use with caution!

// To create a record that throws an exception we first create a SqlException
// We can't do this directly, but we can use our prototypes to construct one.

// SqlExceptions are made from a collection of SqlErrors - which can make like this :
SqlErrorCollection errorCollection = new SqlErrorCollectionPrototype
    {
        new SqlErrorPrototype(1000, 80, 17, "MyFakeServer",
         "Connection Timeout.", "spMySproc", 54)
    };

SqlException sqlException = new SqlExceptionPrototype(errorCollection, "9.0.0.0", Guid.NewGuid());
IObjectRecord exceptionRecord = new ExceptionRecord(sqlException);

So how do these work?

Well basically all three prototype classes (SqlErrorPrototype , SqlErrorCollectionPrototype  and SqlExceptionPrototype ) correspond to a framework class (SqlError, SqlErrorCollection and SqlException respectively).  And all three have implicit conversion operators defined to allow conversion between the prototype class and it’s corresponding framework class.  For example, SqlErrorPrototype  contains the following code –

/// <summary>
/// Implicit conversion from <see cref="SqlErrorPrototype"/> to <see cref="SqlError"/>.
/// </summary>
/// <param name="prototype">The prototype.</param>
/// <returns>The result of the operator.</returns>
/// <remarks></remarks>
public static implicit operator SqlError(SqlErrorPrototype prototype)
{
    return prototype != null
               ? prototype.SqlError
               : null;
}

/// <summary>
/// Implicit conversion from <see cref="SqlError" /> to <see cref="SqlErrorPrototype" />.
/// </summary>
/// <param name="sqlError">The SQL error.</param>
/// <returns>The result of the operator.</returns>
/// <remarks></remarks>
public static implicit operator SqlErrorPrototype(SqlError sqlError)
{
    return sqlError != null
               ? new SqlErrorPrototype(sqlError)
               : null;
}

Because we can implicitly convert to and from the prototype, the prototype can be used anywhere the real class is needed.

If you look at the methods above, you’ll also see a reference to a public readonly  field called SqlError .  This field is actually created the moment you create an instance of the object –

/// <summary>
/// Initializes a new instance of the <see cref="SqlErrorPrototype" /> class, and in doing so initializes the <see cref="SqlError" /> property.
/// </summary>
/// <param name="infoNumber">The info number.</param>
/// <param name="errorState">State of the error.</param>
/// <param name="errorClass">The error class.</param>
/// <param name="server">The server.</param>
/// <param name="errorMessage">The error message.</param>
/// <param name="procedure">The procedure.</param>
/// <param name="lineNumber">The line number.</param>
/// <param name="win32ErrorCode">The win32 error code (if this error is the first in a <see cref="SqlException">SqlException's</see> collection then
/// this value will create an <see cref="SqlException.InnerException">inner exception</see> of type <see cref="Win32Exception"/>.</param>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
/// <remarks></remarks>
public SqlErrorPrototype(int infoNumber, byte errorState, byte errorClass = 17,
                         string server = "Unspecified server", string errorMessage = "Unspecified error",
                         string procedure = "Unspecified procedure", int lineNumber = 0, uint win32ErrorCode = 0)
    : this(
        _constructor(infoNumber, errorState, errorClass, server, errorMessage, procedure, lineNumber,
                     win32ErrorCode))
{
}

/// <summary>
/// Initializes a new instance of the <see cref="SqlErrorPrototype" /> class.
/// </summary>
/// <param name="error">The error.</param>
/// <remarks></remarks>
public SqlErrorPrototype([NotNull] SqlError error)
{
    Contract.Assert(error != null);
    SqlError = error;
}

Looking a the highlighted lines you can see that this calls an internal method (in fact it’s a private static readonly  field of type Func<…> ) that creates our actual SqlError.  So how is this magic function created?  Well, it’s created in a static constructor, and here comes a great example of where statics are useful.  Because it’s in the static constructor it will be called once (and only once) whenever the class is first accessed – this is a cheap effective (and thread-safe) way to solve lazy initialisation.

/// <summary>
/// Creates the <see cref="_constructor"/> lambda.
/// </summary>
/// <remarks></remarks>
static SqlErrorPrototype()
{
    // Find SqlError constructor.
    ConstructorInfo constructorInfo =
        typeof (SqlError).GetConstructor(
            BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.CreateInstance, null,
            new[]
                {
                    typeof (int),
                    typeof (byte),
                    typeof (byte),
                    typeof (string),
                    typeof (string),
                    typeof (string),
                    typeof (int),
                    typeof (uint)
                }, null);
    Contract.Assert(constructorInfo != null);

    // Create parameters
    List<ParameterExpression> parameters = new List<ParameterExpression>(4)
                                               {
                                                   Expression.Parameter(typeof (int), "infoNumber"),
                                                   Expression.Parameter(typeof (byte), "errorState"),
                                                   Expression.Parameter(typeof (byte), "errorClass"),
                                                   Expression.Parameter(typeof (string), "server"),
                                                   Expression.Parameter(typeof (string), "errorMessage"),
                                                   Expression.Parameter(typeof (string), "procedure"),
                                                   Expression.Parameter(typeof (int), "lineNumber"),
                                                   Expression.Parameter(typeof (uint), "win32ErrorCode")
                                               };

    // Create lambda expression.
    _constructor = Expression.Lambda<Func<int, byte, byte, string, string, string, int, uint, SqlError>>(
        Expression.New(constructorInfo, parameters), parameters).Compile();
}

Using the exact same techniques we create the other two prototype classes, which of course are in the code you can download.  I shall leave an explanation of how the code above works until a later post (when I introduce a generic function for creating Action<…> s and Func<…> s) but for now be assured that calling the resultant function is as quick as calling the constructor directly (and way quicker than the appalling Activator.CreateInstance).

Finally, the ObjectReader  has a few public methods that aren’t exposed via the IDataReader interface (or the collection interface).  In the end, the ObjectReader  is a simple collection that keeps track of a single enumeration through it, unlike normal collections, where you can request multiple enumerators and enumerate them independently.  As any seasoned .NET developer will tell you, you can’t modify a collection whilst it is being enumerated.  So once you start using an ObjectReader  you can’t manipulate its contents.  To be accurate you can add/remove records to a record set other than the current one, but you can’t add/remove record sets.

To see where the ObjectReader  got up to you can use the CurrentSet  and Current  properties, which return the current set and the current record (which will be in the current set) respectively.

Unlike a real data reader, though, you can also use the Reset  method on ObjectReader  to reset the data reader back to the start (whilst keeping the data intact) so you can re-run a test (for example).

In the end, there’s a lot of functionality in the library and although I’ve covered some of the basics in these posts you can’t beat diving into the code and playing with it, so I recommend you view the code on GitHub or use the download link below to see the complete project.  All I ask is that you leave a comment or feedback, and even some suggestions if you’d like improvements.  The code is free to use in open source or commercial projects, just acknowledge it’s source.

I hope you find a use in your own tests!

Related Images:

[See image gallery at thargy.com]

If you haven’t read it already, why not start with Simulating SQL Server (Part 1)?

Last time we looked at creating a RecordSetDefinition  as a collection of ColumnDefinition s.  Once we had a way of defining what a recordset looks like, we then were able to create an ObjectRecord .

The next step is to collect those ObectRecord s together into a record set implementation.  For this I’ve added and ObjectSet .

Interestingly the BCL don’t expose a ‘recordset’ independently, instead, it’s always accessed through an IDataReader .  We want to be able to manipulate our recordsets though, so I added an IObjectSet  interface, and we can use the collection operators to make our sets, including Collection Initializers.

// We can stick these records into a recordset
// Note the records must have the same RecordSetDefinition (unless it's an exception record)
// The final record will through an exception when reached!
ObjectSet recordSet = new ObjectSet(recordSetDefinition)
{
new ObjectRecord(recordSetDefinition, 1, "Test", "This is my test record"),
new ObjectRecord(recordSetDefinition, true)
};

As we can create records independently of a record set (again great for testing a method that accepts an IDataRecord) then we need to be sure that any records we add to our record set implement the same RecordSetDefinition .  The above example adds two records, the second of which is random, of course, we can add and remove objects as we like –

// Create a random record and add it.
IObjectRecord randomRecord = new ObjectRecord(recordSetDefinition, true);
recordSet.Add(randomRecord);

// And remove it again.
recordSet.Remove(randomRecord);

But in many cases, we may not care about the actual data (or we want to test how well it copes with random data).  We already showed how to create a random record, so what we need is a fully random record set, and thankfully I added one of them too-

RandomSet randomSet = new RandomSet(recordSetDefinition);

Couldn’t be easier – using the information from the recordSetDefinition  this creates between 0 and 1000 rows of random data.  There are lots of useful optional parameters here as well –

/// <summary>
/// Initializes a new instance of the <see cref="RandomSet" /> class.
/// </summary>
/// <param name="recordSetDefinition">The record set definition.</param>
/// <param name="minRows">The min rows.</param>
/// <param name="maxRows">The max rows.</param>
/// <param name="nullProbability">The probability of a column's value being set to SQL null (0.0 for no nulls) [Defaults to 0.1 = 10%].</param>
/// <param name="columnGenerators">The column generators is an array of functions that generate a value for each column, if the function is
/// <see langword="null"/> for a particular index then a random value is generated, if it is not null then the function is used. The function takes
/// the current row number as it's only parameter and must return an object of the correct type for the column.</param>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
/// <remarks></remarks>
public RandomSet([NotNull] RecordSetDefinition recordSetDefinition, int minRows = 0, int maxRows = 1000,
double nullProbability = 0.1,
Func<int, object>[] columnGenerators = null)

Which compares quite favourably to the full signature for creating a record –

/// <summary>
/// Initializes a new instance of the <see cref="ObjectRecord" /> class.
/// </summary>
/// <param name="recordSetDefinition">The table definition.</param>
/// <param name="randomData">if set to <see langword="true" /> fills columns with random data; otherwise fills them with their default values.</param>
/// <param name="nullProbability">The probability of a column's value being set to SQL null (0.0 for no nulls) -
/// this is only applicable is <see paramref="randomData" /> is set to <see langword="true" /> [Defaults to 0.1 = 10%].</param>
/// <param name="columnGenerators">The column generators is an array of functions that generate a value for each column, if the function is
/// <see langword="null" /> for a particular index then a random value is generated, if it is not null then the function is used. The function takes
/// the current row number as it's only parameter and must return an object of the correct type for the column.</param>
/// <param name="rowNumber">The optional row number to pass to the generator.</param>
/// <exception cref="System.ArgumentException">Thrown if the number of column generators exceeds the number of columns in the record set definition.</exception>
/// <remarks></remarks>
public ObjectRecord([NotNull] RecordSetDefinition recordSetDefinition, bool randomData = false,
double nullProbability = 0.1,
Func<int, object>[] columnGenerators = null, int rowNumber = 1)

Two useful parameters here include nullProbability  which determines how likely nulls will appear in columns (that are defined as allowing nulls) and columnGenerators  which allow a function to optionally be specified for columns that you want to generate specific values for (e.g. lookup out of an array). An example is shown below.

Now we have a recordset, it’s only used in an IDataReader , so for this, we create another Collection, ObjectReader  which implements IDataReader  as well as ICollection<IObjectSet> . Again we can use Collection Initializers –

// We can add recordsets to an ObjectReader
ObjectReader reader = new ObjectReader
{
recordSet
};

We now have a reader with one record set in it but more, can be added, e.g. a random set –

// We can also fix certain rows values using the column generators arry, a null indicates
// that the column should us a random value, otherwise a lambda can be supplied - in this case
// it sets the row to the row number (1 - indexed).
reader.Add(new RandomSet(recordSetDefinition,
columnGenerators: new Func<int, object>[] {null, row => "Row #" + row}));

And finally, we can use this reader just like a normal data reader –

// Now that we have a reader we can use it like a normal reader - it even simulates disposal.
using (IDataReader dataReader = reader)
{
int recordset = 1;
do
{
Trace.Write("Recordset #" + recordset);
int rows = 0;
while (dataReader.Read())
rows++;
Trace.WriteLine(" - " + rows + " rows.");
recordset++;
} while (dataReader.NextResult());
}

Again the full project can be viewed on GitHub or use the download link below to see the complete project.  Next time we will look in more detail at the other functions of the ObjectReader, and also we’ll attempt to simulate realistic SQL Server errors.

Related Images:

[See image gallery at thargy.com]

Ever since the release of .NET 1.1, there has existed an AssemblyVersionAttribute.  This attribute determines the version number boiled into all .NET assemblies that is (supposed to) indicate something about when the assembly was built.

Whenever you create a new C# project in Visual Studio, it helpfully creates an “AssemblyInfo.cs” file (found in the project’s ‘Properties’ subfolder), that the new developer generally ignores (to their cost).  This file is mostly auto-generated and manipulated from the project’s property pane.

For example, the above property pane from a blank console application leads to the following “AssemblyInfo.cs” file:

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ConsoleApplication1")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ConsoleApplication1")]
[assembly: AssemblyCopyright("Copyright ©  2012")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible
// to COM components.  If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("4891b4c5-8e51-495b-ad47-1cb2f5a4e20e")]

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

Unfortunately, the usefulness of the property pane means too many developers never get round to looking at this bit of code, or the helpful comments, which is why Visual Studio hides it away in the “Properties” subfolder in the first place.

The first thing to note is the funny syntax [assembly: AssemblyVersion(“1.0.0.0”)] .  Actually, if you take a look at the MSDN attributes documentation, you will see that this is the full syntax for declaring an attribute – the bit before the :  is actually the attribute target being set explicitly rather than being implied.  This is particularly useful for assembly attributes – where there’s no code element to stick them next to.  Actually, from the same documentation, you’ll notice some of the other elements that can be targeted with an attribute – but that’s another story that I might come back to in a later post.

So these are just normal attributes, targeted at an assembly itself.  And there’s quite a few of them.  As you can see from the above screenshot, it’s possible to edit them all using the “Assembly Information…” link on the first pane of the project’s properties panel.  However, if you take the time to read the helpful comments in the source you can find some really useful information, and (importantly) you learn about the “1.0.*” assembly version trick.

When you specify version as “1.0.*” it get’s set automatically at build time to a new value which is based on the date and time of the build – which is exactly what we want!  So what we need to do here is to change the last two lines to –

[assembly: AssemblyVersion("1.0.*")]

If you drop the AssemblyFileVersion  attribute then the file version is set to being, the same as the assembly version (which is what you want in the majority of cases).

At this point, if you’re getting confused by AssemblyVersion  in the code, but AssemblyVersionAttribute  in the documentation, then don’t worry you can use either as the attribute name, but by convention (and for convenience) C# lets you drop the “Attribute” suffix from the attribute class name.

So what happens if we build our console application – well we get a nice executable file and if we browse to it and open up the file’s properties pane we can see the following on the details tab:

As you can see the File version and Product version (which is our “AssemblyVersion”) are both set to “1.0.4511.14207” and if we built it again – it changes:

Now it’s set to “1.0.4511.14356”.  So clearly, this is a different version of the application.  It’s probably worth pausing and pointing to the other useful information in the properties window, which also comes from the assembly attributes.  If nothing else you now know why it’s worth spending the time setting all those values!  (Though in the example above they’re all defaulted).

But what about those numbers, let’s be honest they’re hardly very useful, apart from indicating which build was newer (14356 is more than 14207).  Well, in fact, going back to our friend MSDN, we discover that version 3 of the documentation for AssemblyVersionAttribute has the following useful nugget of information:

“When specifying a version, you have to at least specify major. If you specify major and minor, you can specify an asterisk (*) for the build. This will cause the build to be equal to the number of days since January 1, 2000, local time, and for revision to be equal to the number of seconds since midnight local time, divided by 2.”

So the “4511” in our example is the number of days since 1 January 2000, and the “14356” is the number of seconds since midnight, divided by 2.  Great, has anyone got a calculator?  Funny you should mention that –

After a lot of internal debate about using things like revision numbers from source control systems (which we did for a while) or using invalid version numbers like 1.0.20110508.75832 (each element is supposed to be a 32-bit integer), I threw together the above little utility to allow easy conversion between the default version number and the actual date and time.  So from our original example, you can see the date was today (8 May 2012) and the time was 7:53AM (notice the last updated was 8:53AM because of daylight saving)

The second build was 5 minutes later.

So we can now get really useful information from builds – in fact, you can also drag assemblies straight onto the tool –

In the example above, you can see the debug and release assemblies were built at different times.

The other buttons allow useful stuff like auto-generation (to show the current date & time in version format) and copy to clipboard.

This tool is ‘commentware’ that is use it as much as you want but please leave me a comment !

Related Images:

[See image gallery at thargy.com]

In my last post, I talked about creating random values for all kinds of interesting types.  One of the biggest complaints I get when encouraging developers to implement unit tests (or dare I say even start thinking about TDD as a development methodology) is that testing code that accesses databases is a huge pain.  For this reason, most code is written to use a data layer which is accessed by easily mockable interfaces.

But what of the data layer itself?  Well too often it goes untested, occasionally some brave developer might introduce a ‘test database’ into the solution, or even a ‘test script’ for building a test database.  But that takes time, it’s a pain and nine times out of ten it’s overkill.

As an alternative, I decided to create a really simple set of classes that implement IDataReader and IDataRecord, and (as much as possible) allow simulation of a SQL Server connection.  The goal was to allow unit tests to be created quickly and (most importantly) consistently without requiring a separate database.

The first step to achieving this aim was to be able to define what a recordset looks like.  All this information is required by the above interfaces, so it was a good starting place.  To do this I started by looking in the System.Data.SqlClient namespace which is defined in the System.Data assembly.  Using reflection I quickly found the internal MetaType  class, which handily defines all the known types supported by SQL Server.

From the information gleaned from reflection, I could create my own class that given a SqlDbType (or even a DbType) could fill in all the other useful information for you automatically, using an ugly (but highly effective) large switch statement.

In most cases the type is enough, however for more complex types, more complex information is needed.  The constructor accepts a number of optional parameters:

/// <summary>
/// Initializes a new instance of the <see cref="ColumnDefinition" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="sqlDbType">The columns type.</param>
/// <param name="length">The length (if fixed length).</param>
/// <param name="fill">if set to <see langword="true" /> expects the column to be full (only appropriate for fixed length columns).</param>
/// <param name="isNullable">if set to <see langword="true" /> the column is nullable.</param>
/// <param name="defaultValue">The default value (required if column is not nullable).</param>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if the <see paramref="sqlDbType"/> is unsupported.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if the <see paramref="defaultValue"/> is invalid for the specified <see paramref="sqlDbType"/>.</exception>
/// <remarks></remarks>
public ColumnDefinition([NotNull] string name, SqlDbType sqlDbType, int length = -1, bool fill = false,
                        bool isNullable = true, object defaultValue = null)
{
    ...
}

The fill  parameter helps indicate whether any values used fill the length (e.g. for fixed length types like char) or whether the length indicates a maximum (e.g. for varchar).  The isNullable  parameter is self-explanatory, but it is notable that the defaultValue  must always be supplied if isNullable  is false.

One we have column definitions we use them to define a recordset, this is done with our RecordSetDefinition  class, which accepts an enumeration of ColumnDefinition  objects in its constructor.  For example:

// To create a record that implement IDataRecord we start with a record set definition.
RecordSetDefinition recordSetDefinition = new RecordSetDefinition(
    new ColumnDefinition("ID", SqlDbType.Int),
    new ColumnDefinition("Name", SqlDbType.Char, 50),
    new ColumnDefinition("Description", SqlDbType.NVarChar),
    // This column is not nullable so defaults to true
    new ColumnDefinition("Active", SqlDbType.Bit, isNullable: false, defaultValue: true)
    );

This immediately meets our goal of providing a clean intuitive syntax for quickly defining a table (or recordset) to be used by our reader.

Once we have a definition for a recordset we can create records.  The easiest way is with the ObjectRecord  class.

IObjectRecord dataRecord = new ObjectRecord(recordSetDefinition, 1, "Test", "This is my test record");

The constructor used accepts a RecordSetDefinition  and a set of values (of type object ) which are validated against the definition.  Any missing values (in the above example the ‘Active’ column is not supplied) are set to their defaults as defined by the RecordSetDefinition .

If we don’t want to explicitly set the values, and we want more than their defaults, we can use the other constructor –

/// <summary>
/// Initializes a new instance of the <see cref="ObjectRecord" /> class.
/// </summary>
/// <param name="recordSetDefinition">The table definition.</param>
/// <param name="randomData">if set to <see langword="true" /> fills columns with random data; otherwise fills them with their default values.</param>
/// <param name="nullProbability">The probability of a column's value being set to SQL null (0.0 for no nulls) -
/// this is only applicable is <see cref="randomData" /> is set to <see langword="true" /> [Defaults to 0.1 = 10%].</param>
/// <param name="columnGenerators">The column generators is an array of functions that generate a value for each column, if the function is
/// <see langword="null" /> for a particular index then a random value is generated, if it is not null then the function is used.  The function takes
/// the current row number as it's only parameter and must return an object of the correct type for the column.</param>
/// <param name="rowNumber">The optional row number to pass to the generator.</param>
/// <exception cref="System.ArgumentException">Thrown if the number of column generators exceeds the number of columns in the record set definition.</exception>
/// <remarks></remarks>
public ObjectRecord([NotNull] RecordSetDefinition recordSetDefinition, bool randomData = false,
                    double nullProbability = 0.1,
                    Func<int, object>[] columnGenerators = null, int rowNumber = 1)
{
    ...
}

which will randomly fill in the columns with valid values, using the code we wrote in Generating Randomness.  For example –

IObjectRecord randomRecord = new ObjectRecord(recordSetDefinition, true);

With these two classes, we can create an object that faithfully implements IDataRecord, without installing a database into our test project.

Next time we will look at creating a record set and a data reader, but in the meantime, you can view the code on GitHub or use the download link below to see the complete project.

Related Images:

[See image gallery at thargy.com]

My new year’s resolution for this year was to not only start blogging more frequently but also to Open Source some of our core libraries that I’ve worked on over the years. In preparation for that though it’s important I cover some of the basics and explain the reasoning behind some of the code we’ll be putting out there.

I thought we’d start with something pretty easy, but hopefully with enough twist to interest more advanced readers. Today I’m starting with random number generation – or more precisely random stuff generation. This will form part of some future test code, but for now, I’d like to look at this small subset of the overall problem.

The first thing about the random generation in .NET is the System.Random class. Now, I’m assuming you’re mostly familiar with this little gem, but if not, here are some quick examples –

// Create a random number generator
Random random = new Random();

// Generate a random number between 0 and Int.MaxValue-1 inclusive.
int a = random.Next();
// Generate a random number between 0 and 49 inclusive.
int b = random.Next(50);
// Generate a random number between 10 and 49 inclusive.
int c = random.Next(10, 50);

// Generate a random double between 0.0 inclusive and 1.0 exclusive
double d = random.NextDouble();

// Fill a buffer with random bytes (each byte having every possible value).
byte[] buffer = new byte[10];
random.NextBytes(buffer);

The important (and often missed) point of these examples is that the upper bound of the Next overloads is exclusive, that is it’s impossible to get Int32.MaxValue using the Next overload. Even worse, you can’t get any negative values. Similarly, NextDouble will only give you values greater than or equal to 0.0 or less than 1.0, which is hardly the whole range of possible doubles!

If we really want to be thinking about random number generation, the really useful method is the NextBytes method – and I’m going to flog it to death!

So first of all, what makes a good random ‘thing’ generator. Well priorities change based on application but at the top of my list is always “It must be theoretically possible to get every conceivable value” – this isn’t always achievable, but it’s the main goal for my implementations. After that, I normally place “It mustn’t be slow”, and finally, “Uniform distribution of values would be nice”. However, I don’t personally put uniformity ahead of performance.

I know in this regard I’m not going to get everyone’s agreement, however, in justification bare in mind that to actually get a random generator to give every possible long (by way of example) randomly would take so incredibly long that it’s uniformity is not that useful.

Ahead of everything, though, I want my Random number generators to be thread safe, and System.Random certainly isn’t (yet so many people miss that). The safest way to use a random is to declare a new one just before it’s use – but that creates a load of objects that need garbage collection. Way better is to have one Random per thread of execution – that way you don’t have to worry about locking, as a thread can’t interrupt itself.

Now achieving this scenario used to be a lot harder than it is in .NET 4 – now it’s easy –

/// <summary>
/// Creates one random generator per thread.
/// </summary>
[NotNull] private static readonly ThreadLocal<Random> _randomGenerators =
  new ThreadLocal<Random>(() => new Random());

/// <summary>
/// A random number generator.
/// </summary>
[NotNull] public static Random RandomGenerator
{
  get
  {
  return _randomGenerators.Value;
  }
}

The key here is the wonderful new System.Threading.ThreadLocal generic class. This allows us to create a field that has a different value on each thread (which is created by the lambda expression), so we can get a different Random on each thread – but only one per thread!

Now that I’ve solved thread safety let’s get on with creating our generators. For this, I want to add extension methods to the System.Random class, so I’m going to need a static class. to define them in (which in my project is called Tester as it’s part of my testing NuGet).

So let’s start with some easy ones –

/// <summary>
/// Generates a random boolean.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static bool RandomBoolean(this Random random )
{
  return (random ?? RandomGenerator).Next(2) == 1;
}

/// <summary>
/// Generates a random byte.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static byte RandomByte(this Random random)
{
  return (byte) (random ?? RandomGenerator).Next(0x100);
}

/// <summary>
/// Generates a random char.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static char RandomChar(this Random random)
{
  return (char) (random ?? RandomGenerator).Next(0x10000);
}

These classes us our good old Random.Next to create simple types, being careful to remember that the upper bound is exclusive (and that chars are Unicode!). If you call the methods directly (i.e. not as extension methods) and pass in null, they will use the RandomGenerator defined above, otherwise you can specify your own Random object.

Now we can turn our attention to creating a random integer, that can have every possible value –

/// <summary>
/// Generates a random Int32.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static int RandomInt32(this Random random)
{
  byte[] bytes = new byte[4];
  (random ?? RandomGenerator).NextBytes(bytes);
  return BitConverter.ToInt32(bytes, 0);
}

This method creates a 4-byte array and fills it with random bytes using the built-in random generator. Unlike Random.Next , it gives a uniform distribution of every possible Int32 value (including Int32.MaxValue and negatives).

We can extend the same principle to quite a few other types –

/// <summary>
/// Generates a random Int16.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static short RandomInt16(this Random random)
{
  byte[] bytes = new byte[2];
  (random ?? RandomGenerator).NextBytes(bytes);
  return BitConverter.ToInt16(bytes, 0);
}

/// <summary>
/// Generates a random Int64.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static long RandomInt64(this Random random)
{
  byte[] bytes = new byte[8];
  (random ?? RandomGenerator).NextBytes(bytes);
  return BitConverter.ToInt64(bytes, 0);
}

/// <summary>
/// Generates a random float.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static float RandomFloat(this Random random)
{
  byte[] bytes = new byte[4];
  (random ?? RandomGenerator).NextBytes(bytes);
  return BitConverter.ToSingle(bytes, 0);
}

/// <summary>
/// Generates a random double.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static double RandomDouble(this Random random)
{
  byte[] bytes = new byte[8];
  (random ?? RandomGenerator).NextBytes(bytes);
  return BitConverter.ToDouble(bytes, 0);
}

As you can see our new RandomDouble covers the whole double range, unlike Random.NextDouble() which is a nice result.

The next few types are going to get a little more tricky and require us to know something about their underlying implementations, for example, the decimal type. This can be constructed with four integers, but the last one is a bit special as it encodes a scale and a sign, and not all values are allowed (or possible) –

/// <summary>
/// Generates a random decimal.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks></remarks>
public static decimal RandomDecimal(this Random random)
{
  random = random ?? RandomGenerator;

  // Calculate last byte
  // We need a scale from 0-28 and a sign, so calculate a random number between -28 & 28.
  // This makes +'ves sligthly more common (as 0 is positive) but is faster.
  int scale = -28 + random.Next(57);
  int sign = 0;
  if (scale < 0)
  {
  sign = unchecked((int) 0x80000000);
  scale = -scale;
  }

  // Now we can create msb.
  int msb = sign + (scale << 16);

  return
  new decimal(new[]
  {
  random.RandomInt32(),
  random.RandomInt32(),
  random.RandomInt32(),
  msb
  });
}

The first three integers are generated using our previous RandomInt32 method, but the last integer is calculated separately to ensure it’s always valid. We have to apply the same level of care to the DateTime generators –

/// <summary>
/// Generates a random date time, with a specific <see cref="DateTimeKind" />.
/// </summary>
/// <param name="random">The random generator.</param>
/// <param name="kind">The <see cref="DateTimeKind" />.</param>
/// <returns></returns>
/// <remarks></remarks>
public static DateTime RandomDateTime(this Random random, DateTimeKind kind)
{
  // Last two bits are used internally by date time.
  long ticks = RandomInt64(random) & 0x3FFFFFFFFFFFFFFF;

  // If ticks is more than max value, just and it to ensure less than max value.
  if (ticks > 0x2bca2875f4373fff)
  ticks &= 0x2bca2875f4373fff;

  return new DateTime(ticks, kind);
}

/// <summary>
/// Generates a random date time.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks>Also generates a random <see cref="DateTimeKind" />.</remarks>
public static DateTime RandomDateTime(this Random random)
{
  random = random ?? RandomGenerator;
  // Last two bits are used internally by date time.
  long ticks = RandomInt64(random) & 0x3FFFFFFFFFFFFFFF;

  // If ticks is more than max value, just and it to ensure less than max value.
  if (ticks > 0x2bca2875f4373fff)
  ticks &= 0x2bca2875f4373fff;

  DateTimeKind kind;
  switch (random.Next(3))
  {
  case 0:
  kind = DateTimeKind.Utc;
  break;
  case 1:
  kind = DateTimeKind.Local;
  break;
  default:
  kind = DateTimeKind.Unspecified;
  break;
  }

  return new DateTime(ticks, kind);
}

/// <summary>
/// Generates a random date time.
/// </summary>
/// <param name="random">The random generator.</param>
/// <returns></returns>
/// <remarks>Also generates a random <see cref="DateTimeKind" />.</remarks>
public static DateTimeOffset RandomDateTimeOffset(this Random random)
{
  random = random ?? RandomGenerator;
  // Last two bits are used internally by date time.
  long ticks = random.RandomInt64() & 0x3FFFFFFFFFFFFFFF;

  // If ticks is more than max value, just and it to ensure less than max value.
  if (ticks > 0x2bca2875f4373fff)
  ticks &= 0x2bca2875f4373fff;

  // Calculate random offset +/- 14 hours in minutes (offsets must be in minutes)
  long offsetTicks = (TimeSpan.TicksPerHour*-14) + (TimeSpan.TicksPerMinute*random.Next(1680));

  // Ensure offsetTicks don't take us outside of the DateTime range.
  // We could decrease/increase ticks and round to nearest minute, but it is easier just to set to 0.
  long ticksOffset = offsetTicks - ticks;
  if ((ticksOffset < 0) ||
  (ticksOffset > 0x2bca2875f4373fff)) offsetTicks = 0;

  return new DateTimeOffset(ticks, TimeSpan.FromTicks(offsetTicks));
}

These required a lot more thought but they’ve been thoroughly tested and checked, so feel free to use them even if the comments aren’t immediately transparent to you!

Finally, we probably want to be able to generate random strings –

/// <summary>
/// Generates a random string.
/// </summary>
/// <param name="random">The random generator.</param>
/// <param name="maxLength">Maximum length.</param>
/// <param name="unicode">if set to <see langword="true" /> string is UTF16; otherwise it uses ASCII.</param>
/// <param name="nullProbability">The probability of a null being returned (0.0 for no nulls).</param>
/// <returns></returns>
/// <remarks></remarks>
public static string RandomString(this Random random, int maxLength = -1, bool unicode = true, double nullProbability = 0.0)
{
  random = random ?? RandomGenerator;
  // Check for random nulls
  if ((nullProbability > 0.0) &&
  (random.NextDouble() < nullProbability))
  return null;

  // Get string length, if there's no maximum then use 8001 (as 8000 is max specific size in SQL Server).
  int length = (maxLength < 0 ? random.Next(10000) : maxLength)*(unicode ? 2 : 1);
  if (length < 1)
  return string.Empty;

  byte[] bytes = new byte[length];
  random.NextBytes(bytes);
  return unicode ? new UnicodeEncoding().GetString(bytes) : new ASCIIEncoding().GetString(bytes);
}

The nullProbability allows you to optionally (and randomly) return nulls, and Unicode is likewise optional.

Next time, we’ll start looking at some more random generators related to SQL, but before we finish, how about something a bit different? The next two extensions are to the IEnumerable<T> interface, which extends the built-in LINQ queries to include a random item selector –

/// <summary>
/// Returns a random element from an enumeration, that matches the predicate; otherwise returns the default value.
/// </summary>
/// <typeparam name="T">The element type.</typeparam>
/// <param name="enumeration">The enumeration.</param>
/// <param name="predicate">The optional predicate.</param>
/// <returns>A random element or default.</returns>
[CanBeNull]
public static T RandomOrDefault<T>([NotNull]this IEnumerable<T> enumeration, Func<T, bool> predicate = null)
{
  if (enumeration == null)
  throw new ArgumentNullException("enumeration", "The enumeration cannot be null.");

  // We may as well build a list, as we have to count elements anyway.
  List<T> filtered = predicate == null ? enumeration.ToList() : enumeration.Where(predicate).ToList();

  int count = filtered.Count;
  return count < 1 ? default(T) : filtered[RandomGenerator.Next(count)];
}

/// <summary>
/// Returns a random element from an enumeration, that matches the predicate; otherwise throws an exception if the predicate is not matched.
/// </summary>
/// <typeparam name="T">The element type.</typeparam>
/// <param name="enumeration">The enumeration.</param>
/// <param name="predicate">The optional predicate.</param>
/// <returns>A random element.</returns>
[CanBeNull]
public static T Random<T>([NotNull]this IEnumerable<T> enumeration, Func<T, bool> predicate = null)
{
  if (enumeration == null)
  throw new ArgumentNullException("enumeration", "The enumeration cannot be null.");

  // We may as well build a list, as we have to count elements anyway.
  List<T> filtered = predicate == null ? enumeration.ToList() : enumeration.Where(predicate).ToList();

  int count = filtered.Count;
  if (count < 1)
  throw new InvalidOperationException("The enumeration did not return any results.");
  return filtered[RandomGenerator.Next(count)];
}

If you want any clarification, or you have a better implementation be sure to leave a comment! Once I get through these tutorials I’ll be sure to post the completed source.

Related Images:

[See image gallery at thargy.com]

The .NET framework is littered with the following code (e.g. from the System.Guid class):

public static Guid ParseExact(String input, String format)
{
    if (input == null)
        throw new ArgumentNullException("input");

    if (format == null)
        throw new ArgumentNullException("format");

    if (format.Length != 1)
    {
        // all acceptable format strings are of length 1
        throw new FormatException(…);
    }
    …
}

A common scenario when creating a publicly accessible method is to validate the parameters being passed into the method and throw an exception when something is amiss.  I used this example as Guid.ParseExact was only added in .NET 4, showing that this is still the ‘Microsoft way’.

But when you do this all over the framework it impacts on performance.  The reality is that in the vast majority of cases this code should be called with a valid string representation of a Guid, at least with a non-null string (with length > 0), yet we have to do the checks every time the method is called.  Even if I can be certain the string represents a real Guid, there is no way for me to skip these checks.  You might say that’s not really a problem, but if I’m writing an ORM (for example) and I’m looking for raw object creation throughput, that overhead starts to become significant.

When ReSharper looked at this problem, they realised that it would be possible to indicate whether null values were expected or not using attributes.  For that reason they added a bunch of attributes that they use to inform their value analysis module, and then they went through the framework and effectively marked it all up.  If you’re using ReSharper (and if not, why not?) you can make use of this code analysis by modifying the above code:

public static Guid ParseExact(
    [NotNull]String input,
    [NotNull]String format)
{
    if (format.Length != 1)
    {
        // all acceptable format strings are of length 1
        throw new FormatException(…);
    }
    …
}

ReSharper will test any code that uses ParseExact and provide a helpful squiggle if it things you are passing in a null when you shouldn’t be.  To be fair the intent here is not to remove the checks themselves, but to make their value analysis not bug you with warnings when they’re unnecessary, but the temptation to remove the checks is powerful.  But this has two big problems.

1. What is the person using your library doesn’t have ReSharper?
2. What if the person using your library ignores the squiggle?

What ReSharper is doing is pretty smart, by analysing the code it can tell if it’s possible a null is sneaking through.  This isn’t done by running the code, but rather by analysing paths through the code.  This can be done at compile time – though it’s not always bomb proof.  When Microsoft Research approached this problem they came up with an even better solution – Code Contracts.

With Code Contracts enabled it is possible to rewrite the above like so :

public static Guid ParseExact(String input, String format)
{
    Contract.Requires(input != null);
    Contract.Requires(format != null);
    Contract.Requires(format.Length != 1);
    ...
}

Which looks eerily like Debug.Assert or Assert.IsTrue statements.  Unlike those two examples though the Contract namespace includes methods that effectively run at compile time to validate constraints.  These methods can also optionally run at runtime, which is useful when a constraint cannot be fully validated at compile time.  Using contracts allows us to move away from those chains of parameter validation code safely.  It even lets us provide information about the outputs of the method using the Contract.Ensures method.  This is a hugely powerful tool in the .NET developer’s arsenal.

But it still suffers from a similar problem to the ReSharper solution – what if the person using your library doesn’t use Code Contracts?  Also, unlike ReSharper, it also modifies the assembly at build time which can be buggy when using other tools, such as PostSharp.   The final nail in the coffin is that ReSharper just doesn’t support Code Contracts in any useful way, and so you’re left implementing both.  It’s for this reason I have repeatedly come back to Code Contracts over the last few years and debated whether to include it in projects.

However, the community does seem to be swinging towards it’s adoption and .NET 4.5 includes the System.Diagnostics.Contract namespace out of the box – but you currently still need to install the Code Contracts extension into VS11 beta if you want to configure it (note if you’re using VS11 that you currently also have to execute ‘devenv /setup’ to complete installation which is a bit of a mess).  If you’re targeting the new framework then there’s no reason to not include Code Contracts as you’re end users won’t have compilation problems – but you may want to encourage them to set up their projects to make use of the contracts you define.  Maybe the Visual Studio team will include the extension when VS11 goes RTM, but that’s not clear.

Until they do, sometimes my code will include examples whilst other times you’ll see the ReSharper attributes.  if you struggle compiling the code you can read the following article, or install the Nuget.  If you want to go old school just create fake attributes that match the signatures used.  If all else fails, you can safely delete the attributes.

Related Images:

[See image gallery at thargy.com]

CloudFlare has saved my neck, repeatedly.  As regular readers no I have been migrating my domains to a new host, for all the advantages of using a big name like GoDaddy.com, there are an equal number of disadvantages.  However, using CloudFlare has meant that I can use their nameservers, which has allowed me to work around most of the idiosyncrasies of my existing registrars, and my new registrar/host.

But even better is the amazing site acceleration that it provides – and that’s good as GoDaddy.com is noticeably slower than my previous host.  With it’s built in CDN, CloudFlare provides super fast content to my visitors, and best of all, it works hand in hand with the excellent W3 Total Cache plugin.

CloudFlare doesn’t stop there though, it has fantastic security features, and best of all, it has apps!  One of the ones I really like is PingDom which allows for real-time monitoring of a domain, and it even sends SMS/email if your site is down.

Because my DNS hosting and PingDom are independent of GoDaddy.com, my visitors, and I, can check the sites status automatically with stats.thargy.com (UPDATE: PingDom have removed public reports on free accounts), which should stay up even if everything else is dead.

That’s a good thing as I wait for the final transfer of my domains which can happen anytime in the next five days.

Related Images:

[See image gallery at thargy.com]

OK I’m not going to lie to you, there’s no way to sugar coat this…

I despise the Domain Registration system.

Can’t help myself. I’ve owned thargy.com and unclecraig.com for well over 10 years and every year I go through the same renewal hell of trying to figure out who owns what – requesting transfers and all the unnecessarily messy rubbish that the industry subjects it’s users to. It’s not that I’m a ‘search for the cheapest deal’ masochist, it’s purely that I have a great habit of backing losers when it comes to the great registrar consolidation world war that has raged continuously over the last decade. I have genuinely lost count of the times that one of my registrars or hosts has changed hands, such that my host, and domains all exist with different people. I genuinely hate Domain Registration.

Well enough is enough, I’ve finally decided to combine everything onto GoDaddy.com. I strongly suspect this is a decision I will live to regret (going on previous form) and certainly my initial experience has been somewhat typically hellish. After many hours of work, numerous support tickets raised, etc. (at one point I even got sent a completely blank EPP Key/Authorization Key in a friendly email) I have at least registered my transfer of thargy.com and have attempted to begin the process of transferring unclecraig.com (though success there remains firmly in the balance).

I am hoping to move this WordPress to GoDaddy, and transfer everything (including CloudFlare CDN support) over in the next week. I figure there’s no time like the present, after all my subscriber count is still very low.

With luck there will be no noticeable interruption, however if the inevitable happens and the site is down, please bare with me as I hope to get it back up and running as soon as possible!

I have some great blogs posts planned for when everything settles down so I hope your persevere.

Related Images:

Update: This post has now appeared in the Oldham Chronicle as can be seen on the Web Apps Website.

In Oldham we seem to find it easy to focus on the negatives, but having attended a number of events showcasing plans for regeneration, it’s difficult to feel anything but positive. Oldham is pushing forward, to show that it’s no longer a dusty old mill town but a place of real innovation and growth, bringing a brighter future to everyone in the borough.

This is exemplified by the recent opening of the Mahdlo Youth Zone which aims to raise the aspirations of Oldham’s young people. Outstanding educational institutions such as Oldham Sixth Form, Oldham College and University Campus Oldham are ensuring a skilled workforce for the future. These skilled young workers won’t need to go far for incredible career opportunities either.

‘Invest in Oldham’ is a pro-active movement by Oldham Council to attract business to the area. At the launch event at Gallery Oldham in March, potential financiers were shown reasons why they should view Oldham differently: including its great location, great people, great infrastructure and great businesses.

It was here that the Hotel Future project, a luxury hotel doubling as a full time vocational training centre was unveiled. The £40 million project is a world first and will create hundreds of new jobs and apprenticeships for the area. The expected location is next to the Queen Elizabeth Hall which will itself be renovated to create a new Civic Square rivalling Bolton’s Victoria Square and Manchester’s Albert Square.

Our Grade II listed Old Town Hall is currently part of restoration plans. In 2010, workmen began to repair the inhabitable building, creating a base for future developments. A range of options are now being considered, including a family facility similar to Manchester’s Printworks. It’s great to see the Council looking to regenerate rather than focusing on cutbacks.

By 2014 when these projects will be nearing completion, the new Metrolink will be in place; connecting Oldham to Central and Greater Manchester. Bringing great transport links to the town will encourage businesses to the area. The temporary line to Oldham Mumps is set to open very soon meaning Oldham’s infrastructure is steadily improving.

The next few years will be critical to restoring the prominence Oldham once held. These are exciting times for the entire borough and as Oldham president of the Greater Manchester Chamber of Commerce, I welcome the fundamental changes needed to see the town flourish.

With the Olympic torch arriving in the borough on Sunday 24^th June, let’s make sure the nation sees a positive Oldham focused on the future. We need to believe in our town, otherwise, who else will?

For more information about investment opportunities in Oldham see www.investinoldham.com .

Related Images:

[See image gallery at thargy.com]

Anyone who knows me will tell you how important I take any opportunity to talk to young people before they enter the workforce, so when the University of Manchester invited me to give a guest lecture to their Advanced Computer Science masters students I jumped at the chance.

So at 11AM on Wednesday the 18th of April 2012 I found myself stood in front of an audience of approximately 30 students. I won’t lie to you, I’d had a very busy week, but this one hour was priority number one for me. The biggest problem was how to condense everything I wanted to say into just an hour – a near impossible task – and so, unsurprisingly I resorted to my usual technique of just talking really quickly! The results are less than impressive, but I think there’s some pretty important insights buried in there. I do regret not having more preparation time to nail down the timings but I think the message still came across OK.

Thankfully I took Gordon Pearce and Natalie Bailey along and Gordon helpfully recorded the whole thing on his iPad so you can see it below.

You can also download the original PowerPoint presentation here.

During the lecture I covered off a number of topics, including the kind of job graduates should look for. I feel it’s important that a first job should be working with other developers where you can refine your skills and learn your craft.

I then went on to talk about how developing code works in businesses, particularly client driven ones. Briefly, I introduced the concepts of process, issue tracking and source control.

The lecture is aimed at people who are just starting out in a career in IT and helps focus on some of the practicality that are often missing from a graduate’s repertoire.

The video was edited down in Vegas Pro. I was asked at the end of the lecture how the presentation had been done (with all the animations). It’s no secret that it was done entirely in PowerPoint. For the video I reedited the aspect ratio from 4:3 to 16:9 to fit the widescreen and saved as WMV – unfortunately the maximum resolution is 1280×720 so I used Vegas Pro to upscale it to 1080p.

Related Images:

[See image gallery at thargy.com]

So statics are generally considered evil, the enemy of TDD and IOC, and at odds with the purity of OO design. Shame they’re so incredibly fast!

Whilst we’re talking about the TDD issue, I recommend you stop for a moment and go and take a look at the Fakes Framework added to VS11. Fakes is the successor, to Moles & Stubs, and it rather elegantly solves the statics testability problem, by introducing the concept of shims.

But statics do have their uses, especially when we’re talking about hyper critical performance situations. For example static member access is approx. 5-6% faster than instance members. But more importantly IOC or Dependency Injection itself are comparatively slow and frequently uses Reflection (often inappropriately). For some scenarios, like logging, statics are powerful tool – if used with eyes wide open. To be clear, you can say that about pretty much any programming paradigm.

Back to the purpose of this post though. After trying to clear up a bit of the mud slung at statics (and at the risk of starting a flame war anywhere). Let’s talk about the greater evil of statics with generics. These things are so evil that ReSharper (the tool you must install if you spend any time developing in .NET) gives you a nice little squiggle and warning –

Clearly we’re talking about a great evil here!

ReSharper is right to warn you about this as it’s a real issue for new developers to understand what’s going on. Going back to your old lectures – a “Class is a definition of an object, and object is an instantiation of a class”. In C# you cannot instantiate a generic class, actually more accurately you cannot instantiate an open generic class. Now when you Google this be sure to use “open generic type” as that’s what everyone uses although in C# only classes and interfaces can be generic (a type describes pretty much every language element, including enums, structs, value types, delegates, generic arguments, etc.), and only classes can be instantiated (interfaces are implemented).

So what is an open generic class? It is a class where any of the generic arguments are not yet specified. The generic argument in our example is ‘T’ (as in Bag;).

To instantiate a generic class, you must first close it, that is fully specify it’s generic arguments. In code this is normally done when you instantiate it, e.g. {csharp decode=”true”}Bag<T> intBag = new Bag<T>();{/csharp}.  As you can see the we specify that the type T should in fact be of type ‘int’ for the ‘intBag’ instance of our generic Bag class. So what’s the problem? Well in closing a generic class you create a new type ‘Bag’ which is the closed generic class made from the ‘Bag’ open generic class, it is a class in it’s own right, and critically, it has it’s own independent statics. To the unwary this can appear counter intuitive, as they might expect that the static is shared across all instances of ‘Bag’ or it’s descendants, however Bag doesn’t have either and ‘Bag’ is not strictly a descendent.

So are all statics in generic types evil? Well let’s expand out our view a little –

– for some reason ReSharper isn’t complaining about our new field ‘_thisIsOk’. The reason is simple, as the field itself is a generic and uses the generic argument of the encapsulating class it’s unlikely you are going to get confused over the field’s scope, unlike with ‘_bagCount’.

Should we just ban statics in generics and be done with it (easier said than done)? Well the answer to that is complex, but there are some really good examples of where it is very useful, some of which I’ll show you in future posts, the important thing is to remember that the static is only global to the closed generic type. In our example ‘_bagCount’ will only be global to ‘Bag’, a ‘Bag’ will have it’s own ‘_bagCount’ static. When you understand the limitation, you can also understand it’s usefulness.

Which brings us to the bit on which so many developers get stuck – how do I have a static shared across all types of my generic class? Well there are two ways really, the best way (if you ask me) is the base class model, for example –

public abstract class GenericBase
{
    protected static int _counter = 0;
}

public class Generic<T> : GenericBase
{
    public static int Counter { get { return _counter; } set { _counter = value; } }
}

This is the most elegant solution, but a base class is not always a viable option (you may need to descend from a different class already. In that case you can use a holder class like so –

internal static class GenericHolder
{
    public static int Counter = 0;
}

public class Generic<T>
{
    public static int Counter { get { return GenericHolder.Counter; } set { GenericHolder.Counter = value; } }
}

– which is far less elegant, although declaring the holder as internal at least means it’s not accessible outside the current assembly.

I plan on following up with far more in-depth examples, and apologise if this one is a little ‘basic’ but I wanted to get some groundwork done before I delve deeper into the .NET framework, and Reflection.

Related Images:

[See image gallery at thargy.com]

Hi everyone and welcome to the new thargy.com (and unclecraig.com).

My old website was left untouched for 7 years and times have changed – as have I. For a start I’m posting this on my iPhone, which wasn’t even around when I stopped editing this site in earnest (around 2004).

Most importantly I really want to start giving back to the community by open sourcing some of the exciting things we’ve been working on. And I have a head full of blogs I really need to write, so after much soul searching I’ve removed the old site (after backing it up first) and brought up this WordPress site. After all, I want to focus on blogging not building a website.

Well I’ll keep this short. I hope to convert my old newsletters into posts on hear, for nostalgia, and then maybe I’ll get round to that blog I’ve been meaning to write.

Thanks for visiting and leave a comment

Craig

Related Images:

[See image gallery at thargy.com]

If you are a regular reader of my articles you will be aware that social responsibility is a key area I focus on. This policy needs to be addressed in order for any business, no matter what size to develop in the way it wants to. Without policies in place how can you determine where your business is heading?

Groundwork, a charity who specialise in environmental regeneration, have been hosting a range of workshops and seminars in order to educate local businesses. Recently they held a seminar on the topic of Corporate Social Responsibility. Timely, as Apple have released sensitive information regarding their pollution and its origins. Although under pressure to do the right thing, Apple have said that they are working towards reducing their environmental impact – a response the public are eager to hear.

Never has it been more important to factor Corporate Social Responsibility procedures into your company to establish core beliefs. A company’s beliefs need to be defined early in order to engage people who share similar views. This will be the message you advocate, therefore it has to be part of the fabric of the business.

Engage with local people, especially young people to encourage them to promote and prolong your message; you are preparing the next generation of workers. If you have no message in place you are allowing other people to fundamentally run your company rather than leading it yourself.

Give back to the community. The local community is vital to your business even if it is not a stakeholder. The image of the area can have a direct impact on your company as it represents you. As a result, creating positivity is a crucial step for your business.

Work in partnership with other businesses. Together you can help others more effectively and in turn increase your workload when these efforts are reported. It’s not all about PR but in the ‘prove to me’ culture of our society you will need to recognise that what you do as a business is always being judged.

Considering Corporate Social Responsibility will enable you to make decisions regarding your company’s message. Primarily you will need to think about the differences you want to make, the differences you can make and the legacy you will leave.

Groundwork are continuing to hold various events to give support to local businesses. For more details contact Jean Maxwell on 0161 624 1444 or e-mail jean.maxwell@groundwork.org.uk

Related Images:

[See image gallery at thargy.com]

How do you measure success? In the business world there’s a misplaced obsession with two metrics – turnover and profit.  Running your business within these parameters would be like choosing your life partner based only on eye colour and height – I suppose it’s a start, but you would be missing out on so much else.

You will have heard of the adage “turnover is vanity, profit is sanity”.  I hate that phrase. Half of the message isn’t bad – turnover is indeed vanity; one guy in a bedroom reselling second hand planes can turnover £16m from one sale of an Airbus A340-500, which is no indicator of the profit he’ll make.  But profit is anything but sanity – a bit like oxygen, it satisfies our immediate survival, but in the long run we’ll need more if we want to prosper, such as food and water.

Alfred Korzybski argued that sanity was tied to the structural fit between our reactions to the world and what is actually happening in the world.  A sane business is not detached from its surroundings, it is embedded in them.  A sane business is concerned with its impact in its own industry, in its community, on its employees. It would be corporate insanity to run a business solely with the aim of making a profit. A perfect example of this can be seen in the recent financial crisis, when some banks became so obsessed with their profits that they failed to monitor the very foundations from which those profits had come.

There are great moral and philanthropic reasons for getting involved in your local community, sponsoring local causes and donating your resources for fundraising purposes. The success of your community reflects your success and vice versa – you need each other to survive.

However, there are also indisputable business incentives for getting involved in local ventures. Speaking from experience, businesses who get involved in projects that will benefit the community are rewarded with valuable knowledge of their locality, knowledge of their marketplace and access to an ancient but indispensable marketing tool: word of mouth.

There are other ways we can become involved in our local community. My personal passion is education – I believe the more opportunities we can offer local young people, the more we are able to offer Oldham’s future business community. If you agree with this sentiment, then have your say – there are many chances to sit on the boards of local educational institutions. If you are more concerned with Oldham’s current business climate, contact the Oldham branch of the Greater Manchester Chamber of Commerce, who can make a real difference to today’s business practices.

Success is not founded on what a business can take, but on what a business can give. “Turnover is vanity, impact is sanity – profit is the result”. It may not be as catchy, but it is a far more realistic measure of business success.

Related Images:

[See image gallery at thargy.com]

Legacy. At times it can be a boon, inspiring culture and rooting us with a strong identity forged in the fires of history. But it can also be a weighty anchor pulling us to the bottom. In business, there are no awards for being first out of the blocks; the gold medals are reserved for those first past the finish line.

This can be seen in the battle between Microsoft and Apple. Steve Jobs rebuilt Apple from a company facing imminent implosion into (for a brief period this summer) the most valuable company in the world (it’s currently second behind Exxon Mobil). Famously, he did so by simplifying and cutting features – Jobs was the first to drop the floppy disk drive, the removable battery and now the CD/DVD. The original iPhone lacked the majority of features (such as cut and paste) that competitors believed to be essential. This freedom from past conventions allowed Apple to flourish and grow.

While Apple steams ahead with innovative ideas, Microsoft continues to utilise its DOS features of the past, such as the command prompt, even though MS-DOS reached 30 years of age in July – practically an antique in IT terms. Last week, Microsoft demonstrated its planned changes to Windows Explorer for Windows 8, while Apple continued to question why we need a file explorer at all. Is Microsoft’s legacy also its limit?

We can liken this scenario to telecoms. It is effectively impossible to purchase an Internet connection without the obligatory landline, although landlines are used less and less, because the technology is becoming redundant. In developing countries, the development of cell phones has allowed users to gain ubiquitous connectivity in less than a decade, skipping an entire generation of infrastructure development.

With the tech world abuzz over India’s plans to spend tens of billions to expand its broadband network, there’s no doubt that the world is waking up to the power of connectivity to drive growth and development. In the UK, we have a huge network of dated copper and aluminium wiring that telcos (telecommunications companies) are still desperate to monetize. But our future legacy is not about metal and electricity, it’s about fibre and light. With current technology, fibre can already carry thousands of times more information than copper. The UK is already starting to lag behind our Western counterparts in fibre infrastructure, and there’s a lot of confusion amongst policy-makers, who are easily bamboozled by telcos with complex agendas.

Oldham’s council appear to have grasped the importance of being at the vanguard of fibre rollout and are campaigning to bring fibre down the tram lines to our borough. This is a laudable statement of intent and has huge potential to promote local growth. Of course, intent is only the first step on the road to delivery and there’s a lot of work to do still. While we may be out of the starting blocks, the finish line remains a long way off.

Related Images:

[See image gallery at thargy.com]

After more than two centuries it is probably a good time to ask, ‘Is the Chamber of Commerce still relevant?’ Businessmen in the last decade of the 18^th Century were hardly worried about developing an effective social media strategy, or obsessing how their website would look viewed on an iPad. How could a Chamber founded practically in the dark ages still have value to businesses today? By staying in touch with the ever changing and evolving issues of its members and the outer community.

When I joined the chamber a couple of years ago I expected to find a group of dotty old men in smoking jackets reminiscing about the good old days. What I found was a passionate cohort of motivated men and women who not only recognised the need for change, in themselves and in business, but also believed in their ability to instigate change.

That drive and focus has led to ‘Action for Business’ a distilled set of policy priorities broken down into six key areas, and a template for focusing the Chambers efforts to ensure a fairer deal for business and our economy. It is an impressive document and I highly recommend reading it (it can be found on the home page of the Chamber’s website at www.gmchamber.co.uk). But it isn’t just an exercise in generating paperwork; it genuinely infuses what the modern Chamber is about – Action. Action found in campaigning for change, better infrastructure and fairness; promoting positive policies, incentives and opportunities; and calling for new approaches, new attitudes and new R&D.

One policy the document highlights is the need to raise awareness of the impact late payments has on business. Debbie Abraham, our newest MP, recently launched her own campaign on this issue called ‘Be Fair Pay On Time’ in an attempt to highlight the injustice of late payments, you have possibly seen it recently highlighted in this newspaper. You can join Debbie’s campaign on Facebook, or via her website at www.debbieabrahams.org.uk.

Late payment is an abhorrent practice, and I would love to see the government adopt a policy of self-reporting – where companies report their own late payments in their published accounts, in the same way businesses self-report on tax liability. Such an approach would break the pattern of asking suppliers to police late payments, normally to the detriment of their own business as customers seek more pliant suppliers elsewhere. I welcome Debbie’s and the Chamber’s willingness to take a stance on the issue.

Ironically one of the earliest minutes, of the Commercial Society (the pre-cursor to the Chamber in Manchester) listed three key objectives the second of which was ‘…the regulation of trade, including the promotion of regular payments’.

Clearly the Chamber is just as relevant today.

Related Images:

[See image gallery at thargy.com]

Last night I found myself at the Bolton Lads & Girls Club. I had been invited for a tour of the facility by Claire Crossfield who is part of the team building a new youth zone facility in the heart of Oldham. The local young people have been very involved in this new centre’s progress and have named it Mahdlo (Oldham backwards). Mahdlo is based on the work pioneered by the Bolton Lads & Girls Club, and aims to create a central place where young people can meet and thrive.

Having just received another depressing report on my desk regarding the economic prospects for the borough, it might seem strange that I want to talk about Mahdlo, but I cannot think of anything more important. Mahdlo is a great example of what I wrote about in my last column – an opportunity for the Oldham business community to invest in the long term future economic prospects of the borough.

And I do mean opportunity. I am not blind to the difficulties faced by our businesses, indeed they can often be summed up in one word – ‘cash’; but not all investment is financial. Mahdlo presents a real opportunity for staff development as you encourage your staff to take part in volunteering as mentors and supporters of the many activities that are planned to be on offer. Mahdlo is currently planning on signing up volunteers to help with youth work, arts, sports and mentoring.

There is a real chance here for improving recruitment as you promote career choices through job clubs and offer apprenticeships and internships, as well as improving attainment through homework clubs and improved facilities for schools. Mahdlo also encourages staff retention as working parents can take advantage of the holiday clubs on offer which will look after children during school holidays – giving them structured activities in a safe environment for ridiculously low costs.

There is scope for town centre renovation as we engage young people more effectively and attract more people to the borough – some youths travel to Bolton regularly from as far afield as Liverpool to attend the club there.

As building moves on a pace, with the opening scheduled for the end of this year; this has to be one of the more attractive opportunities for local businesses to be getting involved in. I encourage you to get hold of Claire and start investing in your future.

Get in touch with Claire from On Side Northwest about available opportunities at: claire.crossfield@onsidenorthwest.org

Related Images:

[See image gallery at thargy.com]

Craig Dean is the new Oldham President of Greater Manchester Chamber of Commerce and Chief Executive of Web Applications UK.

The Oldham business community is a dynamic, thriving and overwhelmingly positive group of people which is unquestionably surprising to ‘outsiders’ considering the ceaseless tirade of negative punditry that surrounds the prospects for our economy and business in general.  As an Oldhamer, I am not surprised though. We are a well-watered bunch, which only serves to let us appreciate the few fantastically sunny days (like we have just experienced) all the more. 

Paul Roberts, my presidential predecessor, is the perfect embodiment of hard work and it is a little intimidating to be taking over as President in Oldham, but I am excited by what lies ahead. It is not just the anticipation of facing up to a challenging economy that I find exciting; it is that we have a plan.  Oldham as a council, and a community, is focused on the future in the truest sense – by being focused on education.  As a business community we are beginning to reap the benefits of this strategy already as we witness the next generation of employees and employers, graduates from our schools, our colleges and now our university.

Hard times see cuts, and there is a short-sighted temptation for businesses to ignore staff development as programmes such as ‘train to gain’ come under the axe.  We should not forget our heritage or underestimate the impact of under-investing in education on our future and our success. It was the business community that first founded the schools and fought to educate their staff and their children, and it is the business community that can inspire and lead the education revolution of the future.

As President, it is my desire to see businesses re-engage in education in a powerful and positive way, and there is no better time to start getting involved.  Our excellent new academies are literally open for business, and never before have we been given such an opportunity to shape and influence the education landscape.  Apprenticeships have a sharp new focus as we move them back to a place where they are considered a legitimate pathway to employment and adult education is providing legitimate benefits to employees and their employers alike.

A strategy that is founded on having the best and the brightest is a strategy that the business community can and should get fully behind. With such a clear strategy there is reason to be positive.

If there are any members from any sector within the Oldham borough who are finding that their business operations are being impacted by certain issues, or you are interested in joining Greater Manchester Chamber of Commerce, please contact Michelle Geoghegan, our Oldham Local Policy Manager, at michelle.geoghegan@gmchamber.co.uk.

www.gmchamber.co.uk www.webapplicationsuk.com

Related Images:

[See image gallery at thargy.com]

This article first appeared as a guest post in Travolution.

If you want to move forward, steer clear of protectionism and build a culture of knowledge-sharing, says Web Applications chief executive Craig Dean

Such has been the pace of technological advancement in our lifetime that the word innovation seems to have become synonymous with technology.

Sitting in my office in a converted mill in the heart of the industrial north, I find myself reflecting on innovation constantly. I am reminded that the origins of the word span back not just to the start of the internet age, or the age of the transistor, but way back, past the dawn of the industrial revolution and into the Middle Ages, at least.

When people talk about innovation they associate it with something new, and that is an easy mistake to make. The word itself descends from the Latin ‘innovare’, which is itself formed from ‘novus’ which gives us the word ‘new’. However, an accurate translation is ‘to renew or change’.

My dull fascination with etymology aside, I can’t think of a more vital point on which to focus – innovation is about change.

As a technology provider, it is easy to think that I would subscribe to the notion that the route to success is buying a new system. Don’t get me wrong; if you’re in the market I will happily sell you one! However, when I talk to new customers the first thing I say to them is that purchasing a system is actually the easy bit – changing their business is where the project will really succeed, or fail.

When I say changing their business, I am really starting to talk about the way their people not only work, but the way they think. Innovation is all about adaptability, and adaptability is all about the kind of people you employ. When we recruit, we do not test for what people already know, in our industry that would be a losing battle as what they know will be of little value in a couple more years.

Instead, we look for a desire to grow, to learn, and most importantly, to change. It’s a running joke in our office that you should look before you sit down in case someone has been moved into your seat; we never let people get too comfortable with the status quo.

In technology it is easy for people to develop a silo mentality, specialising to the point of protectionism. It is a natural temptation to jealously guard our hard-won solutions, to establish dominance in our chosen field.

That kind of protectionism is the enemy of change and is counterproductive not only for the business, but for the individual, who finds himself typecast and ultimately side-lined. Everyone knows a colleague who is the only one that knows how to do that critical process. Rooting them out is the first step to creating a positive culture for change.

Instead, it is important to create an environment of constant learning and constant teaching – or knowledge sharing. When people are placed in boxes they stop innovating, when they are set free to teach others they solidify their own understanding and develop a desire to learn more themselves.

So technology is not innovation, it is just a tool; used correctly it frees up people to work smarter, and allows them to change. Technology does not drive innovation, people do.

Related Images: