Scott Seely

I’m such a friggin idiot—Day of Mobile has that Jay Freeman!

Scott Seely — Sat, 27 Feb 2010 01:17:00 GMT

I’m hosting a conference in Chicago called Day of Mobile. At the end of the day, we are having a big time keynote from Jay Freeman. These days, he’s a rock star in the iPhone universe. For some reason, and I’m a complete moron for not realizing this until a few minutes ago, he is the same guy who brought the .NET world this little tool: Anakrino. If you are scratching your head and wondering why that would impress me, it’s because I’m getting older and I’ve used every .NET tool in the world. Anakrino was a mainstay at Microsoft to decompile .NET assemblies to read in C# and VB.NET. It was easier to use than grabbing the source code. Eventually, the tool found a home at RedGate and is now called .NET Reflector. [edit: Apparently, my memory is poor at times too. As a commenter so kindly pointed out, Lutz Roeder wrote Reflector, at one time a competitor of Anakrino.]

So, in the last few minutes, I’ve gone from realizing that we had a really awesome iPhone ninja speaking at the conference to realizing that we had one of those legendary brainiac developers at the conference. And, while I didn’t want to pimp the conference at devlicio.us, I now feel I should because he’s such a part of all of our everyday lives as .NET developers. I mean, the guy who single handedly wrote Anakrino/.NET Reflector. Holy friggin’ crap!

Visual Studio 2010 Beta-->RC install and ASP.NET

Scott Seely — Wed, 10 Feb 2010 14:31:00 GMT

I installed the VS 2010 RC last night, after uninstalling the VS 2010 Beta. If you see that ASP.NET isn’t coming up/working on your machine, you may need to remap the ASP.NET handlers into IIS. To do that, go to the Microsoft.NET 4.0 folder on your machine (typically C:\Windows\Microsoft.NET\Framework64\v4.0.30128 on a 64-bit Windows install, C:\Windows\Microsoft.NET\Framework\v4.0.30128 on a 32-bit install). Once in that folder, run the following:

aspnet_regiis.exe –i

After doing this, your ASP.NET applications should start running again. This is the same trick that worked on earlier versions of .NET, but it’s been a while since we had a .NET upgrade. I thought this might help out a few of you out there.

DataContract, Partial Types and Generated Code

Scott Seely — Tue, 09 Feb 2010 19:31:00 GMT

The other day, a friend had an issue with a DataContract. He had an Entity Model that used DataContract serialization. The code, stripped down to its essence, had something like this:

[DataContract]
public partial class SomeClass
{
    [DataMember]
    public int MyInt { get; set; }
}

And this was all well and good. When transmitting SomeClass over the wire, the fields on the entity model were transmitted. Now, my friend is really smart, and he knew that his version of serialization had implicit serialization. So, when adding new fields, he relied on implicit field serialization by augmenting SomeClass in a separate file as:

public partial class SomeClass
{
    public string MyString { get; set; }
}

Lo and behold, the field MyString didn’t appear on the wire. Why was this? This is because partial classes are a compiler trick that hides itself at the assembly level. The assembly indicated that SomeClass is a type that has the following C# implementation:

[DataContract]
public partial class SomeClass
{
    [DataMember]
    public int MyInt { get; set; }

    public string MyString { get; set; }
}

This shows that MyString is not part of the data contract, so the field doesn’t get serialized. At the assembly level, no one knows that you separated the implementation across two files.

So, next time you are wondering why part of your object isn’t being serialized, see if you made any declarations about serialization on the type. If you did, you have turned off the automatic “magic” parts of serialization. Sometimes, wizards will make those decisions for you. One way to recognize that the work was done for you: look to see if the generated type has [DataContract] on the partial class you are augmenting.

Incorporating Video into a Silverlight 4 Application

Scott Seely — Mon, 25 Jan 2010 12:00:00 GMT

Over the past week, I spent some time with Silverlight 4. I’m really impressed by how easy it is to incorporate video into an application. This post shows how to capture video from the camera and display the video on the screen. The post also handles grabbing single frames of video. You might use this type of arrangement to allow users to upload images, hold impromptu web casts, and to do video conferencing.

I’ve uploaded a barebones application that turns on video capture and displays the video (viewable here)

To understand how this works, you need to be familiar with the following objects:

CaptureSource

CaptureDeviceConfiguration

VideoBrush

The CaptureSource type encapsulates the methods needed to interact with audio and video devices.

CaptureDeviceConfiguration acts as gatekeeper to the webcam and microphone. CaptureDeviceConfiguration knows how to ask the user for permission to use the webcam or microphone. It also remembers what the user said about using the webcam or microphone during the current session.

VideoBrush knows how to paint using a video as the source.

In order to interact with the camera, you need to know whether the user gave you permission and if not, you have to ask for permission. Once you have permission, you just need to capture video from the default camera, create the brush, and start capturing the video.

private CaptureSource _captureSource = null;
private void btnStartCapture_Click(object sender, RoutedEventArgs e)
{
    if (_captureSource != null &&

        _captureSource.State == CaptureState.Started)
    {
        return;
    }
    if(!CaptureDeviceConfiguration.AllowedDeviceAccess)
    {
        if(!CaptureDeviceConfiguration.RequestDeviceAccess())
        {
            return;
        }
    }

    _captureSource = new CaptureSource
       {
         VideoCaptureDevice =

           CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice()
       };
    var brush = new VideoBrush();
    brush.SetSource(_captureSource);
    _captureSource.Start();
    rectVideo.Fill = brush;
}

Later on, when the user wants to capture the current video as an image, you just do something like this to put the current frame into an image control:

private void btnGrabImage_Click(object sender, RoutedEventArgs e)
{
    if(_captureSource == null || _captureSource.State != CaptureState.Started)
    {
        return;
    }
    _captureSource.AsyncCaptureImage(
        image => imgCapture.Source = image
        );
}

As someone who spent way too much time in the C++/MFC era writing code to capture video from devices, I am incredibly impressed with the brevity of the code. I think the SL4 team did an awesome job here. Way to go!

You can grab the sample project here.

The Sieve of Eratosthenes and F#

Scott Seely — Sat, 19 Dec 2009 03:42:00 GMT

There is a problem on the Euler project, www.projecteuler.net, which asks to find the sum of all values under a given number. Problems on the Euler project have a range of solutions, where at least one solution has a runtime of under 1 minute. A popular, time efficient algorithm that finds all primes in a given range is the Sieve of Eratosthenes. The basic algorithm is:

Create an array that contains all values from 2 up to the final maximum value
Starting at 2, For each value in the array, mark all items that have indices of the current value that are multiples and NOT equivalent to the current index as 0 (eg. index mod [current value] == 0).
March forward until you hit a non-zero value in the array, then mark all multiples as 0.
Halt condition: stop when you cross the midpoint of the array (anything remaining that is non-zero is a prime since you already all multiples of 2).

In practice, this gives successive iterations of an array from 2 .. 10 as:

[2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 0, 5, 0, 7, 0, 9, 0]
[2, 3, 0, 5, 0, 7, 0, 0, 0]
At this point, we reach 5, which is greater than the length of the array (9) divided by 2 (4.5). Any non-zero values in the array are prime.

In C#, one possible implementation is:

private static long SieveOfErastosthenes(long maxvalue)
{
    long[] values = new long[maxvalue];
    // Populate the list
    for (long i = 0; i < values.LongLength; ++i)
    {
        values[i] = i;
    }
    values[0] = 0;
    values[1] = 0;
    for (long i = 2; i < values.LongLength; ++i)
    {
        if (values[i] != 0)
        {
            for (long j = i * 2; j < values.LongLength; j += i)
            {
                values[j] = 0;
            }
        }
    }

    long retval = 0;
    foreach (long k in values)
    {
        retval += k;
    }
    return retval;
}

Overall computational complexity is O(n). If you aren’t familiar with big O notation, the overall complexity is bound by the size of the dataset times a constant—in this case 3, since we iterate through the complete dataset 3 times:

Populate the dataset
Mark all non primes as 0
Sum the primes

And yes, this works quite well, even for large values of n. My challenge was to get the sieve to work with performance equal to C#, only in F#. At the start of this, I had my first pass of the C# code running in ~600 ms for a value of 5 million. The challenge I set for myself was to achieve a similar timing in F#. The first few passes left me with runtimes of over 15 minutes (I killed the runs prior to completion). The reason why was simple: I wrote an O(n^3) algorithm. My challenge was to get this faster without using mutable values. My first pass looked like this:

let rec sieveofErastosthenes values filterout maxval =
    if (filterout >= (maxval/2)) then
        values
    else
        let shouldFilter =
            try
                let a = values |> List.find(fun x -> x = filterout)
                a <> 0
            with
            | _ as ex -> false
        if (shouldFilter) then
            sieveofErastosthenes (values 
                |> List.filter(fun x -> (x = filterout) || ((x % filterout) <> 0))) (filterout + 1) maxval
        else
            sieveofErastosthenes values (values |> List.find(fun x -> x > filterout)) maxval

let max = 5000000
let sumofprimes =  sieveofErastosthenes [2 .. max] 2 max |> List.map( fun x -> int64 x) |> List.sum

This code is correct—pass in 10 for the max and the value returned is 17. But the answer just never returned for larger values within reasonable time. Next, I tried using a mutable type: System.Collections.Generic.List<T>. This got the time down to a measureable 4s. That’s still 6.5x longer than the C# version. That next attempt looks like this:

let sieveOfEratosthenes x =
    let retval = new List<int32>()
    retval.AddRange([0 .. x])
    retval.Item(0) <- 0
    retval.Item(1) <- 0
    for i in 2 .. x do
        if retval.Item(i) <> 0 then
            for j in 2 * i .. i .. x do
                retval.Item(j) <- 0
    retval.ToArray()

let max = 5000000
let sumofprimes =  sieveOfEratosthenes max |> Seq.map( fun x -> int64 x) |> Seq.sum
printfn "%A\n" sumofprimes

Notice that this latest iteration executes a lot less code and, frankly, looks pretty close to the C# code. Through some investigation, I found that the call to preload the array consumed 2.6 s. I then switched to a sequence and shrank the execution time to 2300 ms. I was closing in on my goal and learning some stuff about the performance of various F# constructs. Loading using a sequence changed the AddRange call to this:

retval.AddRange([|0 .. x|])

The reason this takes less time is simple. When allocating a List, F# allocates and initializes all values up front. The Seq is created with an iterator and only allocates enough space to store the iterator and not much else. So far, so good. At this point, I did a search on F# implementations of the Sieve of Eratosthenes and found that Chris Smith had one. His implementation keeps track of which numbers AREN’T prime. Performance on his algorithm hits 8600 ms. That wound up being a step in the wrong direction.

Next, I tried, explicitly initializing the list of integers and cut the time down to 1450 ms. The strategy was getting me closer to optimal timing and showed that, for 5 million int32s, I was filling in the list in 46 ms.

let sieveOfEratosthenes x =
    let retval = new List<int32>(x + 1)
    for i in 0 .. x do retval.Add(i)

    retval.Item(0) <- 0
    retval.Item(1) <- 0
    for i in 2 .. x do
        if retval.Item(i) <> 0 then
            for j in 2 * i .. i .. x do
                retval.Item(j) <- 0
    retval |> Seq.filter(fun x -> x <> 0)

This was better, but I’d like to get closer to the C# version. The last thing I tried was moving to Array from System.Collections.Generic.List. This last change cut 250 ms, bringing my times down to 1200 ms. It looks like using lighter weight objects really will speed things up! That version is:

let sieveOfEratosthenes x =
    let retval = Array.zeroCreate(x + 1)
    for i in 0 .. x do retval.[i] <- i
    retval.[0] <- 0
    retval.[1] <- 0
    for i in 2 .. x do
        if (i % 2 <> 0) && retval.[i] <> 0 then
            for j in 2 * i .. i .. x do
                retval.[j] <- 0

    retval |> Seq.filter(fun x -> x <> 0)

let max = 5000000
let sumofprimes =  sieveOfEratosthenes max |> Seq.map( fun x -> int64 x) |> Seq.sum

Greatest Prime Factor in F#

Scott Seely — Thu, 17 Dec 2009 00:00:00 GMT

Today I was reading an article in The Onion, Conquerors You May Have Missed, and noticed that the number for the ant looked like it might be a big old prime, or at least have a large prime divisor. (For reference, the ant is # 43,168,974,563,247.) There are a number of algorithms for finding this answer, but my favorite is a little brute force algorithm that keeps dividing the big number by some other value until the two numbers are equal. Yes, I know I can short circuit a bunch of testing via a square root function, but BigInteger doesn’t have a sqrt function (yet…).

Anyhow, I cobbled this together and it worked right out of the gate:

let rec largestFactor x y = 
    if (x = y) then y
    else
        let z = x % y
        if z = 0I then largestFactor (x/y) y
        else largestFactor x (y + 1I)

let LargestPrime x = largestFactor x 2I

let a = LargestPrime 43168974563247I

printf "%A" a

Answer: 84,826,177

So, the number isn’t prime, but the largest prime factor is pretty big! And, writing up the code to figure out the answer itself was pretty simple.

Slides and Code from Chicago Alt.NET meeting

Scott Seely — Thu, 12 Nov 2009 15:00:00 GMT

I want to say thanks to everyone who came out to watch me speak about OpenSocial at the Chicago Alt.NET meeting. Thanks for inviting me to present and for making the time so enjoyable. I’ve posted the slides and the code for the Canvas page here.

Speaking at Chicago Alt.Net Meeting

Scott Seely — Tue, 10 Nov 2009 02:25:00 GMT

This month, I’ll be speaking at the Chicago Alt.Net user group meeting. Please check out the details here and register here. And, here is the blurb on the talk:

November 2009 Meeting

Building OpenSocial Applications

6:00 pm
Pizza and networking time

6:30 pm

From its official web site:

Friends are fun, but they're only on some websites. OpenSocial helps these sites share their social data with the web. Applications that use the OpenSocial APIs can be embedded within a social network itself, or access a site's social data from anywhere on the web.

OpenSocial is the platform that MySpace, Orkut, Ning, LinkedIn, Hi5, and pretty much every social network but Facebook supports for creating games and other applications that run on these social network sites.

In this talk, we focus on the MySpace platform and how one builds a MySpace application. This involves interacting with the OpenSocial JavaScript as well as receiving and sending OpenSocial requests on your own servers.

Iowa Code Camp November 2009 Slides Up

Scott Seely — Sun, 08 Nov 2009 00:39:00 GMT

I want to send out a big thank you to the team who put together the Iowa Code Camp. You people did an awesome job!!! I had a great time giving my talks and really enjoyed hanging out with the crowd in Iowa.

For those of you who attended my talks, or just want to see the materials, I’ve posted things.

WCF Diagnostics Talk and Materials

WinDBG Talk and Materials

See you next year…

Speaking at nPlus1 ArcSummit- Chicago

Scott Seely — Mon, 02 Nov 2009 13:18:00 GMT

On December 7, I’ll be speaking at the nPlus1 ArcSummit for the optional morning session. I’d love to see the place packed! Here are the details:

https://www.clicktoattend.com/invitation.aspx?code=142763

About nPlus1.org

nPlus1.org is a site dedicated to helping Architects, aspiring Architects and Lead Developers learn, connect and contribute. On this site you’ll have access to great first party content written by some of the most skilled and experienced Architects working today. You’ll also have access to, and be able to contribute to a nexus of content from around the Internet aimed at keeping Architects up to date on all the new developments in their fields of interest.

When

Monday December 7, 2009 – 10:00PM to 5:00PM

Where

Microsoft MTC - Aon Center

200 E. Randolph

Suite 200

Chicago, IL 60601

driving directions

Free Lunch Provided

Agenda

Morning Session (Optional): An Introduction to Object Oriented Programming

10:00 AM - 12:00 PM

Are you new to OOP? Do you want a refresher on the benefits of Interfaces and the differences between implements and extends? The morning session is a two hour introductory course of Object Oriented Programming. If you are new to OOP the lessons in this session will prepare you for the more advanced topics in the afternoon.

If you are already well versed in OOP then feel free to come have a refresher, or simply join us for lunch and the advanced sessions in the afternoon. The morning session is completely optional.

Afternoon sessions:

Session One: Software Patterns

Patterns are an important tool to use as architects and developers. They provide a common vocabulary for us to design with, as well as a common approach to a common problem. Come learn about useful patterns, and how to use them in your everyday code.

Session Two: How I Learned To Love Dependency Injection

Dependency Injection is one of those scary topics that most developers avoid. It sounds all ‘high-falootin’ and complex. It’s not. Really. We wouldn’t lie. It’s a great way to manage complexity in your system, and a great way to make your system so much more testable. And isn’t that what we all want?

Each session will be followed by open discussions periods.

A catered lunch will be provided starting at noon. This will divide the morning introductory sessions from the advanced sessions. Register once for all session and choose to attend the morning, the afternoon or both! Lunch is provided for attendees for any of the sessions.

Lambdas aren’t just for managed code

Scott Seely — Wed, 21 Oct 2009 23:50:29 GMT

A long time ago, I was a C++ developer. I actually thought of myself as a pretty darn good C++ developer and got way too excited when I finally got to meet folks like Scott Meyers and actually landed a job working with Bobby Schmidt—same team on MSDN. (If you know Bobby’s name, well, you were pretty deep into C++ circa 1999.) Then, like many C++ devs, I moved over to a garbage collected language. I’ve done more than my fair share of professional .NET and Java development. C++ has been left by the wayside. Today, I finally downloaded and installed Visual Studio 2010 Beta 2. I dug into the “What’s New” and, out of curiosity, decided to look at C++ first (I already know about many of the C# and VB changes). I saw two cool things:

C++ now has an auto keyword. For you C# devs, it is pretty much the same as the C# var keyword.
C++ has lambdas.

Now, I’m only a little ways into understanding C++ lambdas, so some of my information here may be suspect. The C++ lambda is just an anonymous function. You can pass variables into the function so that the variable is visible within the function. The syntax is:

[ list of variables from current scope to pass into lambda scope ] return-type( function signature ) { code }

The canonical example appears to be std::for_each from <algorithm>.

   #include "stdafx.h"      
#include <iostream>       
#include <algorithm>       
#include <vector>       
using namespace std; 
    int _tmain(int argc, _TCHAR* argv[])      
{       
    vector<int> myints;       
    for (auto i = 0; i < 10; ++i){       
        myints.push_back(i);       
    }       
    auto number = 0;       
    auto numSquared = 0;       
    for_each(myints.begin(), myints.end(), [&number, &numSquared](int n) {  
        cout << n << endl;       
        number += n;       
        numSquared += n * n;       
    });       
    cout << "The sum is " << number << endl;       
    cout << "The sum of the squares is " << numSquared << endl;       
    return 0;       
}

In this example, I have two values: number and numSquared. I make references of the value visible to the lambda, which prints out each value as it comes through and then sums the numbers and their squares. Once the function completes, the code emits the values to the console window. If you don’t want to pass anything to the lambda, you still need to state this. If I didn’t want number or numSquared visible, the lambda signature would be:

   [](int n){}

At some point, I’ll dig in and see what else this is good for, including how to build my own Functor signatures. Anyhow, just thought I’d share this little nugget with you.

New F#/WCF Article up at InformIT

Scott Seely — Wed, 30 Sep 2009 19:10:00 GMT

My article on programming REST services with F# and WCF went up at InformIT. Please go read it! http://www.informit.com/articles/article.aspx?p=1394625

Review of ANTS Memory Profiler

Scott Seely — Sun, 23 Aug 2009 16:05:00 GMT

Quick Summary: Highly recommended! This is a big time saver over WinDBG/SOS/CLRProfiler. Either combination will get the job done, but you will complete simple tasks in significantly less time if you choose ANTS Memory Profiler.

The review

Our sponsors over at Red Gate Software released a new version of their Memory Profiler and asked devlicio.us to give it a spin and write up a review. I had never used the tool before, but I have used the standard Microsoft tools to troubleshoot memory issues. My biggest concern with the Red Gate product is not whether it works but if it is worth the price in terms of time saved and productivity. With a list price of US$495 for the standalone product or US$795 for the .NET Bundle, it needs to save a lot of time to be worth the money. To get a feel for how it compares to the Microsoft solution, I decided to run Tess Ferrandez’s .NET Debugging labs 3 and 6 against the Red Gate Memory Profiler. In my evaluation, I’m mostly interested in seeing if I can get to all the data and find the planted bugs without spinning up WinDBG + the SOS CLR extension, AdPlus, and all those other tools.

Setup

My test system is a Dell Studio XPS M13 with 4GB RAM running Windows 7 Ultimate x64.

I installed the 14 day trial of the .NET Bundle. When you download, you will get an email from someone at Red Gate asking how they can help you with your evaluation and reminding you that there are demos and exercises to learn the tool at the bottom of the Memory Profiler home page. I then ran through the demos and labs to get familiar with how the Memory Profiler tool works.

To recreate the problem scenarios, I used Tinyget from the IIS 6.0 Resource Kit Tools.

For setup, I grabbed the BuggyBits.zip file and unzipped it into c:\inetput\wwwroot\BuggyBits. I then opened up Internet Information Services (IIS) Manager, navigated to and right-clicked on the BuggyBits folder, and selected Convert to Application.

Debugging .NET Debugging Demos Lab 3: Memory

This lab stresses a web site and causes a high memory situation. The lab has a simple goal: figure out what caused the issue memory leak. I setup the Memory Profiler to run the BuggyBits application. One thing I ran into was that the profiler won’t actually start profiling until you navigate to another page in the IIS application. For BuggyBits, this meant navigating to http://localhost/BuggyBits/Links.aspx in order to start profiling. I then followed these steps:

Take Memory Snapshot
From a command line, ran tinyget -srv:localhost -uri:/BuggyBits/Links.aspx -loop:400
Took another Memory Snapshot
Started my investigation

I did find that if I ran the application in a loop of 4000 items, Memory Profiler ran into memory issues during the investigation. That said, it was easy enough to do the troubleshooting with a smaller repro case.

The first screen I saw after taking the second snapshot is this:

From that, we can see that we have a lot of strings, but we also have two classes with very similar instance counts: StringBuilder and Link. StringBuilder is a .NET CLR type, but Link isn’t. From this same screen, we can also take a look at how many objects are on the Gen 0,1, and 2 heaps. Looking at the Gen 2 heap, we see a similar picture with 3505 Link objects on the heap. What is causing the number of Link objects to be so high? Looking at the source, we see a class with a finalizer declared—the finalizer does some heavy work (simulated via Thread.Sleep):

~Link()
{
    //some long running operation when cleaning up the data
    Thread.Sleep(5000);
}

At this point, we have a few things we can do to fix the code:

Eliminate the finalizer altogether.
Implement IDisposable and make sure to explicitly Dispose any Link objects after they are used.

I tried both options, and saw that we stopped leaking Link onto any of the heaps.

Discovery in this case was pretty simple as the first screen gave me enough data, via the increase in memory usage on the graph and the analysis to know what was going on as well as inform me if my changes helped.

Debugging .NET Debugging Demos Lab 6:_Memory Leak

Another memory leak situation. I followed a similar setup to the previous example. Steps to gather data are:

Navigate to http://localhost/BuggyBits/ProductInfo.aspx?ProductName=Bugspray
Take Memory Snapshot
From a command line, ran tinyget -srv:localhost -uri:/BuggyBits/ProductInfo.aspx?ProductName=Bugspray –threads:50 -loop:20
Took another Memory Snapshot
Started my investigation

This time, I was greeted by the following summary:

A large growth in strings still isn’t interesting. This grows due to assemblies being loaded in between calls and is hard to pin as an issue. Looking at “Largest Growth in Instances”, I see that RuntimeType has grown by quite a bit. Let’s see why. I clicked on RuntimeType and saw this screen, showing me how the size had changed:

I then selected the Class Reference Explorer and got a hint as to what is going on:

While it doesn’t consume much space, the big hint of System.Xml.Serialization.TypeDesc is enough of a hint that we might have a serialization issue. XmlSerialization generates new assemblies when certain constructors are run. One feature I particularly liked in this investigation was the ability to see what types of objects were holding onto the references of other types. Here is an example of the objects referring to our TypeDesc.

From here, I looked for uses of XmlSerializer and sure enough, found one of the versions that doesn’t cache the serializer. DataLayer.cs contains these lines:

  118         Type[] extraTypes = new Type[1];
  119         extraTypes[0] = typeof(ShippingInfo);
  120 
  121         MemoryStream ms = new MemoryStream();
  122         XmlSerializer xs = new XmlSerializer(typeof(Product), extraTypes);
  123         xs.Serialize(ms, p);

This is one of the constructors that creates a new assembly for every XmlSerializer instance. To fix the issue, one should cache the serializer. I did so by creating a static property on the DataLayer class:

    static XmlSerializer _xs = null;
    static object _xsLock = new object();
    static XmlSerializer Serializer
    {
        get
        {
            if (_xs == null)
            {
                lock (_xsLock)
                {
                    if (_xs == null)
                    {
                        Type[] extraTypes = new Type[1];
                        extraTypes[0] = typeof(ShippingInfo);
                        _xs = new XmlSerializer(typeof(Product), extraTypes);
                    }
                }
            }
            return _xs;
        }
    }

This sped up execution time and reduced the number of RuntimeType instances by 2,031.

Other Impressions

Given the speed with which I could diagnose the above two issues, I was really impressed. I also loved the ability to dig around and see what classes were in use and track through object graphs. To get the same job done with the Microsoft SDK tools I would have to correlate information from WinDBG + SOS and from CLRProfiler. The fact that I could do all this drill down in one tool gave me a huge productivity boost.

I did have some issues with using the profiler. I posted the issue to the Red Gate forum and had a resolution within a few days. It turned out due to the design of the Server Garbage Collector (the GC that runs on multi-core machines) has a behavior that may appear as memory corruption to a profiler. (You can read the forum thread here.) I had a few other interactions with Red Gate as well and found the company to be very responsive to my needs. Because of the way the tool presents information, I could see patterns quickly and fix the issues with ease. Thanks to the time saving properties, I heartily recommend buying at least one copy of the Memory Profiler for every dev team. This is something I will be using once per sprint to look for memory leaks.

Just one Solution for Daily WTF Praxis on 8-5-2009

Scott Seely — Wed, 05 Aug 2009 19:08:00 GMT

Over at The Daily WTF, they’ve started posting programming puzzles. The latest one is a puzzle where a set of locker doors are toggled, starting from the closed state, to the open state. Starting at a step size of 1 and stopping at a step size equal to the number of lockers, one toggles each door. At a step size of 1, all doors are opened, step size of 2, all the even doors are closed. At a step size of 3, door 3 is closed, door 6 opened, and so on.

Many of the solutions observe that only perfect squares remain opened when the algorithm is complete. That option is easy, but I wanted to do one that mimics the jocks effort of brute force solving the problem.

// Init the lockers to the initial state

// and mark all doors as closed (false)

let sw = System.Diagnostics.Stopwatch.StartNew()

let totalLockers = 100

let lockers =

[1..totalLockers]

|> Seq.map( fun e -> (e, false))

// Recursive function to set each door.

let rec openLockers l skip =

let listLength = Seq.length(l)

if (totalLockers < skip) then

// We've done our last toggle on the previous iteration.

else

// Do the toggling and try again.

let newList =

l |> Seq.map(

fun (e, f : System.Boolean) ->

let modValue = (e % skip)

match modValue with

| 0 -> (e, not(f))

| _ -> (e, f))

openLockers newList (skip + 1)

let remainingOpen =

(openLockers lockers 1) |>

Seq.filter(fun (e, f:System.Boolean) -> f) |>

Seq.map(fun (e, f:System.Boolean) -> e)

sw.Stop()

Seq.iter (printf "%d\n") remainingOpen

printf ("%s\n") (sw.Elapsed.ToString())

Thirsty Developer interview is up!

Scott Seely — Thu, 23 Jul 2009 15:23:00 GMT

At the end of June, Larry Clarkin met me at a Starbucks to do an interview. After a month of editting, the interview is ready for prime time. Please go to http://thirstydeveloper.com/2009/07/22/69WebServicesWithScottSeely.aspx and give it a listen!