I was impressed with the professional atmosphere and organization at this event.

Andy’s presentation centered around the book, touching on several highlights over the two hour period.  This was largely a rehash for me, which was very good, with a little bit of new material thrown in.  (There is a new Pomodoro book pragprog is publishing so there was a brief overview of Pomodoro included with a plug – which I fully support at free/sponsored events; I had just read the RSS post earlier in the day so I would have been disappointed if it were skipped!)  His slides were good – not distracting – and the presentation was delivered with animation and some really well placed humor.

Points [I remember]:

Dreyfus Model of Skill Acquisition

Mind mapping (easily my favorite technique I learned from the book)

You cannot execute a great idea if you don’t exercise your brain to get it to produce them – write down your ideas, all of them

Meditation

How context switching and multitasking damages productivity

Have a personal wiki

Book study groups – going to suggest replacing our low value formal code reviews with this in an on-going basis

Finally Andy said it may be possible in the near future to get some of pragprog’s non-code books in an audio book format which for anyone who has a long commute is very good news.

This challenge involved averaging times of the day without the actual day in the context.  When I first started to tackle the problem I thought to myself that this will be very easy.  Then I hit the “no day” context and realized that this problem was much tougher than I anticipated.  When I finally saw the posted solutions including Chris Strom’s (blog) it was like decades old high school math came rushing back to me.  I would have never thought of plotting points on a graph but now that I’ve been exposed I’m certain I will never forget it!

My friend [and commuting body] Matt and I talked through the problem during our drive home as we sat in Virginia I-495 outer loop and I-95S traffic.  He had some ideas about plotting the problem linearly around 0 but ultimately I ended up going with making assumptions about how close the provided times were to midday and midnight.

require 'time'

SECONDS_IN_DAY = 86400
MIDNIGHT = Time.parse("12:00AM").to_i
MIDDAY = Time.parse("12:00PM").to_i

def average_time_of_day(times)
  seconds = []
  times.each {|time| seconds << Time.parse(time).to_i}
  seconds.sort!
  if (seconds.first - MIDNIGHT) < (seconds.last - MIDDAY)
    seconds.map! {|s| s < MIDDAY ? s += SECONDS_IN_DAY : s }
  end
  Time.at(seconds.inject { |sum,n| sum += n }.to_f / seconds.length).strftime("%I:%M%p").downcase
end

Gist: https://gist.github.com/5b371226faf83af50d7e

Interview: http://rubylearning.com/blog/2009/10/22/charles-feduke-winner-rpcfn-2/

I found a gem that does precisely what I needed named Construct.  Unfortunately there is a bug with Ruby 1.8.6 on Windows in regards to clean up of temp files.  The problem is that when attempting to clean up a Errno::EACCES is raised causing the unit test to fail (or you to write a lot of rescue blocks).

A workaround I came up with was to replace the rmtree method in the Pathname class within my unit test to perform no clean up.  Not the best approach I am sure, but it let me get on with my work.

# something_test.rb
require "test/unit"
require 'construct'
require 'something'

class Pathname
  # windows has problems with temp files created by Ruby
  # http://redmine.ruby-lang.org/issues/show/1494
  def rmtree
    nil
  end
end

class SomethingTest < Test::Unit::TestCase
   # test methods...
end

# something.rb
class Something
    def initialize(kernel=Kernel)
        @kernel = kernel
    end

    def process_arguments(args)
        @kernel.exit
    end
end

# something_spec.rb
require 'something'
describe Something do
    before :each do
        @mock_kernel = mock(Kernel)
        @mock_kernel.stub!(:exit)
    end

    it "should exit cleanly" do
        s = Something.new(@mock_kernel)
        @mock_kernel.should_receive(:exit)
        s.process_arguments(["-h"])
    end
end

What I learned was that you can define a constructor with optional arguments (in this case, initialize(kernel=Kernel) and then proceed to use @kernel’s methods instead of the methods that Kernel provides when you do not specify a class instance.  With a properly mocked and stubbed exit method in my spec things operate as expected.

Essentially the goal is to get away from a “GetOrCreate” master method call and just have two methods: Get(args) and Get(args, Foo default) and then leave the responsibility of default generation up to Foo.  This way there’s no unintended side effects and you don’t have to explicitly coalesce (though with this pattern you could as easily coalesce; strictly speaking it isn’t as “discoverable”)…

var foo = FooService.Get(23) ?? new Foo { ... };

So here’s the pattern defined in code:

public class Foo : ICloneable
{
    private readonly static Foo __default =
        new Foo { Bar = "...", Baz = Int32.MinValue };

    public string Bar { get; set; }
    public int Baz { get; set; }

    public static Foo Default()
    {
        return (Foo)__default.Clone();
    }

    public object Clone()
    {
        return new Foo { Bar = this.Bar, Baz = this.Baz };
    }
}

public class FooService
{
    public Foo Get(int baz)
    {
        // retrieve from data store...
        return null;
    }

    public Foo Get(int baz, Func<Foo> @default)
    {
        return Get(baz) ?? @default.Invoke();
    }
}

You’ll see that any associated overhead with Clone only occurs if Get(baz) returns null.  I have specifically stepped around the common naming standard of “GetDefault()” for the function – its named like a property - because its intended usage is as follows:

var foo = new FooService().Get(12, Foo.Default);

An ICloneable reference type is pretty much required, though any immutable reference type could get by without cloning because any changes gives you a new copy of that type.

public bool Validate(IValidationDictionary modelState, string prefix)
{
    // xVal example code
    var dataAnnotationErrors = from prop in TypeDescriptor.GetProperties(_entity).Cast<PropertyDescriptor>()
           from attribute in prop.Attributes.OfType<ValidationAttribute>()
           where !attribute.IsValid(prop.GetValue(_entity))
           select new ErrorInfo(prop.Name, attribute.FormatErrorMessage(string.Empty), _entity);

    var brokenRules = GetBrokenRules();

    if (!String.IsNullOrEmpty(prefix))
        prefix += ".";

    if (dataAnnotationErrors.Any())
        dataAnnotationErrors.ForEach(ei => modelState.AddError(prefix + ei.PropertyName, ei.ErrorMessage));
    if (brokenRules.Any())
        brokenRules.ForEach(rule => modelState.AddError(prefix + rule.Property, rule.Message));

    return modelState.IsValid;
}

There is a “Fix Indentation” button in PreCode.  I am in love.

Now just to setup the clipboard SWF thing.

I should seriously consider a theme with a wider content area.

1. Unload your project through Solution Explorer (right-click, unload)
2. Edit your *.csproj (yes you can do this in Visual Studio, right click the unloaded project node in Solution Explorer, Edit *.proj)
3. In the <ProjectTypeGuids /> node add the GUID {603c0e0b-db56-11dc-be95-000d561079b0}; (the semi-colon is important if you prepend it to the exiting list, which is what I did)
4. Add <MvcBuildViews>false</MvcBuildViews> as a sibling of the <ProjectTypeGuids /> node
5. Reload the project

I am working with a friend on an attempt at best practices MVC development using the whole nine yards (DI, TDD, CI, git, SVN).  I had sort of dreaded the part where I had to setup CruiseControl.NET because, well, I hate editing XML files and I hate configuring CC.NET.  Then I stumbled across Chris Allport's blog post on Hudson for .NET Projects.  Hudson is a continuous integration server written in Java and its trivially easy to install, setup, and get running.  On my workstation it took less than 15 minutes to have a working build.  My Windows Home Server (Windows Server 2003) it was a bit more taxing as I had no build environment so I'll detail the steps shortly.

Some of the advantages I see from Hudson, other than very easy to setup and configure:

• not a lot of hand editing XML files (you could I suppose)
• plugins - loads and loads - install from the web UI, no manual steps necessary
• has built in "install as Windows service" option
• if you do this, do it first for optimal user experience - if you set your hudson directory to something like "c:\hudson" and install as a Windows Service your previous settings will appear to be lost (but they aren't, they are just under the ~\.hudson folder Hudson uses by default)
• easy to manage security or for the masochistic LDAP integrated security
• very clean, responsive UI
• build reports, trends, status
• RSS feeds for build statuses per project plus email notification
• integrated textual help on just about everything

Its rare to find a software package that just feels enjoyable to use.  Hudson is one of those software packages.  It absolutely has displaced CC.NET for CI for me.

So on my bare Windows Server 2003 I had to install the following things (download links may not work due to session identifiers but you should be able to find everything after a cursory search):

• Java Runtime Environment 1.6 (1.5+ is required) [download]
• .NET Framework 3.5 with SP1 [download] (required a reboot)
• Hudson (latest stable) [download - can go out of date, look for the latest on the Hudson releases page]
• I placed the hudson.war file in c:\hudson and gave the local system (Network Service) account privileges to this folder
• Ruby (for Rake, optional if you use NAnt or something else) [download - this link can easily go out of date, you'll want the latest version of Ruby as always]
• after installation, Command Prompt and cd c:\ruby then gem install rake
• Windows SDK for Windows Server 2008 and .NET Framework 3.5 [download]
• Supported platforms: Windows Server 2003, amongst many others - don't let the name fool you!
• There is an ISO version and web installer - I went for the web installer and paired down the installed components to just the .NET SDK stuff
• (Optional) ASP.NET MVC if you are compiling an MVC application [download]
• (Optional) Visual Studio for C# Express [home page]

I also had to copy my workstation's MS Build targets (found, on Vista 64 by default at: C:\Program Files (x86)\MSBuild\Microsoft and ended up on my Windows 2003 Server 32-bit at Program Files\MSBuild\Microsoft [download]

After you're all setup, you can start Hudson by running:

java -jar c:\hudson\hudson.war*

then you can browse to http://localhost:8080 and begin your configuration - but if you're going to install Hudson as a Windows Service make sure to turn that on first so you don't waste time double configuring!  Installing as a service was very easy but I did have to go to Computer Management > Services and manually restart Hudson due to a Java NullPointerException caused when the web UI tried to launch the service manually.  No big deal.

I installed the Rake plugin and the NUnit plugin.  Once doing this I restarted the service (there is a button after plugin installation to do this, and restarting the service from the service hosted HTTP server works fine).

After fiddling around with some settings (specifically email - I created a gmail account and used smtp.gmail.com over SSL for my build server) I moved onto configuring a job.  Some settings I made for my build were:

• Advanced Project Options > Use custom workspace - I created c:\hudson\workspaces\specialorder and choose that as my custom workspace.  Be foreward: this ended up causing my repository to be placed under c:\hudson\workspaces\specialorder\specialorder since I also set the Source Code Management > Local module directory (optional) value to "specialorder"
• For building I used rake because, well, its ridiculously easy.  I used the example Rakefile.rb found on Chris Allport's blog "Getting Started with Rake on .NET Projects" as my basis, the resulting Rakefile.rb was placed in my source control repository's trunk\ directory and checked in.

task :default => :build

task :build => [:clean, :compile, :test]

task :clean do
  FileUtils.rm_rf("build") 

  # this doesn't do anything for me yet - have to conf. projects to ".."
end

task :compile do
params = '/t:Rebuild /nologo /v:m /p:Configuration="Debug" src\SiameseHead.SpecialOrder.sln'
msbuid = 'C:\\WINDOWS\\Microsoft.NET\\Framework\\v3.5\\MSBuild.exe'
sh "#{msbuid} #{params}"
end

task :test do
  # FileUtils.cd 'build\\Debug'
  # exec "..\\..\\tools\\nunit\\nunit-console.exe TestStuffInDotNet.dll"
end

You can see I haven't tried setting up automatic unit testing yet, but I will shortly.

• For Build > Advanced I specified the full path to the Rakefile.rb (C:\hudson\workspaces\specialorder\specialorder\trunk\Rakefile.rb) and the full path for the Rake working directory (C:\hudson\workspaces\specialorder\specialorder\trunk\); I was getting "invalid path" errors from Rake otherwise

Once you've saved your job you should be able to build it using the "Build Now" link and work your way through any errors (just click on failed builds then look for the "Console Output" link on the left side of the page).

http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=22739

I first read about it from Steve Sanderson's blog where he describes how to use it with an ASP.NET MVC project.

I am supporting a legacy web forms application and have a typical web application setup so I'll explain what I did to get up and running in a matter of minutes with LTAF.

1. Download LTAF; you can use the "... for ASP.NET Samples" link and pull the *.dll out of the Bin folder and the contents of the Test folder, or you could build from source using the "... for ASP.NET Source"
2. Create a new Class Library project in your solution and name it appropriately - Company.Tests.Integration.Site - for example
1. For this project's properties alter the output assembly's name to begin with App_Code - this will slightly speed up web test load times and can help solve problems you may experience if your web application references tons of assemblies, i.e. App_CodeCompany.Tests.Integration.Site
3. Add a reference to Microsoft.Web.Testing.Light.dll to your Company.Tests.Integration.Site project
4. Copy and add to your web project (Company.Site) the Test folder; you can name the folder anything you want and you don't strictly have to add it to your project but I did for convenience for Start > Debug
1. Remember to alter your build process to remove the Test folder for production releases
5. Alter the web.config file for your Company.Site to allow anonymous access to the Test folder:

<location path="Test">
  <system.web>
    <authorization>
      <allow users="*" />
    </authorization>
  </system.web>
</location>

1. Again, remember to alter your build process to eliminate this node from your production web.config
6. Add a reference to your integration test project, Company.Tests.Integration.Site, to your web application, Company.Site
7. Let's test the login page (here I assume that "Login.aspx" is the name of your login page and its in the root of the application and you've used an <asp:Login /> control)...
1. Create a new class LoginTests in your Company.Tests.Integration.Site project and eliminate the file's contents - it is very important that all tests exist outside of a namespace
2. Paste this code into the body of your LoginTests.cs file:

using Microsoft.Web.Testing.Light;

[WebTestClass]
public class LoginTests
{
    [WebTestMethod]
    public void SignInAndSignOut()
    {
        var page = new HtmlPage("Login.aspx");

        page.Elements.Find("UserName").SetText("someuser");
        page.Elements.Find("Password").SetText("yourPW");
        page.Elements.Find("LoginButton").Click(WaitFor.Postback);

        // you'll need to determine what a good landmark for your
        // application is upon successful login
        var logoutLink = page.Elements.Find("LogoutHyperlink");
        Assert.AreEqual("[Logout]", logoutLink.GetInnerText());

        logoutLink.Click(WaitFor.Postback);

        Assert.IsNotNull(page.Elements.Find("LoginButton"));
    }
}

8. Set your Company.Site as the startup project if its not already, and Tests/Default.aspx as the startup page; run from Visual Studio

Magic!  This is my first use of a browser automation framework for integration testing and while it has its pitfalls, it does work and looks very promising.

Notes

• Looks like all your integration tests must exist in the same assembly
• Source code for LTAF is available so making this a configuration option is a possibility
• All tests must exist outside of namespaces
• Prefixing your integration tests assembly with App_Code can help work around assembly loading problems as the test runner searches for WebTestClass attributes
• Remember to have your production build process eliminate the Tests folder and associated integration test assembly

The problem with this approach is that the class you want to deep copy requires that it be marked with the SerializableAttribute.  I've noticed that a portion of my time is spent writing hackarounds for classes in the .NET BCL and MailMessage is no exception - yup no ICloneable and no SerializableAttribute either.

public class Serializer
{
    public static void Serialize(Stream target, object source)
    {
        var formatter = new BinaryFormatter();
        formatter.Serialize(target, source);
    }

    public static T Deserialize<T>(Stream source) where T : class
    {
        var formatter = new BinaryFormatter();
        var obj = (T)formatter.Deserialize(source);
        return obj;
    }
}

public class MemorySerializer<T> : IDisposable where T : class
{
    #region Member Variables
    private readonly MemoryStream _ms;
    #endregion

    #region Constructors
    public MemorySerializer(MemoryStream ms)
    {
        _ms = ms;
    }

    public MemorySerializer()
    {
        _ms = new MemoryStream();
    }
    #endregion

    #region Methods
    public MemorySerializer<T> Serialize(T obj)
    {
        Serializer.Serialize(_ms, obj);
        _ms.Position = 0;
        return this;
    }
    public T Deserialize()
    {
        return Serializer.Deserialize<T>(_ms);
    }
    #endregion

    #region Implementation of IDisposable
    public void Dispose()
    {
        if (_ms == null)
            return;
        try
        {
            _ms.Close();
        }
        finally
        {
            _ms.Dispose();
        }
    }
    #endregion
}

public static class ObjectUtility
{
    /// <summary>
    /// Creates a deep copy of an object for any object which
    /// supports binary serialization.
    /// </summary>
    /// <typeparam name="T">Type to serialize/deserialize.</typeparam>
    /// <param name="source">Object to deep copy.</param>
    /// <returns>New instance of the object with all properties and
    /// fields that support serialization copied.</returns>
    /// <remarks>This method isn't as fast as a provided Clone method
    /// but when ICloneable is not implemented on a BCL class its a
    /// pretty close substitute.</remarks>
    public static T DeepCopy<T>(this T source) where T : class
    {
        T ret;
        using (var ms = new MemorySerializer<T>())
        {
            ret = ms.Serialize(source).Deserialize();
        }

       return ret;
    }
}