1:00 – 2:15pm

Room 18B – MonoTouch Testability and Architecture – Brian Donahue

Room 18C – Starting an Open Source Project or Contributing to an existing one and the best way to go about it – Ryan Svihla

Room 18D – Moving to Mono: Why? How? – Michael Maham

2:15 – 3:30pm

Room 18B – Codeplex Foundation – Sam Ramji

Room 18C – Integrating open source into corporate software – Mike Sheldon

Room 18D – Distributing on Linux (deb, rpm, huh??) – Frank Bergmann

9:00 – 10:15am

Room 18B - MonoDevelop vs Visual Studio + Resharper (what do we need to add) – Josh Flanagan

Room 18C – Silverlight and Windows Presentation Foundation (WPF) Best Practices – Justin Angel

Room 18D – 0 to 60 on Linux for Noobs

 

10:15 – 11:30am

Room 18B – Jazz Band Management (with Miguel de Icaza) – Kirstin Juhl

Room 18C – Build Your First Linode for Running ASP.NET – Eric Hexter

Room 18D – Adding Scripting To Your Applications (and making them cross-platform)

 

1:00 – 2:15pm

Room 18B – MonoTouch Pairing – Kirsten Juhl

Room 18C – Mono.AddIns, Managed Extensibility Framework (MEF), and/or Inversion of Control – Josh Flanagan

Room 18D – Using NHibernate in High Transaction Applications – Mike Sheldon

 

2:15 – 3:30pm

Room 18B – Lessons Learned by Reading Open Source Software (Architecture, etc.) – Frank Krueger

Room 18C – Legal Issues in Technology (Independent Contractors, Open Source Software, Intellectual Property (Copyright vs. Trademarks vs. Patents) – John Petersen

Room 18D – Automated Build with Rake – Scott Bellware

Sharp Architecture’s Approach

Sharp Architecture is an excellent “architectural foundation for building maintainable web applications with ASP.NET MVC”. It has an Action Filter called Transaction that starts a transaction in the OnActionExecuting event, and then commits if no exception occurred. Otherwise, it explicitly rolls the transaction back. In fact, the Implicit transactions thread in the Sharp Architecture Google group discusses the Transaction attribute and some of the issues using it. The Transaction attribute provides the functionality that I want, but it requires the developer to decorate each Action method with an attribute. Why not make the HttpModule that creates and disposes of the Unit of Work handle the commit?

Modified Bootstrapping Example

I have modified the Bootstrapping NHibernate with StructureMap example from my previous post to do just that. Now, the NHibernateModule is responsible for calling Commit() on the UnitOfWork. Here is the NHibernateModule’s new Dispose method:

public void Dispose()
{
    _unitOfWork.Commit();
    _unitOfWork.Dispose();
}

The only addition is the call to the _unitOfWork.Commit(). However, now that the NHibernateModule is responsible for the commit, the developer can not abort an existing transaction. So, I added a Rollback() method to the IUnitOfWork class. The concrete implementation, UnitOfWork, calls _transaction.Rollback().

One final change to the UnitOfWork prevents it from throwing an exception if the developer explicitly calls commit by checking the ITransaction’s IsActive property before attempting to commit. Here is the UnitOfWork’s new Commit method:

public void Commit()
{
    if (_transaction.IsActive)
        _transaction.Commit();
}

Multi-Transaction Unit of Work

There is still one issue nagging at me. Once the developer commits the unit of work, the transaction is closed. The FubuTasks example in the fubumvc-contrib project solves this problem by starting a new transaction once the existing transaction is committed. Here is the source for FubuTask’s NHibernateUnitOfWork. I have talked to Chad Myers about this implementation and he has moved away from the idea of handling rollback in general. In any event, I don’t like the idea of starting a new transaction because I don’t think there should be one transaction per request. At the same time, I am preventing the developer from using my unit of work for more than one transaction. At least for now, opening a new transaction is a YAGNI for me. What do you think?

The full source code with these changes are available in the mvbalaw-commons project here.

Tags: NHibernate

Many examples on configuring NHibernate depend on some library such as FluentNHibernate or include additional concepts such as Repositories. While we use FluentNHibernate and Repositories to interface with the database, I did not want to complicate the example with these concerns. I did not want to preclude their addition, either.

NHibernate Registry

I have encapsulated the NHibernate configuration in a StructureMap Registry. It makes the following available:

• NHibernate.Configuration as a Singleton
• ISessionFactory as a Singleton
• ISession scoped to Hybrid (HttpContext, if available, falling back to Thread)
• IUnitOfWork scoped to Hybrid, a light-weight container for ISession (more on this later)
• IDatabaseBuilder, a utility class to create the database using SchemaExport and populate it with initial data.

That’s it. If you want to create your own ISession (for example, to use in an integration test), then you request the ISessionFactory and call the OpenSession() method.

Here is the NHibernateRegistry class that provides the Configuration, ISessionFactory, ISession, and IUnitOfWork:

using NHibernate;
using NHibernate.ByteCode.Castle;
using NHibernate.Cfg;
using NHibernate.Dialect;
using NHibernate.Driver;
using NHibernateBootstrap.Core.Domain;
using StructureMap.Attributes;
using StructureMap.Configuration.DSL;
using Environment=NHibernate.Cfg.Environment;

namespace NHibernateBootstrap.Core.Persistence
{
    public class NHibernateRegistry : Registry
    {
        public NHibernateRegistry()
        {
            var cfg = new Configuration()
                .SetProperty(Environment.ReleaseConnections, "on_close")
                .SetProperty(Environment.Dialect, typeof(SQLiteDialect).AssemblyQualifiedName)
                .SetProperty(Environment.ConnectionDriver, typeof(SQLite20Driver).AssemblyQualifiedName)
                .SetProperty(Environment.ConnectionString, "data source=bootstrap.sqlite;Version=3")
                .SetProperty(Environment.ProxyFactoryFactoryClass, typeof(ProxyFactoryFactory).AssemblyQualifiedName)
                .AddAssembly(typeof(Blog).Assembly);

            var sessionFactory = cfg.BuildSessionFactory();

            ForRequestedType<Configuration>().AsSingletons().TheDefault.IsThis(cfg);

            ForRequestedType<ISessionFactory>().AsSingletons()
                .TheDefault.IsThis(sessionFactory);

            ForRequestedType<ISession>().CacheBy(InstanceScope.Hybrid)
                .TheDefault.Is.ConstructedBy(ctx => ctx.GetInstance<ISessionFactory>().OpenSession());

            ForRequestedType<IUnitOfWork>().CacheBy(InstanceScope.Hybrid)
                .TheDefaultIsConcreteType<UnitOfWork>();

                ForRequestedType<IDatabaseBuilder>().TheDefaultIsConcreteType<DatabaseBuilder>();
        }
    }
}

Unit Of Work

Recently, I have been in several discussions regarding what the Unit of Work’s (single) responsibility is. Per Martin Fowler’s definition, a Unit of Work “maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.” In practice, NHibernate’s ISession is a Unit of Work.

When I first created my example, I used the ISession directly, but I found myself writing the following code over and over again:

    var product = new Product {Name = "Apple", Category = "Fruits"};
    using (var session = _sessionFactory.OpenSession())
    using (var transaction = _session.BeginTransaction())
    {
        session.Save(product);
        transaction.Commit();
    }

When I really wanted to write this:

    var product = new Product {Name = "Apple", Category = "Fruits"};
    using (var unitOfWork = new UnitOfWork(_sessionFactory))
    {
        unitOfWork.CurrentSession.Save(product);
        unitOfWork.Commit();
    }

So, my Unit of Work is a simple wrapper that combines the ISession and ITransaction together.

using System;
using NHibernate;

namespace NHibernateBootstrap.Core.Persistence
{
    public interface IUnitOfWork : IDisposable
    {
        ISession CurrentSession { get; }
        void Commit();  
    }
}

using NHibernate;

namespace NHibernateBootstrap.Core.Persistence
{
    public class UnitOfWork : IUnitOfWork
    {
        private readonly ISessionFactory _sessionFactory;
        private readonly ITransaction _transaction;

        public UnitOfWork(ISessionFactory sessionFactory)
        {
            _sessionFactory = sessionFactory;
            CurrentSession = _sessionFactory.OpenSession();
            _transaction = CurrentSession.BeginTransaction();
        }

        public ISession CurrentSession { get; private set;}

        public void Dispose()
        {
            CurrentSession.Close();
            CurrentSession = null;
        }

        public void Commit()
        {
            _transaction.Commit();
        }
    }
}

I have heard the argument that this is not a real Unit of Work because it does not track the changes per Martin Fowler's definition. While I agree, I also believe that ISession is not just a Unit of Work either because it includes Get methods that have nothing to do with the Unit of Work. Also, best practices dictate that NHibernate not use implicit transactions. ISession can not be a Unit of Work without requiring the developer to interact with ITransaction. So, my compromise is to create a simple interface that melds NHibernate’s ISession with its ITransaction. I have heard other names for this class such as TransactionBoundary, but that doesn’t sound right to me. I am open to other suggestions. However, please don’t get caught up in the naming or I’ll be forced to change it to an unpronounceable symbol called “The class formerly known as Unit of Work”.

NHibernateModule

Finally, in order to manage the Unit of Work for web applications, I created an HttpModule called NHibernateModule that creates a Unit of Work in the Begin_Request event handler and disposes of it in the End_Request event handler.

using System;
using System.Web;
using NHibernateBootstrap.Core.Persistence;
using StructureMap;

namespace NHibernateBootstrap.Web
{
    public class NHibernateModule : IHttpModule
    {
        private IUnitOfWork _unitOfWork;

        public void Init(HttpApplication context)
        {
            context.BeginRequest += ContextBeginRequest;
            context.EndRequest += ContextEndRequest;
        }

        private void ContextBeginRequest(object sender, EventArgs e)
        {
            _unitOfWork = ObjectFactory.GetInstance<IUnitOfWork>();

        }

        private void ContextEndRequest(object sender, EventArgs e)
        {
            Dispose();
        }

        public void Dispose()
        {
            _unitOfWork.Dispose();
        }
    }
}

NHibernateBootstrap Source Code and Tests

I have created a Google Code project called mvbalaw-commons with the code for NHibernateBootstrap among other things. You can browse the code here or check it out from here.

The sample application uses SQLite. So, the only external requirement is that you have installed ASP.NET MVC in order to run the web application. You will need Ruby and Rake to run the build file. See the README.TXT in the root of the NHibernateBootstrap file for more information getting it up and running.

Note: This example requires a build of StructureMap 2.5.4 after revision 262 which changes “the concrete class behavior so that it can still build a concrete class that is not specified, but it doesn’t get into the GetAllInstances()” per the check-in comment. Hopefully, there will be a new release of StructureMap soon. Until then, feel free to use the StructureMap dll in this project which was built from trunk (revision 263).

NHibernateBootstrap includes four projects:

• NHibernateBootstrap.Core – fully functional domain and persistence classes to demonstrate NHibernate.
• NHibernateBootstrap.Tests – integration tests around CRUD operations for a Product class.
• NHibernateBootstrap.Tests.Environment – a single test that calls ObjectFactory.AssertConfigurationIsValid() to ensure that StructureMap is configured correctly.
• NHibernateBootstrap.Web – an ASP.NET MVC 1.0 application with a Product CRUD controller.

The sample application bootstraps NHibernate, tests a ProductController, and provides full CRUD operations for a Product through an ASP.NET MVC web application.

In order to improve accessibility, I based my sample application on the one in the Getting Started Guide on NHibernate Forge which originally came from Gabriel Schenker’s excellent NHibernateFAQ series of blog posts.

Also, I started with Ayende’s NHibernate Unit Testing example to get familiar with interacting with SQLite. I left his example in the BlogTestFixture class in the NHibernateBootstrap.Tests project.

So what do you think? You can leave comments here or it might be better to move the discussion over to a discussion thread that I started in the StructureMap Google group to get more people involved.

Tags: NHibernate, StructureMap

Here is an example code snippet created using Alex Gorbatchev’s Syntax Highlighter tool:

namespace StarterProject.Core
{
    public class HelloWorld
    {
        public string Speak()
        {
            return "Hello, World!";
        }
    } 
}

It uses a series of javascript libraries and CSS styles to render code blocks in modern browsers.

Scott Hanselman’s blog post, Best Code Syntax Highlighter for Snippets in your Blog. explains how Syntax Highlighter works.  He even explains how to use it with PreCode, a LiveWriter plug-in.

I host my blog at SquareSpace, but could not find information on using Syntax Highlighter with it.  There is documentation on adding your own javascript and how to use Google Analytics.  Between these two pages, I was able to add the configuration necessary to integrate Syntax Highlighter with my blog.

First, login to your SquareSpace website.  Then, under the Website Management menu, there is a menu called Data & Media.  Select the File Storage submenu.  Create a folder called scripts and another one called styles.  These folders will be available to your web pages as /storage/scripts and /storage/styles, respectively.  Download and unzip the Syntax Highlighter folder.  Use the Upload Files button on the File Storage page to upload the contents of the scripts and styles folders to the new folders you just created at SquareSpace.

Under the Website Management menu, there is another menu called Structure.  Select the Website Settings submenu item.  On the Website Settings page, there is another menu bar.  Select the Code Injection menu item which brings up a drop-down menu for the Injection Region and a textarea for the HTML code.  Add the following code (you can cut and paste it from here) to the Extra Head Code (within <head> Tag) injection region:

<script type="text/javascript" src="storage/scripts/shCore.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushBash.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushCpp.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushCSharp.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushCss.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushDelphi.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushDiff.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushGroovy.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushJava.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushJScript.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushPhp.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushPlain.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushPython.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushRuby.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushScala.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushSql.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushVb.js"></script>
<script type="text/javascript" src="storage/scripts/shBrushXml.js"></script>
<link type="text/css" rel="stylesheet" href="storage/styles/shCore.css"/>
<link type="text/css" rel="stylesheet" href="storage/styles/shThemeDefault.css"/>
<script type="text/javascript">
    SyntaxHighlighter.config.clipboardSwf = 'storage/scripts/clipboard.swf';
    SyntaxHighlighter.all();
</script>

I noticed some issues with preview in LiveWriter and even previewing the blog posts before publishing them, but it looked right for me once I published the blog entries.  For reference, I installed Syntax Highlighter version 2.0.320 and PreCode version 5.0.1.

You may also want to adjust the width of your content column to accommodate wider code snippets.  If so, I recommend this page, Adjusting Column Widths.

At the AltNetSeattle Open Spaces conference at the end of February, Aaron Jensen convened a session on how the AutoMockingContainer that they created is not working for them and where to go from here. I went into the session expecting an overview of Machine.Container, but it turned out to be more of a discussion of the issues that people are having using mock objects in Test Driven Development.

Basically, the problem is that refactoring break tests because they are brittle or because the tests are no longer relevant after the refactoring.  So, you spend your time maintaining tests, not maintaining code.

AutoMockingContainer

Aaron described the evolution of their process as starting with manual mocking in fine-grained unit tests, but found that they were creating a lot of mocks.  In response, they came up with the AutoMockingContainer.  It worked great, but mocking entities was not as useful because they were persistent ignorant anyway.

Fluent Builders

This led to a move towards fluent fixtures or what some people call fluent builders (e.g. new Student(“Bob”).EnrolledIn(new Course(“101”)) ).  The goal of fluent builders is to make it easy to create object graphs, but not necessarily specify the business behavior.  However, even this process has problems because refactoring or decomposing a service breaks the tests because they are no longer relevant.

Introducing a Container

Jimmy Bogard asked about introducing an Inversion of Control (IoC) container.  Aaron said that the problem with containers is that registration time is slow and they can get in the way of testing.  For example, a container would cache an object, but you might want more control than a traditional container allows you to have.  For testing, you need a container that does fast registration, gives you the ability to override with mocks, and allows for lifetime reset.  Machine addresses some of these issues, but he did not go into detail on it.  Instead, the session became more of a discussion about how different people deal with the brittleness.

No real answers, yet

Aaron went through a couple of examples of starting with the controller and adding checkpoints as you flesh out the implementation.  Also, he brought up the idea of having tests that fail (warning tests?), but don’t stop the rest of the tests.  Ian Cooper mentioned their use of Fitnesse tests. (Read more about the session in Ian’s blog post about AltNetSeattle.)  Aaron also mentioned the Ruby Synthesis project which I would like to investigate further.

I came away from the session with a lot of new ideas, but no real answers, yet.  However, it is nice to have the opportunity to listen to people that are further down the path than I am.  Thanks to all who participated.

You can watch the video here:

Here are my Session Notes.

At the AltNetHouston Open Spaces conference last weekend, I convened a session on FubuMVC.  Selfishly, I wanted to get Chad Myers and Jeremy Miller to talk more about their alternative MVC stack.

FubuMVC is an MVC framework built on .NET.  It is often looked at as an alternative to Microsoft’s ASP.NET MVC. framework that shipped last month.  FubuMVC is a framework that grew organically out of work that Jeremy and Chad were doing at Dovetail Software.  The Fubu in FubuMVC is short for For Us By Us.

At Kaizenconf, they gave a workshop called Using and Abusing ASPNET MVC for Fun and Profit.  Based on the interest from that workshop, Chad looked to recreate the framework that they were using at Dovetail as an open-source project.  Over the Christmas break, he coded the core of framework (available on Google Code here).

Unfortunately, my laptop died during the AltNetHouston conference and I was unable to keep my MinoHD camera charged.  So, I was only able to record the first half hour of the hour and ten minute session.  There was another video recording.  I will try and track that down and post a link here if and when it is available.

In the meantime, here is the first half hour:

AltNetHouston: FubuMVC from Weston M. Binford III on Vimeo.

Also, here are the Session Notes.

Last weekend, I attended the AltNetHouston Open Spaces conference.  Thanks to Ben Scheirman, Claudio Lassala, and J Sawyer for organizing the event and to Steven “Doc” List for facilitating.  I especially enjoyed the sessions on FubuMVC and Why Blog and Open Source.

As with previous conferences, there were a number of people videoing the proceedings.  I had my MinoHD camera, but had battery charging issues after my laptop died.  I did record the Opening Circle Friday night and part of the FubuMVC session on Saturday.

If you are not familiar with Open Spaces conferences, the participants get together at the beginning of the conference and create the agenda as a group.  Doc is an excellent facilitator.  Ben opened the conference and then turned it over to Doc to explain how Open Spaces work.  Finally, the attendants proposed sessions for the weekend.

Here is the Opening Circle video:

AltNetHouston: Opening Circle from Weston M. Binford III on Vimeo.

You can see other videos and session notes for most of the sessions on the HoustonAltNet wiki.

This is something that I have planned to do for almost five years, but never started because I was afraid of starting and then not sticking to it, picking the wrong platform, or just not having enough to say.  However, the Why Blog and Open Source session at the ALT.NET Houston Open Spaces conference last weekend gave me the kick that I needed to get started.

Instead of trying to get it perfect.  I'm just going to start.  Hopefully, there will be something here worth reading someday, but I know that I will never get it right if I don't start somewhere.  So here goes.  I take solace in the fact that nobody is probably reading.  If you are, please bear with me as I find my voice.