I’ve had numerous requests to publish my podcast list, so here it is.  Here is what I listen to on my commute to and from client sites or, in the case of this month, to and from a buddy’s wedding several states away.

http://polymorphicpodcast.com/podcast/feed/
http://channel9.msdn.com/rss.aspx?ForumID=34&Mode=0&sortby=0&sortorder=1&format=mp3
http://www.hanselminutes.com/hanselminutes_MP3Direct.xml
http://www.dotnetrocks.com/DotNetRocks_FullMP3.xml
http://www.slashdotreview.com/wp-rss2.php
http://www.se-radio.net/rss
http://feeds.feedburner.com/javaposse
http://feeds.feedburner.com/DrNeilsNotes
http://agiletoolkit.libsyn.com/rss
http://syndication.sdmediagroup.com/feeds/public/cmp_podcast_udi.xml
http://feeds.gigavox.com/gigavox/channel/itconversations
http://www.trinitydigitalmedia.com/tnb.xml
http://www.oneminutetip.com/feed.xml
http://www.runasradio.com/runasradio_FullMp3.xml
http://feeds.feedburner.com/NetObjectivesPodcast_LAST

In case you’d rather import the OPML, here it is in its entirety:

I found out today that my wife is with child, and we're having a baby!  Now, on with the post. . .

Integration testing isn't your basic 200-level topic at an MSDN event.  It can be very involved.  I believe that a good integration test has to depend on targeted unit tests being present.  Consider the scenario without unit tests:

Bob has a use case that spans 15 classes.  He sets up the environment to get this slice of the system under test.  He then proceeds to write the test with asserts.  He quickly becomes frustrated because for each of the 15 classes along the way, there are different scenarios that are possible.  If each class has just 2 possible uses, his number of scenarios to test are 2^15.  Each scenario requires many assert statements.  Faced with 32,768 test combinations, Bob is disgruntled and concludes that automated integration testing is too much overhead.

What did Bob do wrong?  First, Bob attempted to start his automated testing at the integration level.  Second, he assumed unit test responsibilities inside the integration test.  Third, he tried to test every possible combination of integration.  Fourth, he hadn't surrounded himself with a quality team that could help guide the testing strategy.

Here's the success scenario:
Bob has written unit tests for each of his 15 classes.  He marvels at how simple they looks since each unit test only has to cover 2 usage scenarios for each class.  With confidence that each individual class will do its job correctly, Bob writes an integration test for the use case choosing one of the many combinations that could occur.  Bob sets up the test, executes it, and then asserts on the resulting state of the system.  Bob finds an integration issues caused by how two of the classes interact with each other.  He fixes that bug, and the test passes.  Bob now has confidence that the 15 classes are interacting properly in his use case.

If you haven't already read the following from my friend, Jeremy Miller, take a minute to do so:

Qualities of a Good Unit Test: http://jeremydmiller.blogspot.com/2005/05/qualities-of-good-unit-test.html
Achieve Better Results by following Jeremy's Third Law of TDD: Test Small Before Testing Big: http://codebetter.com/blogs/jeremy.miller/archive/2006/05/30/145752.aspx

I've labeled this as a level 100 topic because I feel that every .Net developer
should know the basics of sorting.  With the base class library that we have to
work with, we don't have to worry about sorting algorithms or speeding up our
sorts.  Folks smarter than I have implemented the fast sorting that we have in
.Net.

Here, I'll cover the basics of how
to sort your own domain object as well as how to sort any other object (even
ones you didn't create).

Let's consider
the following domain object, Person:

In our application, we may want to display
FirstName LastName or LastName, FirstName.  Also, we may want ascending or
descending sorts.  If you are using a database, you may be tempted to let the
database order the records for you, and that's fine if you never need to change
the sort inside the application.  In object-oriented systems, however, a lot of
code never talks to the database, so we need to be able to sort.  Now, suppose I
wanted the following code to work:

This code won't work right now because
Array.Sort( ) counts on the elements in the array implementing the IComparable
interface.  This is a key interface in .net for sorting.  By adding an
implementation of that method to my Person class, I get sorting for free.  What
I am going for here is a sort by last name and then first name:

Notice how
I just had to implement a single method comparing first on last name and then on
first name.  Here is my output:

------ Test started: Assembly: BlogScratchPad.dll ------

Jerry Seinfeld
Bart Simpson
Homer Simpson

1 passed, 0 failed, 0 skipped, took 0.41 seconds.

That's the bread and butter sorting case,
and that gives my Person object a default sort order.  Anyone working with
Person(s) can now sort by last name, first name in ascending order.  But what if
I wanted to sort in descending order?  There is another key interface in .Net
called IComparer.  This interface enables you to create a class that defines the
sort order for any class.  Consider the following tests.  I would like my
Person(s) to be listed in descending alphabetical order (reverse of above). 
Here, I choose to implement the generic form to avoid some casting:
IComparer<T>.

Notice how this test looks very similar to
the previous one; however, I've added my new comparer class to instruct
Array.Sort( ) how to sort the array.

Notice how I just compared y to x instead of
x to y.  This gets me the descending order that I want.  Here is the result of
running the test:

------ Test started: Assembly: BlogScratchPad.dll ------

Homer Simpson
Bart Simpson
Jerry Seinfeld

1 passed, 0 failed, 0 skipped, took 0.41 seconds.

Notice how it is exactly the
reverse of the previous result – just what I wanted. 

Array.Sort(Array, IComparer) works to sort an array of any object under the
sun.  My team's Visual Studio solution has accumulated  a healthy number of
IComparer classes.  This allows our application to sort objects however needed,
whenever needed. 

I was listening to Internet radio before the term "podcast" was coined.  With the term, we have an explosion of Internet radio and listenership.  I've been asked several times what podcasts I follow.  I'll admit, there is limited time for listening, so over time, I have dropped some shows and picked up some others.  Here is my current list:

• .Net Rocks:  http://www.dotnetrocks.com/DotNetRocks_FullMP3.xml
• Polymorphic Podcast: http://polymorphicpodcast.com/podcast/feed/
• Channel 9: Podcasts: http://channel9.msdn.com/rss.aspx?ForumID=34&amp;Mode=0&amp;sortby=0&amp;sortorder=1&amp;format=mp3
• Slashdot Review: http://www.slashdotreview.com/wp-rss2.php
• Agile Toolkit Podcast: http://agiletoolkit.libsyn.com/rss
• The Java Posse: http://feeds.feedburner.com/javaposse
• Dr. Neil's Notes: http://feeds.feedburner.com/DrNeilsNotes
• Software Engineering Radio: http://www.se-radio.net/rss
• Hanselminutes: http://www.hanselminutes.com/hanselminutes_MP3Direct.xml