Andrew Stopford's Weblog

Wanted: a code discovery tool

andrewstopford — Thu, 24 Jul 2008 09:34:00 GMT

Picture this, large scale enterprise app, small scale legacy application, third party code...in other words a code base you are not fully familar with and need to understand. Sure enough can apply the feathers rules but if your in a hurrry to understand to understand a code base to start making changes (and a green field option is not an option) then what do you do? I'm on the look out for a tool that can allow you to explore a code base, explore object dependencies and pathways. Ideas welcome.

I never saw this coming...

andrewstopford — Thu, 17 Jul 2008 11:25:00 GMT

While eating my lunch I was running through google reader and started reading a post from Glen, this lead me in turn to Hammett (the guy that founded the Castle project) and this post literally blew me away.

Microsoft have been snapping some of the coolest, smartest dudes in the commnity lately, first Haack, then Rob, then Hansleman, now....Hammet. It is a very long time coming, Hammett is a seriously smart dude and fully deserves it. He will be joining them on the MEF team, as that is not directly related to Castle (although I am sure the IoC stuff make use of the MEF) he gets to keep working on the project, very cool.

I do wonder when Oren, Jeremy and Jeff (also super smart dudes) will be joining the mother ship, still waiting on my call Scott :D ;-)

Give credit where it is due

andrewstopford — Fri, 11 Jul 2008 06:48:00 GMT

Jeff's recent post I cannot repeat enough, with both MbUnit and Gallio we have made sure that we have credited folks where we have reimplemented their ideas and concepts. If they took the time to come up with the concept\idea then we feel it was only right to credit them for that concep\idea, while there may be little legal standing it is a polite and professional thing to do. During my time as V2 lead, Roy contacted me about a failure on our part to credit him for the Rollback attribute in the MbUnit code and we quickly corrected it. It was Roys concept and it was only fair to give notice of that. Me and Jeff have recently noticed several other OSS projects who have copied some of the concepts\ideas from MbUnit\Gallio and we ask that those concerned give us the same consideration.

Alan Turing

andrewstopford — Fri, 04 Jul 2008 23:56:00 GMT

Jeff Attwood has a post on possibily the greatest man in the computing age, Alan Turing. As Jeff states during WW2 Alan helped break the enigma code and went on to become one of the fore-fathers of AI. There are several books on Alans life that are well worth reading with the Andrew Hodges book one of the best.

Alan is one of my personal heros, some of Alans greatest work in computing occured here in Manchester, the place I was born and grew up in. After the war Alan conducted research into computing and maths at the University of Manchester. He worked on one of the first computers ever built the Manchester Mark 1 as well as conducting a great deal of his AI and machine learning research there. The memorial you see above was built in his honor and rightly so, with out him I cannot imagine what the world may have become.

MbUnit v3 in Visual Studio Team System 2008

andrewstopford — Thu, 03 Jul 2008 16:46:00 GMT

One of the changes made in MbUnit v3 alpha 3 was support for the Visual Studio Team System test runner. As Jeff points out, we are the first to offer this kind of support. At the moment the support is experimental but we will be driving foward more in the coming weeks and months.

You will need to install MbUnit v3 alpha 3, if your upgrading from v2 to v3 there will be some compatability issues (I'll cover these in a later post).

Take this simple test

Make sure you have MbUnit and Gallio referanced

Recompile and the test should now show in the Test View window

Just like a MSTest test you can now run through the test window.

MbUnit v3 beta 3 updates

andrewstopford — Thu, 03 Jul 2008 11:56:00 GMT

Jeff has news on a couple of updates to the MbUnit v3 beta 3 release including.

R# 4.0 final support
Factory attribute support
Repeat and ThreadedRepeat attributes support
CSV data source metadata
Pex support
Contract verifiers

The R# 4.0 support does mean that you can run MbUnit 3.0 and 2.0 in R# but if you prefer you can work directly with MbUnit v2.0 (rather than through Gallio) via Alberts plugin.

My thanks to Jeff and the whole team, who have worked hard to help make this happen (Jeff in particular works all hours to bring this to you).

32

andrewstopford — Sun, 29 Jun 2008 21:23:00 GMT

I post this every year, but I was a day late this year. I turned 32 yesterday, your only as old as you feel they say, I feel about 50 :)

MbUnit @ DDD7

andrewstopford — Sat, 07 Jun 2008 21:46:00 GMT

I've proposed a session for MbUnit at one of the UK's best free 1 day conferences, DDD7. DDD7 will be held later this year at Microsoft UK's hq down in Reading but is organised and talks given by non Microsoft staff. The session is based on the one I gave at AgileNorth last year however I'll also be covering Gallio and the changes to MbUnit in v3. The sessions are voted by attendees and the quality of speakers and speakers is very high, I'd love to take the talk down to Reading so when voting opens do spare me a thought :)

I'm also hoping to speak at AgileNorth again later this year.

ContextSwitchDeadLock erorr while debugging

andrewstopford — Mon, 19 May 2008 16:14:00 GMT

While debugging a managed code batch process today I ran into VS throwing a 'ContextSwitchDeadlock MDA' error. The debugger was attached to several long running process's and towards the end of the cycle VS was reporting this issue. As Mike Stall reports it seems to be caused by the thread running the managed code I am debugging timing out but the unmanaged thread seeing not seeing it as dead. Why the managed code I am running times out in the debugger thread I am not clear about. It seems like that the debugger has a fixed response to all break points that starts at execution time, as each step I am debugging goes off to the database, waits a while and then comes back, it eats into this time. Eventually the debugger thread times out and the ContextSwitchDeadlock error occurs. You can't stop this kind of error (although I do wonder if the time out value on the debugger thread could be adjusted) but you can disable the warning.

Two tips I extracted from this thread is

First you don't already have it (Debug - Exceptions) obtain the debug exceptions window (right click tool bar - customize - debug and drag exceptions into the debug menu).
Select from Debug - Exceptions - Managed Debugging Assistants and disable ContextSwitchDeadlock.

I had no luck with trying to disable this via reg keys and config files but that is suggested in the MDA help files.

Using Where and Group in Linq

andrewstopford — Fri, 16 May 2008 11:53:00 GMT

I tried lots of Google time to find the answer to this and failed (my google searching may also suck :) so in trying to tie a Where and GroupBy together in a Linq query I used the following.

var values = from p in tbl_data
             where
             p.some_other_value == 'hello world'
             select p;

var group_values = values.GroupBy(p => p.a_value).ToList();

I've seen lots of queries that place the groupby in the from and but never with a Where, there may be a nicer way of doing it but the above works for me :)

MbUnit v3 and optional TestFixture

andrewstopford — Fri, 16 May 2008 11:49:00 GMT

If you have not already done so, check out Jeff's post on changes to make TestFixture optional. As Jeff notes, Jim and Brad took this line in XUnit and after consultation it was decided for MbUnit to support this. Note, it's optional so your existing tests won't break but if refactoring it out makes sense then it is available for you to do so. If you do have any thought's and feelings on this do let us know.

MbUnit v3 alpha 3

andrewstopford — Wed, 14 May 2008 22:11:00 GMT

Jeff announced the release of Gallio alpha 3 yesterday, my time constriants at the moment meant I missed blogging Alpha 2 back in March but that release was a massive release in terms of features and the work that Jeff, Julian, Graham, Mark, Ben and the rest of the team have put in.

I have talked about Gallio before but as a re-cap, Gallio is described best on the website "The Gallio Automation Platform is an open, extensible, and neutral system for .NET that provides a common object model, runtime services and tools (such as test runners) that may be leveraged by any number of test frameworks", What does that mean, well unit test frameworks such as xUnit.net, NUnit, Pex and MSTest can plugin into the framework (and Gallio supports them all) or frameworks like MbUnit v3 use it directly. It's runners then use that framework and Gallio has the largest set of runners of any unit test framework to date.

GUI (Icarus)
Console (Echo)
TD.NET
R#
VSTS
CCNet
Powershell
MSBuild
NAnt

The runners them selfs are very rich, those who remember the ZaneBug framework will remember how rich it's GUI was and that is something we have aimed for in Icarus with great use of layouts and display information. So now you can take your framework of choice and reuse them across the Gallio platform.

Related directly to MbUnit is the change to the parameterized testing, this has had some heavy work done in make things a little simpler and far more flexible. With this kind of testing now added to Xunit.net, NUnit and csUnit there are lots of different ways you can go about it, the following is a reprint from Jeff's announcement.

A test can now be parameterized in any of the following ways:

Adding a method parameter to a test method.
Adding a generic method parameter to a test method.
Adding a constructor parameter to a test fixture.
Adding a field to a test fixture.
Adding a writable property to a test fixture.
Adding a generic type parameter to a test fixture.

Correspondingly data-source attributes can be specified on any of the following code elements:

Test methods.
Test method parameters.
Test method generic parameters.
Test fixture types.
Test fixture constructors.
Test fixture constructor parameters.
Test fixture fields.
Test fixture properties.
Test fixture generic parameters.

So there are many choices, but each choice is quite simple.

Here are a few interesting combinations.

A basic "Row"-test.

CHANGE !! - : The [RowTest] attribute is not needed anymore and has been eliminated.

[TestFixture]
public class Fixture
{
    [Test]
    [Row(3, 4, 5, true)]
    [Row(1, 2, 3, false)]
    public void Test(int a, int b, int c, bool expectedResult)
    {
        Assert.AreEqual(expectedResult, Math.IsPythagoreanTriple(a, b, c));
    }
}

CHANGE !! - A generic "Type"-test.

Note: The [TypeFixture] attribute is not needed anymore and has been eliminated.

[TestFixture]
[Row(typeof(List<int>))]
[Row(typeof(LinkedList<int>))]
public class Fixture<T> where T : IList<int>, new()
{
    [Test]
    public void Test()
    {
        T list = new T();
        list.Add(123);
        Assert.AreEqual(1, list.Count);
    }
}

CHANGE !! - A combinatorial test.

Note: The [CombinatorialTest] attribute is not needed anymore and has been eliminated.

[Test]
public void Test([Column(0, 1)] int a, [Column("a", "b")] string b, [Column(false, true)] bool c)
{
// Test something with the specified combination.
// Will be executed 8 times total.
}

CHANGE!! - A pairwise test.

Only tests all combinations of pairs of values. Can yield a significant reduction in test cases compared to ordinary combinatorial tests while still obtaining great coverage. See also: www.pairwise.org.

[Test, PairwiseJoin]
public void Test([Column(0, 1)] int a, [Column("a", "b")] string b, [Column(false, true)] bool c)
{
// Test something with the specified combination.
// Will be executed only 4 times instead of 8.
}

NEW ! - A CSV data source.

Just one of many external data sources to be implemented.

[Test]
[CsvData(ResourcePath="CsvDataTest.csv", HasHeader=true)]
public void ImplicitlyScopedResourceWithHeader(decimal price, string item)
{
Log.WriteLine("{0}: {1}", item, price);
}

The data itself should be stored in an embedded resource called "CsvDataTest.csv". We just create a file with that name in the same folder as the test class and then set its Build Action property to Embedded Resource in Visual Studio.

Item, Price
Apples, 1.00
Bananas, 1.50
Cookies, 2.00

Note the changes to TypeFixture and CombinatorialTest, also note Factory is not included, if you use this with combinatorial tests I'd like to hear from you. The Pairwise testing is something new to v3 and I'll cover in more detail in a future post. If you have further questions, things you want to see them also let me know.

Please also note that Jeff sat down with Scott Hansleman, Brad Wilson (XUnit.net), Charlie Poole (NUnit) and Roy Osherove to talk about the past and future of unit test frameworks in .NET at the recent ALT.NET event, Jeff does talk about Gallio and it is well worth a listen. I do hope that in the future the discussion thrown open wider to other folks that are central to the topic, such as Jim Newkirk, Peli de Halleux, Manfred Lange and others.

MVP & MVC simply put

andrewstopford — Tue, 13 May 2008 12:08:00 GMT

This question seems to get asked a lot, this recent article on codeproject does a decent job of explanation as well as this article from Infragistics Guidisan Todd Snyder.

If I was sum it up very simply, the different is entry point into the pattern.

In MVC the entry point is the controller, if you look at the Microsoft MVC framework for example the controller class is where you bind your view and everything else (model) together.

In MVP mean while the entry point is the view, webforms lends it's self very well to this pattern as you can bind the aspx and your view and use the normal aspx entry point to get at the rest of your patttern (in fact winforms works well on this pattern as well).

Going a bit further

You can break down your view into two, a view and View-extender. The temptation in webforms land in a passive sense of the pattern is hold all sorts of view centric items on the presenter. If you have lots going on in your presenter for your view and you want to keep your view ultra light and passive then use a view extender as a layer between the presenter and view, remember keep your concerns focused and light.

In Presenter-First (a variant of MVP) you can take your first MVP pattern and extend it's presenter to multiple views that also follow the MVP pattern. If there is a degree of data transform needed between the language of the view and the model then this pattern can be useful.

Crazy thought of the day

I wonder if the Microsoft MVC view engine (or MonoRails for that matter) could be readapted to act as entry point. More likely you could redefine aspx files as your own http handler, writing a class to act as the aspx which then appends the view and obtains actions from it.

The work\life balance and my absence of late.

andrewstopford — Thu, 24 Apr 2008 11:36:00 GMT

For the first time in 7 years of blogging I almost managed no blog posts in a month. I (for fun) graphed the last 12 months of blog posts and sure enough the amount of posts has seen a steady drop. I then graphed all the posts I have made on weblogs.asp.net and since peaking in 2004 I have been on a decline ever since. There are several reasons why, but my now near total flat line needs explanation.

With the work/life balance and my new family growing the balance tips in favour of more time with my family and less time at the computer. As such blogging\writing\opensource and generally all things out side of the day job has gone the way of the pear (i.e I have stopped). I've had a good run, of the 11 years I have been working in this industry all of them have seen me doing things out side of the day job, from blogging, article writing, book authoring and reviewing, to 4 years of user forum support (as a Macromedia Evangelist) and 3 years of open source\MbUnit. I've had time for all these things but things have changed and as much as I love geeking out I won't have Darcey growing up with her dad a stranger. More so, Emma has been for years a 'computer widow' while I was geeking it up, that has to stop.

I came close to closing this blog, I just don't have that much to say anymore. However, Emma convinced me other wise and I'll aim for a couple of posts a month however I may manage none at all.

The design in TDD

andrewstopford — Mon, 10 Mar 2008 22:13:00 GMT

Lately I've been drafting posts on my daily commute and post them up in batches (just in case you were wondering :).

I recall an article (not sure where I read it) about Ron Jeffries and his ability as an 'alpha architect'. Such people are rare, the design they have mostly in their mind with TDD providing a way of slightly reshaping the design and proving the model (in a pair session that can mean validating each other’s ideas). Another kind of folks is the folks that have a general system picture but design a piece at a time with model shaping and validation occurring as they go. Both are no less a way of designing and developing a system but while the 'alpha architect' has considered overall, system considerations and won't introduce design faults, the other folks need to go carefully to avoid those faults.

The point that TDD is a design process seems to get missed, writing tests before your code is only part of the process and not the sum total. The trouble I have found is that the design process tends to be an organic one, a rhythm that you adopt and you’re not aware of what process you’re following. So in this post I am going to attempt to lay out some of those considerations, not sure I will capture them all and you may have your own, leave us a comment with yours.

SOC

A car is not made from one part but many, with each part such as the engine or wheels made up from other parts. Does the engine depend on the door handle or the windscreen wiper blades? No. Each part, object or concern is separated from the rest but is associated in such a way that you can still achieve your aim without any dependencies on each concern. Relating that back to code, if a car class had an internal Ferrari engine object could we create a Porsche car from that car class? If the car class held a reference to an engine object that the Ferrari object was sub class off could we instead create a Porsche sub class and our Porsche car have the right engine? The practice of SOC is really a good OO practice in that you ensure your classes are so tightly bound to other concerns that you losing all the polymorphic benefits.

TDD helps us here in that we look at all of the concerns of the class and how that class behaves in isolation and with associated concerns integrating with the class. If in writing and then developing the test it fails randomly, your setup and surround is heavy or you are forcing the test into a deep integration test then chances are the class and its concerns are bound up too tight and it's a candidate for further refactoring.

Integration and Isolation

Take your class in isolation, can you isolate it? If you can what are its dependencies, if you’re testing it what kind of dependencies do you need and how deep are they. The more complex it is to take a class in isolation then your likely looking at a smell and some further refactoring is required. TDD forces you into putting a class into isolation and not being 5 levels deep in a system. You’re focused on that class alone and once taken out of context you can really learn if it will hold up.

Jeremy’s most recent post talked about using static and integration styles in your tests, it's a great post and well worth taking your time over. One thing that is worth mentioning about integration is that integration means as light as you can make it. If your using a lot of other actual concrete concerns to achieve isolation then it's a smell, the cohesion between your class and its concerns is too tightly bound. If you can use mocks or doubles in place of the concerns and your class knows no difference, working as it would normally then you’re in a happy place. Sometimes you can't avoid using an actual and sometimes it makes sense but too many and too often would be a smell, finding a balance is half the skill.

Things around

Consider the concerns around the class, what does the class need as inputs, what does it need for its processing and for its outputs. Those considerations would help you decide what you want to mock, double or actual. For example a class adds an entry to a database as a net product, a test (or for that matter another concern making use of the class) does not care how this product occurs; only that it has occurred. It would be a good mock candidate as we are not reusing the db entry further down the test process and as such we only care the method has occurred. If you wanted to emulate some kind of processing or validation, for example loading a collection of data, then a double could be useful. Following the same contract as the actual, the double would be a light weight emulation that the test could use.

Cross Cuts

Cross cutting concerns are (but not limited to) things like logging, security and validation etc. Things that may not be central to the core parts of the class like processing or logic but needed in the general scheme of the operation of the class. If you find your concerns reusing other concerns more and more often than these could be a cross cuts. To aid re-use and isolation you will want to ensure the cross cuts don't affect the SUT when under test. There are several tools are you disposal (such as DI, IoC and AOP) to service the cross cuts.