Head.SmackOnTable();

Once you get your head around the DeepLoading and Inclusive/Exclusive Lists in NetTiers, its not too hard, but it isnt straightforward to start off with. Take this VERY simplified class, as an example:

class Product
{
public TList<Product> ChildrenProducts {get;set;}
public Product ParentProduct {get;set;}
}

If you want to deepload the ChildrenProducts collection, you think youd run the following:

DataRepository.ProductProvider.DeepLoad(product,true,DeepLoadType.IncludeChildren, new []{typeof(Product)});

But that will load the ParentProduct product, and not your ChildrenProducts collection, even though its just a list of Product.

What you want to do is:

DataRepository.ProductProvider.DeepLoad(product,true,DeepLoadType.IncludeChildren, new []{typeof(TList<Product>)});

Im guessing because the .net 4.0 framework is still in the beta stages, that’s why NAnt (and TeamCity) arnt supporting it, but from what I can tell, mstcthe method to build it hasnt changed since .net 2.0′s msbuild way of compiling a solution.  Basically, all you need to do is call msbuild from the command line, give it the path of the solution, and off it goes to build it. You can specify additional information such as the build target etc, but its not essential.

Whereas normally, within NAnt, you would run the following:

<solution configuration="release" solutionfile="test.sln" />

This aparently dosent work with the .net 4.0 framework, it seems to not detect it. From what I can tell, the quickest way around this is to do the following:

<exec program="c:\Windows\Microsoft.NET\Framework64\v4.0.21006\MSBuild.exe" basedir="C:\SVN\CycleMania\"  verbose="true" >
 <arg value="C:\SVN\CycleMania\CycleMania.sln" />
 </exec>

Obviously, change the path in the program attribute to suit where Windows is located, and change the Framework64 to simply Framework if you are not running on a 64bit platform. One quirk that I fonud is that you have to have the BaseDir as where the solution is based, otherwise it throws errors about it cannot build properly.

And that should be it! If you are still struggling to compile on the .net 4.0 framework from within Nant, give me a shout.

Its now public knowledge that I have been working on getting a decent CI integration for the CycleMania project working on a publicly accessable server.

For the record, we are using the following tech for the CI integration. Yes, I WILL write a very detailed how-to on how I set things up, but as I am on my lunchbreak here at work, heres a very quick overview of what we are using:

• TeamCity 5.0 Professional, a free download from JetBrains (Limit of 20 Projects and 20 Users)
• .Net framework 4.0 Beta 2 (obviously)
• Nant 0.85, not as a proper build script, but purely as a glorified as a batch script
• APPCMD command to control IIS7′s App recycling (From inside Nant)
• .Net 4.0′s MSBuild

All this running ontop of Windows 2008 R2 Web Edition, and SQL Server 2008 Express.

Things I have learned is:

• TeamCity 5.0 isnt geared up for .net 4.0 YET, which is fair enough, they said support will be included in 5.1
• TeamCity also seems to be simply geared for building projects and running unit tests, less so for copying files over to another directory with specific paths etc.
• Nant’s contrib project is crap. Fair enough last time it was updated was 3 years ago, but it dosent work.
• You cannot simply recycle an app pool to kill a user instance of SQL Server 2008, to update the .mdf file.
• You really shouldnt run a site from the same directory as SVN, if you plan to update it (re above)
• Nant is all good and well, but also dosent support .net 4.0.

I promise I will expand on most of these points when I have time!

After writing some comparison code, we have the following output, thanks to log4net (I love log4net):

Comparison
S[X: 79, Y: 156, Width: 17, Height: 23] matched to T[X: 73, Y: 149, Width: 17, Height: 23]
S[X: 158, Y: 249, Width: 32, Height: 31] matched to T[X: 152, Y: 242, Width: 32, Height: 32]
S[X: 398, Y: 339, Width: 18, Height: 26] matched to T[X: 392, Y: 334, Width: 16, Height: 24]
S[X: 38, Y: 374, Width: 16, Height: 15] matched to T[X: 31, Y: 366, Width: 17, Height: 16]
S[X: 154, Y: 430, Width: 27, Height: 24] matched to T[X: 392, Y: 334, Width: 16, Height: 24]
S[X: 126, Y: 457, Width: 29, Height: 46] matched to T[X: 31, Y: 366, Width: 17, Height: 16]
S[X: 256, Y: 601, Width: 17, Height: 18] matched to T[X: 31, Y: 366, Width: 17, Height: 16]
Non matched
S[X: 34, Y: 388, Width: 16, Height: 17]
S[X: 154, Y: 430, Width: 27, Height: 24]
S[X: 465, Y: 442, Width: 25, Height: 22]
S[X: 126, Y: 457, Width: 29, Height: 46]
S[X: 227, Y: 472, Width: 17, Height: 19]
S[X: 256, Y: 601, Width: 17, Height: 18]
T[X: 148, Y: 423, Width: 27, Height: 24]
T[X: 459, Y: 435, Width: 24, Height: 22]
T[X: 119, Y: 450, Width: 30, Height: 46]
T[X: 221, Y: 465, Width: 17, Height: 19]
T[X: 250, Y: 594, Width: 17, Height: 18]

I know its not perfect, I know its only matching about 50% of the blobs, but im working on it. I have a plan up my sleeve for this

There seems to be a new phenomenon in the c#.net 3.5 world, where people are using the “var” keyword, because, well I’m guessing they are lazy. Take this example, what is MORE READABLE:

OR

Now, I know that will be straight forward, you can see what the new type is, it will be a ComparisonRectangleContainer, but what happens when you use var when getting a response from a method, like the following:

Now, what does FirstPass return? Is it an IList<String>? No, I have to mouseover to find out:

Ok, so it turns out it returns an ImageParallelCombiner, the first bit of code does not make it clear.

You should always write code for HUMANS, not the compiler

The following is PERFECTLY valid c#.net code, but is it good code?

Note – you can prefix variable names with @ if you want to use a keyword – i.e. @class is a valid variable name, so is _ (underscore) – perfect if you want to make things as hard as possible for people to read it, like the “var” keyword.

Warning – this post will be heavy on images, so if you are on a low bandwidth connection, well sucks to be you then.

With a few minor improvements to the code, here we have the Source image:

Here is the target image’s blobs:

As you can see, it has found both blobs, and here is the raw output for the blob data:

They are very similar, only a few pixels out! Now to compare the images somehow…

Two code snippets for you:

Does exactly what it says on the tin!

Every now and then, I get a crazy idea, to try something rather hard in .net – maybe hard isnt the right word for it, but something that hasn’t really been attempted before, or if it has, nothing public about it. So the idea I have is for some form of image detection, to say that Image X is x % similar to Image Y. I prefer to use the terms Source and Target, but it doesn’t really matter.

The source and the target images are here. That’s a photo I took a few weeks ago, if you do decide to steal it, please put a message on there that points back to me Anyway, the target image is 14×15 pixels smaller – that’s a whopping 210 pixels different! It shouldn’t be too hard to match up the two images, or should it?

Histograms

My first attempt was with Histograms. I grabbed some open source (unsafe!) code that generates an array of int[] and lists the histogram values, so I shoved both images through that, and got it to output the Source’s histogram value, the Target’s histogram value, the difference between them both, and the percentage of how similar it is, like so: (The first number is the key# of the int in the array, just because)

Right at the bottom, I had an average of all the percentages, to see how “similar” the image is. I was expecting the percentage to be fairly high, since there is only a few hundred pixels difference, and I didn’t change any of the levels or colours when I cut the images out of each other, but it told me there was a 87.7% similarity! That was very shockingly low. If you see something wrong with my maths from the code below, please let me know:

Image Processing

My next port of call was basically image processing, like what I did with my ANPR project that I created – basically filtering stuff out and building a “thumbprint” of the image, that hopefully will withstand being resized and stuff like that. Using image filters, flattening images and looking for large “blobs” of images, sofar I have come up with this:

That is the current “thumbprint” for the red channel, on the source image.

Pex generates Unit Tests from Parameterized Unit Tests through Automated White box Testing based on Input Generation

Ill be the first to admit, I have never been a big fan of unit testing. To me, it seems like a big waste of time. I’m not sure why, but I just don’t like it – I suppose it has something to-do with spending time writing tests instead of actually doing proper, paid work. Yes, yes, I know that tests “prove” that your code works, as long as you have coded your tests right. But what if you haven’t?

Anyway, I thought id give Pex a test since it generates unit tests for me. I love things that generate things for me, because I like to do things as quickly as possible, and the computer is millions of times faster than me at generating stuff.

For starters – head over to the Pex website, and download it – I downloaded the academic version, since im running VS.NET 2008 pro. Installing it after downloading it also might help matters.

Once you have installed it, you should be able to just open up a project and when right clicking inside a .cs file, you should see a few menu items:

Once you click on that little baby, Pex should start whizzing into action. Be warned, Pex will only test Public classes and methods – it dosent like testing anything else that isnt public, and I believe it will give you a warning.

In VS.NET’s status bar, you will get a bunch of messages, along the lines of “Pex: listening to monitored process (cold start)” and then “Pex: Finished”. It should also pop up a window, something vaguely like the following:

I know this looks confusing at first, but it really isn’t. Its quite simple really. You have various options, but what’s interesting (I think) is the grid view in the middle. The first icon says if the test passed or failed – green = pass, red = ? (Take a guess, gwan, take a guess!) The number denotes the number of the test (its incremental), and the name is the value it has tried If the test fails and throws an exception, that will be listed under the Summary and Error message bits.

If you click on the test, you can see the following to the side :

The details is the actual code for the unit test that it has executed. I know, it says “this.” instead of the class name, and that’s because Pex creates a copy of the code to run tests on, in a partial class. Under the stack trace subtab, it well, gives you the stack trace (Please tell me you knew what that would do. Please.)

This is where Pex becomes rather … brilliant – it allows you to save all of these generated tests into its own project, simply by selecting the tests you want to save, and hitting the fancy “Save Test…” button – it will go off, and generate its own project (It will ask you for the name of the project, where it should live etc, I will provide a screenshot later) – and it will save the tests to that project! Tests that you can run later, and you don’t have to use vs.net’s test suite – you can decide to plug in different testing libraries such as MBUnit (my current fav) by downloading extensions that are available on CodePlex, or I believe you can create your own.

More on Pex later!

Well the good news is I have submitted my patch to include the OnItemCommand for the TableRepeater in Nettiers 2.3 – You can either download the file from this link, or directly from here (it lives in WebLibrary\UI)