Jason Crease

Scrum: Keeping Kosher doesn’t make you Jewish

2008-12-08T16:10:00Z

Our development team has started using Scrum. We’re only 4 weeks in, so it would be premature to make a judgement on whether it's working for us. I’ve investigated how it’s practised elsewhere, and there seems to be a worrying trend…

Let’s say I want to become a Christian. I could go to church on Sundays; receive communion; marry in a Church; sing hymns; celebrate Christmas. But none of these would make me a Christian. These are just extrinsic procedures – not core beliefs. To really be a Christian, you have to ‘live-for-God’; believe in the divinity of Christ; and so on. The point of Christianity is these core beliefs, not the extraneous rituals.

When it comes to Scrum, I always see teams faithfully having daily stand-up meetings, having retrospective meetings, calling someone a Scrummaster, etc. But they fail to implement the core principles of Scrum: ‘Done-is-done’, etc. It’s easy to practise the irrelevant rituals, yet these should not be confused with what Scrum is really about.

Many people tell me that no one implements Scrum properly – it’s a matter of compromise and seeing what works. I don't accept this. It’s remarkable how readily people compromise on the core-beliefs, yet retain all the extraneous procedures. They give up believing Jesus is the son of God, but keep Easter.

This is not to say there isn’t value in some of Scrum. Daily stand-up meetings are useful; but this hardly amounts to a vindication of Scrum. In the same way, some hymns are great (‘Autumn Days’ and ‘Shine Jesus Shine’ are two of my favourites) but this is not sufficient to justify becoming a Christian. If you like hymns but don’t believe in the divinity of Christ, then don’t become a Christian. Start a choir instead.

Nullable Structs - An interesting 'Gotcha'

2008-11-26T17:11:00Z

One of the interesting new features in C# 2.0 was nullable valuetypes. Using these, you can set valuetypes to a value, or null. Their usage is entirely straightforward. For instance, to use a nullable int simply declare a variable of type int?, and then set it to a value or null.

Behind the scenes, nullable valuetypes are implemented as generic structs of type Nullable<T>. When you write:

int? i = 2;

What you’re really writing is:

Nullable<int> i = new Nullable<int>(2);

When you assign a value to a pre-existing nullable int, like so:

i = 4;

you’re really writing:

i = new Nullable<int>(4);

And when you ‘get’ the value, like so:

int j = i;

What you’re really writing is:

int j = i.Value;

The Value is a get property, and assignment is by creating a new instance of Nullable<T>. This is similar to strings in C#: presenting a reference type by valuetype semantics.

This is all fine for primitives like int, double, etc. But when using structs, an interesting problem is created that lets light in on the ‘magic’ of nullable valuetypes.

Let’s say I have a struct Point, implemented as so:

struct Point

{

public int x, y;

public Point(int px, int py)

{

x = px; y = py;

}

public override string ToString()

{

return "(" + x + ", " + y + ")";

}

Then, I write a program that creates an int and a Point, and alter them slightly:

static void Main(string[] args)

{

int i = 3;

Console.WriteLine(++i); //increment then print it

Point p = new Point(2, 4);

p.x = 1; Console.WriteLine(p); //move left then print it

Console.ReadLine();

}

No problems here. The int and the Point will be altered as expected. Now I decide that I want my int and Point to be nullable. So I simply add two question marks, producing this program:

static void Main(string[] args)

{

int? i = 3;

Console.WriteLine(++i); //increment then print it

Point? p = new Point(2, 4);

p.x = 1; Console.WriteLine(p); //move left then print it

Console.ReadLine();

}

But this won’t compile. The int? part is fine, but for the Point? part I get the error: “'System.Nullable< Point>' does not contain a definition for 'x'”. No problem, I’ll just edit it like so:

static void Main(string[] args)

{

int? i = 3;

Console.WriteLine(++i); //increment then print it

Point? p = new Point(2, 4);

p. Value.x = 1; Console.WriteLine(p); //move left then print it

Console.ReadLine();

}

Now you get a different compile error: “Cannot modify the return value of 'System.Nullable<.Point>.Value' because it is not a variable”. This happens because Nullable<T>.Value has no set accessor method.

Nullable value types have this ‘limitation’ for a very good reason. The same thing happens is you try to edit a struct in a List<> of structs. Consider an over-simplification of Nullable<T> with a bodged-in set accessor, like so:

class MyNullable<T>

{

private T val;

public T Value

{

set {

val = value;

}

get {

return val;

}

If I create a MyNullable<Point> and use it:

MyNullable<Point> p = new MyNullable<Point>();

p.Value = new Point(2, 1);

p.Value.x = 2;

I get a compile error on the third line: “Cannot modify the return value of ‘MyNullable<Point>.Value' because it is not a variable”. This is because the statement p.Value.x = 2 is equivilent to:

Point otherPoint = p.Value; otherPoint.x = 2;

Which doesn’t change the underlying p.val, because otherPoint is a copy of p.Val. So when C# gives us a compile error, it is merely protecting us from editing an irrelevent copy of the underlying Point.

In conclusion, nullable valuetypes are immutable. I think the C# designers intended programmers to never modify the value of a struct once one is created, nullable or not.

Testing the speed of ANTS Profiler 4

2008-09-16T13:55:00Z

Profiling and debugging code inevitably adds overhead, and I know that it can be really frustrating. The overhead can either be small, e.g. the Visual Studio debugger, or massive, as with most performance profilers. A developer may invest in a performance profiler to optimize an algorithm that takes 10 minutes to run, and finds that when profiled it takes 2 hours to run. A top priority in the development of ANTS Profiler 4 was to make it faster than its predecessor and faster than any other profiler on the market.

We have found ANTS Profiler 4 to be about eight times faster than its predecessor, ANTS Profiler 3. It is also 4 to 20 times faster at line-level profiling than other profilers on the market.

I did a few speed tests and I have made a video to show how ANTS Profiler 4 compares to the fastest-known other profiler:

ANTS Profiler 4 vs fastest known competitor

Here it is compared to ANTS Profiler 3:

ANTS Profiler 4 vs ANTS Profiler 3

If you want to try out ANTS Profiler 4, you can download it from the RedGate website

A Quick .NET Puzzle

2008-07-17T17:17:00Z

Just a quick .NET puzzle. Does this application ever throw that ApplicationException? If so, why?

using System; using System.Threading; class Program { static long Num = 0; static void Main(string[] args) { Thread t1 = new Thread(ModifyNum); t1.Start(); while (true) { long k = Num; if (k != -1 && k != 0) throw new ApplicationException( "k is not -1 or 0. It is " + k.ToString()); } } static void ModifyNum() { while (true) { if (Num == -1) Num = 0; else Num = -1; } } }

Stuck? Then here's a hint: if you change Num from a long to an int, it never throws the exception.

ANTS Performance Profiler 4 = Sexy Software!?

2008-06-03T16:46:00Z

I sit next to this guy called Stephen Chambers. He is the Usability Engineer working on our next version of our code profiler, ANTS Performance Profiler 4. He is completely revising the UI of ANTS Profiler, and spends most of his time phoning developers asking what they would like to see in the next version, and then designing the new UI based on the feedback he gets.

Occasionally, you’ll hear some outbursts such as: “It’s getting hotter and hotter round heeere!” If you ask him what he’s on about, he’ll reply in an apologetic tone, “I can’t help it…. It really is very sexy!” That’s when I realise he’s talking about ANTS Performance Profiler 4 (APP 4) and the new design he’s working on. He’s contemplating the slick interface and clean lines of the profiler, summoning passers-by to come and check out “How god damn sexy it looks!”

So, the other day I asked for more detail. What exactly makes Stephen so animated?

1. One-click profiling

He loves the one-click profiling concept. He spent a lot of time working on the opening dialog. No 52-step wizards - just a single screen. The opening dialog is implemented to allow immediate profiling. That way, users will be more inclined to use the tool a lot more frequently, because it’s so quick and easy.

Figure 1: Opening Dialog of ANTS Performance Profiler 4

2. Much greater control for the user

The decision to remove the concept of ‘snapshots’ has produced an entirely new way of interacting with the profiler. Why confine the user to ‘snapshots’ when he could just choose any arbitrary period of time? Simply highlight any period of time (e.g. the creation of a Form), and see profiling results for that period.

Figure 2: Timeline feature in ANTS Performance Profiler 4

With snapshots, you must remember to switch back to the profiler to take a snapshot, reset results, etc. The need to switch from a task to the profiler has now been removed. The user can perform any number of actions they wish and retrospectively analyze the performance of each task in as much depth as they wish.

3. Responsiveness of the interface

Stephen has so far organised over 15 hours of testing sessions with users of the Early Access Program of APP 4. I asked him about their feedback. It seems that participants to the usability sessions have been stunned by the speed at which the results for a given region are processed and displayed. This can equally be done while the profiled application is running or after it has exited.

4. Clear and simple interface

Given the inherent complications of performance profiling, creating a front end that keeps things simple and immediate was a priority for Stephen. The UI went through several iterations and one of the main achievements of the APP 4 development team has been the reduction of options and windows on the main UI. Stephen seems to be getting a satisfying feeling watching a participant in a feedback session of APP 4 install it, set-up a project to be profiled and locate a performance bottleneck within minutes. The power of the profiler is as it should be – hidden under the surface with just the right number of options at the right time to give the user the power to examine the data in any way they feel like.

5. Not throwing the baby out with the bathwater

Talking to existing users of ANTS Profiler 3 revealed a huge amount about not only what features people would like to see in a new version but also what they really liked about the existing version. ANTS Profiler is well-known for its slick line-level timings feature, and some were concerned a new versions may present a ‘change for the worse’. APP 4 represents innovation in many areas, but preserves the features that people found genuinely useful in ANTS Profiler 3. We originally considered dropping the ‘All Methods Grid’, but this decision was quickly reversed upon talking to customers. Instead of a removal or total re-design, a number of subtle tweaks were made to simply freshen up its appearance and extend its usefulness. For example performance bars were added to heighten the visibility of poorly performing methods.

Figure 3: The fresher ‘All Methods’ grid in ANTS Performance Profiler 4

The code view has retained the iconic ANTS Profiler 3 red bars but we have tweaked its functionality by showing the currently selected method.

I find Stephen’s passion for his work impressive. He gets amazing satisfaction from watching users understand the features and options available, and listening to users saying “oh wow, that’s what I call a responsive profiler!” or “very clean interface!” Admittedly, a lot of work went into these things, so I guess, I can understand that…but I can’t help feeling a little uneasy when I see Stephen dancing on his chair, singing “ANTS Performance Profiler, Sexy Software…”!

Order of Construction

2008-06-02T15:05:00Z

For me, inheritance is often a headache. In particular, in what order is everything initialized? Consider this short C# program. It creates an instance of Dog, which derives from Animal. Both Dog and Animal have an instance constructor, a class initializer (aka a static constructor), an instance variable, and a static variable.

using System;



namespace CtorOrder

{

    class Animal

    {

        public int instanceAnimal = Program.Print("Animal.instanceAnimal");

        public static int staticAnimal = Program.Print("Animal.staticAnimal");

        public Animal()

        {

            Console.WriteLine("Animal constructor");

        }

        static Animal()

        {

            Console.WriteLine("Animal class constructor");

        }

    }

    class Dog : Animal

    {

        public int instanceDog = Program.Print("Dog.instanceDog");

        public static int staticDog = Program.Print("Dog.staticDog");

 

        public Dog()

        {

            Console.WriteLine("Dog constructor");

        }

        static Dog()

        {

            Console.WriteLine("Dog class constructor");

        }

    }

 

    class Program

    {

        public static int Print(string s)

        {

            Console.WriteLine(s);

            return 0;

        }

        static void Main(string[] args)

        {

            Dog d = new Dog();

            Console.WriteLine("\nPress enter to continue");

            Console.ReadLine();

        }

    }

}

There are eight activities here:

Dog instance constructor
Dog class constructor
Dog instance variable
Dog static variable
Animal instance constructor
Animal class constructor
Animal instance variable
Animal static variable

The question is: ‘In what order are the eight activities run?’ Try working it out. Anyway, the answer is:

Dog static variable
Dog class constructor
Dog instance variable
Animal static variable
Animal class constructor
Animal instance variable
Animal instance constructor
Dog instance constructor

There are two things I find surprising about this:

Why do static constructors run from most derived class to least derived class, i.e. Dog then Animal?
Why do instance variables get initialized before calling the parent’s instance constructor?

The answer to question 1 is that Dog’s class initializer has to be run since we are running Dog’s instance constructor, but execution of any type's class initializer method will not trigger automatic execution of any class initializer methods defined by its base type. Indeed, why should it?

The answer to question 2 is complicated. Constructing instance fields in the most derived class first is the only way to ensure that readonly fields are initialized and then not changed. Check out Eric Lippert’s blog for a decent explanation: http://blogs.msdn.com/ericlippert/archive/2008/02/15/why-do-initializers-run-in-the-opposite-order-as-constructors-part-one.aspx

Using the Exception Hunter Command Line to find All Methods that throw a given Exception

2008-01-31T12:01:00Z

Red-Gate's new .NET tool - Exception Hunter - shows you the exceptions that can be thrown by a .NET method. However, many users would like to see this the other way round, i.e. pick an exception and see which methods throw that exception. We will endeavour to put this in the next version of Exception Hunter.

However, for the moment this functionality is available via the Exception Hunter command line. I've recorded a 5-minute video where I demonstrate how to use the command-line to find all methods that throw IO exceptions in a simple application. Have a look...

http://www.simple-talk.com/blogbits/jason_crease/Exception_Hunter_Command_Line_demo_skin.swf

To download the 14-day free-trial of the .NET Developer Bundle, which includes Exception Hunter, go to:

Download .NET Developer Bundle