Why do we need DB Change management

Okay then Mr. Developer (or Mrs.), Why do we need source control? We need database change management for the same reason we need source control. To help manage the code and dependencies our applications rely on.

Recipes for Disaster:

Team of developers all working/developing off of a central database

Team of developers working/developing off of local database, with no way to keep changes in sync.

So what’s the problem with these recipes? As new features are developed for an application it is very likely that the database will need schema changes to support these features. These could be as simple as new tables or adding a column. If we have schema changes, we have to make sure that the code base for the app is deployed concurrently with the schema changes.

When deploying software to production, code files and libraries can usually be overwritten with a new version. Databases however must be updated intelligently.

So we’ve got a problem, do we have a solution?

Enter Tarantino. I was talking with Jarod F. and he said he had heard some stuff about it, but had never used it so I started digging around and found enough pieces to get it working. So first thing I did was head over to the Tarantino project site. Starting reading around and then i did a little googling and managed to dig up enough information to really wet my appetite and to get it working. Then Eric Hexter was kind enough to give me some time via IM and cleared up several areas for me.

Before I get into the specifics of how to set all this up, I want to explain how Tarantino finds and keeps changes in sync.

1. Tarantino is a forward only change management system, you can’t roll back.
2. If you use Tarantino, you can’t go make changes by hand manually
3. Tarantino uses RedGate SQL Compare if you want, to compare DB Schemas
4. Tarantino makes a table in every DB it touches to keep track of what scripts have been executed on that DB

The system is based on a set of conventions which allow incremental changes to the database schema. The conventions are to create two subdirectories in your database scripts folder. Create– this is where your inital schema change scripts go. Update – this is where your change scripts should be placed. They should be named with the following convention ####SCRIPTNAME.sql where #### is the script number with leading zeros. This will ensure the first script 0001_first_schema_change.sql would be executed first. There is a third folder, ExistingSchema, that you will need if you are going to start using Tarantino on an app that is already in development or production.

There are two ways to use Tarantino, command line, and as a NAnt task. I will be showing the NAnt task method, as it has the most examples available on the net.

Project Setup

So what I have done, is created a very simple project. A class library with a Fluent NHibernate configuration, a test fixture to create the database schema, and two simple entities which I have listed below:

public class Order

{

    public virtual int Id { get; set; }

    public virtual int OrderNumber { get; set; }

    public virtual string PONumber { get; set; }

    public virtual IList<OrderItem> OrderItems { get; set;}

   public Order()

   {

       OrderItems = new List<OrderItem>();

   }

}

public class OrderItem

{

    public virtual int Id { get; set; }

    public string ItemName { get; set; }

    public string Description { get; set; }

}

and my NHibernate and Test Fixture setup:

[TestFixture]

public class DB_Setup_Fixture

{

    private Configuration _configuration;

    [TestFixtureSetUp]

    public void FixtureSetup()

    {

        _configuration = Fluently.Configure()

            .Database(MsSqlConfiguration.MsSql2008

                          .ConnectionString(c =>

                                            c.FromConnectionStringWithKey("testData"))

                          .UseReflectionOptimizer()

                          .ShowSql())

            .Mappings(m =>

                      m.AutoMappings.Add(AutoMap.AssemblyOf<Order>()

                                             .Where(x => x.Namespace.EndsWith("Domain"))))

            .BuildConfiguration();

    }

    [Test, Explicit, Category("DBSetup")]

    public void Create_DB_Schema()

    {

        var exporter = new SchemaExport(_configuration);

        exporter.Create(true, true);

    }

}

The one thing to make note of here, is that my test is set to explicit, and I gave it a category of “DBSetup”. This will be important once we start configuring NAnt and Tarantino.

So now we have a very simple application that we can use to play around with Tarantino. To get Tarantino working, I am using the modified NAnt files that CodeCampServer is using. I just copied over their NAnt folder they have checked into source control. There are two NAnt build files that are required to use Tarantino. Disclaimer: I am a total NAnt noob, this is not my usual build utility, but I figured out enough to make it work.

Common.build

<?xml version="1.0" encoding="utf-8"?>

<project xmlns="http://nant.sf.net/schemas/nant.xsd">

    <!-- Database change management -->

    <target name="rebuildDatabase" depends="dropDatabase, createDatabase" />

    <target name="updateDatabase">

        <property name="action" value="Update" />

        <call target="manageSqlDatabase" />

    </target>

    <target name="createDatabase">

        <property name="action" value="Create" />

        <call target="manageSqlDatabase" />

    </target>

    <target name="dropDatabase">

        <property name="action" value="Drop" />

        <call target="manageSqlDatabase" failonerror="false"/>

    </target>

    <target name="manageSqlDatabase">

        <manageSqlDatabase

            scriptDirectory="${database.script.directory}"

            action="${action}"

            server="${database.server}"

            integratedAuthentication="${database.integrated}"

            database="${database.name}"

      username="${database.username}"

      password="${database.password}"

        />

        <if test="${action != 'Drop'}">

            <echo message="Current Database Version: ${usdDatabaseVersion}" />

        </if>

    </target>

  <script language="C#" prefix="migration" >

    <references>

      <include name="System.IO.dll" />

    </references>

    <code>

      <![CDATA[

              [Function("next-migration-number")]

              public static string NextMigration(string path  ) {

                  string[] files = System.IO.Directory.GetFiles(path);

                  int count=1;

                    if(files.Length > 0)

                    {

                        string filename = System.IO.Path.GetFileName(files[files.Length-1]);

                        try

                        {

                            count = Convert.ToInt32(filename.Substring(0, 4));

                            count++;

                            if(count%2 == 0)

                                count++;

                        }

                        catch

                        {

                        }

                    }

                  return string.Format("{0:0000}", count);

              }

            ]]>

    </code>

  </script>

</project>

This file sets up most of the plumbing that hooks up the Tarantino NAnt targets for use in the nant.build file

NAnt.build

<?xml version="1.0" encoding="utf-8"?>

<!--EXTERNAL_PROPERTIES: usdDatabaseVersion, CCNetLabel-->

<project name="TarantinoSample" xmlns="http://nant.sf.net/schemas/nant.xsd">

      <!-- ************** -->

    <!-- Initialization -->

    <!-- ************** -->

    <include buildfile="common.build"/>

      <loadtasks assembly="lib\nant\Tarantino.Nant.Tasks.dll" />

    <!-- ***************** -->

    <!-- Master Properties -->

    <!-- ***************** -->

    <property name="company.name" value="Tarantino Test"/>

    <property name="assembly.unittests" value="TarantinoSample.dll"/>

    <!-- Version settings -->

    <property name="project.config" value="debug"/>

    <!-- Folder references -->

    <property name="dir.solution" value="src"/>

    <property name="dir.build" value="build" dynamic="true"/>

    <!-- Compilation settings -->

    <property name="nant.settings.currentframework" value="net-3.5" />

    <property name="file.solution" value="${dir.solution}/${project::get-name()}.sln"/>

    <!-- Database migration settings -->

    <property name="database.script.directory" value="dbChangeScripts" />

      <property name="database.server" value="localhost" overwrite="false"/>

    <property name="database.name" value="OrderData" overwrite="false"/>

    <property name="database.integrated" value="true" overwrite="false" />

    <property name="database.username" value="dbuser" overwrite="false"/>

    <property name="database.password" value="P@ssword1" overwrite="false"/>

    <!-- ********************************** -->

    <!-- Database Change Management Targets -->

    <!-- ********************************** -->

    <target name="reset-database" depends="dropDatabase, createDatabase">

        <nunit2 failonerror="true" verbose="true">

            <formatter type="Plain" />

            <test assemblyname="${dir.solution}/bin/${project.config}/${assembly.unittests}">

                <categories>

                    <include name="DBSetup"/>

                    <exclude name="*"/>

                </categories>

            </test>

        </nunit2>

    </target>

      <target name="db-migration">

        <delete file="${database.script.directory}/Update/_New_Script.sql"  />

        <call target="reset-database" />

        <call target="create-versioned-database" />

        <property name="migrationScriptName" value="${migration::next-migration-number(database.script.directory+'/Update')}_AutoGeneratedMigration.sql"/>

        <if test="${file::exists('c:\program files (x86)\red gate\SQL Compare 8\SQLCompare.exe')}" >

              <property name="redgate.exe" value="c:\program files (x86)\red gate\SQL Compare 8\SQLCompare.exe"/>

        </if>

        <if test="${file::exists('c:\program files\red gate\SQL Compare 8\SQLCompare.exe')}" >

              <property name="redgate.exe" value="c:\program files\red gate\SQL Compare 8\SQLCompare.exe"/>

        </if>

        <exec

              program="${redgate.exe}"

              commandline="/f /v /server1:${database.server} /server2:${database.server} /database1:${database.name} /database2:${database.name}Versioned /scriptfile:${database.script.directory}/Update/_New_Script.sql /exclude:Table:usd_AppliedDatabaseScript"

              resultproperty="execReturnCode"

              failonerror ="false"/>

          <fail if="${execReturnCode != '0' and execReturnCode != '63'}" message="Redgate Compare Failed!"/>

        <if test="${file::exists(database.script.directory + '/Update/_New_Script.sql') == false}">

            <echo message=""/>

              <echo message="---------------------"/>

              <echo message="No Migration Required"/>

        </if>

        <if test="${file::exists(database.script.directory + '/Update/_New_Script.sql')}">

            <move file="${database.script.directory}/Update/_New_Script.sql" tofile="${database.script.directory}/Update/${migrationScriptName}"/>

            <echo message="Created Migration File ${database.script.directory}/Update/${migrationScriptName}"/>

          </if>

      </target>

      <target name="create-versioned-database">

        <tstamp></tstamp>

        <manageSqlDatabase

            action="Drop"

            server="${database.server}"

            integratedAuthentication="true"

            database="${database.name}Versioned"

            username=""

            password="" />

        <manageSqlDatabase

            scriptDirectory="${database.script.directory}"

            action="Create"

            server="${database.server}"

            integratedAuthentication="true"

            database="${database.name}Versioned"

            username=""

            password="" />

      </target>

</project>

Inside this file there are a few pieces that need to be configured for use in your own app, these are all listed under “Master Properties”

Change script creation

So without going into too many details, what I have done is created my initial schema using my Unit Test. From here I could script this out to a text file, but what I did was use SQL Compare, comparing my initial schema to an empty database. This gave me my initial SQL script that creates my database.

Just to verify that my initial schema creation script is good, I will have Tarantino create the Versioned database for me using this command:

lib\nant\nant.exe –buildfile:nant.build create-versioned-database

Tarantino then looks in the ExistingSchema folder, runs any scripts found there, then does the same thing for the Updates folder.

In order to test out the change management features, I made a small change to my domain, adding a decimal of cost to the OrderItem class should do the trick. Rebuild my solution, then back to the command line to run my “Create Database Migration Script.bat” file. This file is just running the NAnt task.

What happens then, is NAnt goes out and runs my DBSetup test that is in my project. Which recreates the “OrderData” database. Tarantino then creates the “Versioned” database, then uses SQL Compare to find the changes between the two, and creates a file in the update folder for me named, 0001_AutoGeneratedMigration.sql NOTE: It is important to rename this file before it is committed to source control, or before you apply these changes to a database. Tarantino tracks the scripts that have been run by filename.

Push to Production or Dev

So I have mentioned two databases so far in this post, OrderData and OrderDataVersioned. These two databases contain no data, that’s not to say that they couldn’t, if you had scripts that put it in. But that is not what they were designed to do. Our app.config is pointing to OrderData, so when we ask NHibernate to build the schema, it drops all the tables and recreates them, losing all data. OrderDataVersioned, is Tarantinos database that is used to keep changes in sync. In our development environment, every dev has a third database, we would call OrderDataProd for instance. This database could have sample data and other information in it. Let’s say, we don’t want to lose our data in this DB so what we do is let Tarantino handle the first two databases, then we deploy our schema changes to our development database. We use this same technique to push changes to production, after backups of course.

We can do this easily with the following command:

lib\nant\nant.exe –buildfile:nant.build updateDatabase –D:database.name=OrderDataProd

Now when I tried to run this, my database OrderDataProd did not exist, so I went to SQL manager, created it, and then ran the command again, only to be slammed with another error. Since the database existed, Tarantino did not run the create schema script, only the update, which created another error. The next command will create the database I want, by executing the schema creation script, then applying any updates to it.

lib\nant\nant.exe –buildfile:nant.build createDatabase –D:database.name=OrderDataProd

Bingo! I now have my 3rd database that I can dump data into and start developing on top of. Just to be sure that we can create another change script, and deploy it to this database, I will modify the domain again, by adding a quantity to the OrderItem object. I will leave this step up to you to try out.

Source Code

I know the blog formatting sometimes jacks up code samples a lot so I am making all the source for this post available two ways:

• Zip File Download
• Elegant Code SVN Repository

Information Sources

Eric Hexter – Huge Help

CodeCampServer

Palermo and Hexter Screencast on Tarantino

The long version

Work pretty much consumes all of my waking hours anymore, which sucks, but it will be better soon. I have grown my team since my last post, we have 4 developers now, 2 graphic designers and an all around marketing/design guy. Pretty soon we are going to have to move out of this sardine can we call an office. The team is all working towards the same deadline, which is to get our new site ready for launch on August 15. We are building our entire web app on top of FubuMVC, which has been very challenging and rewarding.

What’s happening with FubuMVC?

Funny you should ask that, FubuMVC continues to evolve weekly, no major changes as of yet but there are some on the horizon.

No More Controllers

I am excited about this one. Composable controllers, AKA, no controllers, just behavior chains. You can read more about this one straight from the horses mouth. It is a little lengthy, but has some good info. But essentially when you configure FubuMVC for your project, you will be able to conventionally or explicitly setup a chain of behaviors that wrap around an action. Chad and Mark have already started laying the groundwork for this too. This will allow a much more flexibility to what an Action can do.

No More ISupportResultOverride

Before this change, if you wanted to redirect to another view or action you had to implement ISupportResultOverride on a ViewModel, set that value to a RedirectResult and then return the ViewModel. Well, not anymore. Now there is a service, called IResultOverride. You call that service, and say for instance _resultOverride.RedirectTo(_resolver.Home()). In my example_resultOverride is an injected instance of IResultOverride, and _resolver is an injected instance of IUrlResolver using an extension method to get the url.

You can also do this:

_resultOverride.RedirectTo(“/home”);

or:

_resultOverride.RedirectTo<HomeController>(c => c.Index(null));

Then you just return the ViewModel that your controller action expects to return, and that’s it.

Other Changes

I know Chad is working on some stuff to cleanup some of the configuration DSL, which should help out a lot. He also added more descriptive error messages to the framework, so if you get a Yellow Screen of Death and it’s the framework or configurations fault it will tell you more elegantly.

That’s really all I have time to write about now, but I will keep you guys posted on how these things progress as we move forward. I also have some top secret stuff that I can’t write about, yet anyway

As always, let me know what you think, comments, questions, etc… If there is anything more you want to know about FubuMVC leave a comment, or head over to the Google Group

• FubuMVC From Scratch Part 1 – Basic project structure setup
• FubuMVC From Scratch Part 2 – FubuMVC configuration and Controller setup
• FubuMVC From Scratch – Part 3 (Adding View to project)

Persistence is a requirement in virtually every application that we write today, and now the time has come for us to add a persistence model to our FubuMVC app. I know I mentioned moving my samples to the FubuCart source, but I am going to go ahead and implement the persistence piece in the same project the previous articles using, FubuSample. I have also added all the code for this series to the FubuMVC-Contrib project

We will be implementing our persistence model to use NHibernate, Fluent NHibernate, Repository Pattern and UnitOfWork pattern all on top of SQL Express or standard. This will also work for sqllite and other database servers.

Class and Interfaces we have to implement:

• ISessionSourceConfiguration
• SQLServerSessionSourceConfiguration
• IUnitOfWork
• INHibernateUnitOfWork
• NHibernateUnitOfWork
• IRepository
• NHibernateRepository
• DomainEntity
• IDomainQuery
• FubuSamplePersistenceModel

Note: I put the first two in the list in my Core.Config namespace, and the rest in Core.Persistence

Before we start you probably want to go ahead and add the following references to your core project and Web project

Let’s just work our way down the list and get these files implemented.

ISessionSourceConfiguration

public interface ISessionSourceConfiguration

{

    bool IsNewDatabase { get; }

    ISessionSource CreateSessionSource(PersistenceModel model);

}

SQLServerSessionSourceConfiguration

public class SQLServerSessionSourceConfiguration : ISessionSourceConfiguration

{

    #region Implementation of ISessionSourceConfiguration

    public bool IsNewDatabase

    {

        get { return false; }

    }

    public ISessionSource CreateSessionSource(PersistenceModel model)

    {

        var properties = GetProperties();

        var source = new SessionSource(properties, model);

        create_schema_if_it_does_not_already_exist(source);

        return source;

    }

    private void create_schema_if_it_does_not_already_exist(ISessionSource source)

    {

        if (IsNewDatabase) source.BuildSchema();

    }

    protected IDictionary<string, string> GetProperties()

    {

        MsSqlConfiguration config = MsSqlConfiguration.MsSql2005;

        config.ConnectionString.FromConnectionStringWithKey(“MYDBKEY”);

        config.ShowSql();

        config.UseOuterJoin();

        return config.ToProperties();

    }

    #endregion

}

A quick note here: We told SQLServerSessionSourceConfiguration to use a connection string from the app settings file (Web.Config) with a key of “MYDBKEY” This will be important later.

IUnitOfWork

public interface IUnitOfWork : IDisposable

{

    void Initialize();

    void Commit();

    void Rollback();

}

INHibernateUnitOfWork

public interface INHibernateUnitOfWork : IUnitOfWork

{

    ISession CurrentSession { get; }

}

NHibernateUnitOfWork

public class NHibernateUnitOfWork : INHibernateUnitOfWork

{

    private ITransaction _transaction;

    private bool _isDisposed;

    private readonly ISessionSource _source;

    private bool _isInitialized;

    public NHibernateUnitOfWork(ISessionSource source)

    {

        _source = source;

    }

    public void Initialize()

    {

        should_not_currently_be_disposed();

        CurrentSession = _source.CreateSession();

        begin_new_transaction();

        _isInitialized = true;

    }

    public ISession CurrentSession { get; private set; }

    public void Commit()

    {

        should_not_currently_be_disposed();

        should_be_initialized_first();

        _transaction.Commit();

        begin_new_transaction();

    }

    private void begin_new_transaction()

    {

        if (_transaction != null)

        {

            _transaction.Dispose();

        }

        _transaction = CurrentSession.BeginTransaction();

    }

    public void Rollback()

    {

        should_not_currently_be_disposed();

        should_be_initialized_first();

        _transaction.Rollback();

        begin_new_transaction();

    }

    private void should_not_currently_be_disposed()

    {

        if (_isDisposed) throw new ObjectDisposedException(GetType().Name);

    }

    private void should_be_initialized_first()

    {

        if (!_isInitialized) throw new InvalidOperationException("Must initialize (call Initialize()) on NHibernateUnitOfWork before commiting or rolling back");

    }

    public void Dispose()

    {

        if (_isDisposed || !_isInitialized) return;

        _transaction.Dispose();

        CurrentSession.Dispose();

        _isDisposed = true;

    }

}

IRepository

public interface IRepository

{

    void Save<ENTITY>(ENTITY entity)

        where ENTITY : DomainEntity;

    ENTITY Load<ENTITY>(Guid id)

        where ENTITY : DomainEntity;

    IQueryable<ENTITY> Query<ENTITY>()

        where ENTITY : DomainEntity;

    IQueryable<ENTITY> Query<ENTITY>(IDomainQuery<ENTITY> whereQuery)

        where ENTITY : DomainEntity;

    void Delete<ENTITY>(ENTITY entity);

    void DeleteAll<ENTITY>();

}

NHibernateRepository

public class NHibernateRepository : IRepository

{

    private readonly INHibernateUnitOfWork _unitOfWork;

    public NHibernateRepository(INHibernateUnitOfWork unitOfWork)

    {

        _unitOfWork = unitOfWork;

    }

    public void Save<ENTITY>(ENTITY entity) where ENTITY : DomainEntity

    {

        _unitOfWork.CurrentSession.SaveOrUpdate(entity);

    }

    public ENTITY Load<ENTITY>(Guid id) where ENTITY : DomainEntity

    {

        return _unitOfWork.CurrentSession.Load<ENTITY>(id);

    }

    public IQueryable<ENTITY> Query<ENTITY>() where ENTITY : DomainEntity

    {

        return _unitOfWork.CurrentSession.Linq<ENTITY>();

    }

    public IQueryable<ENTITY> Query<ENTITY>(IDomainQuery<ENTITY> whereQuery) where ENTITY : DomainEntity

    {

        return _unitOfWork.CurrentSession.Linq<ENTITY>().Where(whereQuery.Expression);

    }

    public void Delete<ENTITY>(ENTITY entity)

    {

        _unitOfWork.CurrentSession.Delete(entity);   

    }

    public void DeleteAll<ENTITY>()

    {

        var query = String.Format("from {0}", typeof(ENTITY).Name);

        _unitOfWork.CurrentSession.Delete(query);   

    }

}

DomainEntity

Note: I put both of these classes in my Core.Domain namespace, also XML comments are in Source Repository

public class DomainEntity : IEquatable<DomainEntity>

{

    public virtual Guid ID { get; set; }

    public virtual bool Equals(DomainEntity other)

    {

        if (ReferenceEquals(null, other)) return false;

        if (ReferenceEquals(this, other)) return true;

        return other.ID.Equals(ID);

    }

    public override bool Equals(object obj)

    {

        if (ReferenceEquals(null, obj)) return false;

        if (ReferenceEquals(this, obj)) return true;

        if (obj.GetType() != GetType()) return false;

        return Equals((DomainEntity)obj);

    }

    public override int GetHashCode()

    {

        return ID.GetHashCode();

    }

    public static bool operator ==(DomainEntity left, DomainEntity right)

    {

        return Equals(left, right);

    }

    public static bool operator !=(DomainEntity left, DomainEntity right)

    {

        return !Equals(left, right);

    }

}

IDomainQuery

public interface IDomainQuery<ENTITY>

    where ENTITY : DomainEntity

{

    Expression<Func<ENTITY, bool>> Expression { get; }

}

FubuSamplePersistenceModel

namespace FubuSample.Core.Domain.Persistence

{

    public class FubuSamplePersistenceModel : PersistenceModel

    {

        public FubuSamplePersistenceModel()

        {

            addMappingsFromThisAssembly();

        }

    }

}

Now that we have all the puzzle pieces in place we need to hook them up and make them do some work. Open up FubuSampleWebRegistry

And add the following code:

protected override void configure()

{

    ForRequestedType<ISessionSourceConfiguration>().AsSingletons()

        .TheDefault.Is.OfConcreteType<SQLServerSessionSourceConfiguration>();

    ForRequestedType<ISessionSource>().AsSingletons()

        .TheDefault.Is.ConstructedBy(ctx =>

                                     ctx.GetInstance<ISessionSourceConfiguration>()

                                         .CreateSessionSource(new FubuSamplePersistenceModel()));

    ForRequestedType<IUnitOfWork>().TheDefault.Is.ConstructedBy(ctx => ctx.GetInstance<INHibernateUnitOfWork>());

    ForRequestedType<INHibernateUnitOfWork>().CacheBy(InstanceScope.Hybrid)

        .TheDefault.Is.OfConcreteType<NHibernateUnitOfWork>();

    ForRequestedType<IRepository>().TheDefault.Is.OfConcreteType<NHibernateRepository>();

}

With a little luck and all of our mad skills, we should be able to talk to the database now. So we need to plumb our simple product object up to talk to NHibernate. We will do this with a mapping file, and since we are using FluentNHibernate we can do this strongly typed.

Make the following modifications to Product: Extend DomainEntity and get rid of Id Property, it is inherited

public class Product : DomainEntity

{

    public virtual string Name { get; set; }

    public virtual string Description { get; set; }

}

Add mapping file for Product:

namespace FubuSample.Core.Domain.Mapping

{

    public class ProductMap : ClassMap<Product>

    {

        public ProductMap()

        {

            Id(e => e.ID).GeneratedBy.GuidComb();

            Map(p => p.Name);

            Map(p => p.Description);

        }

    }

}

You may also want to setup your connection string at this point in the Web.Config file, mine looks like this:

<add name="MYDBKEY" connectionString="Data Source=LOCALHOST;initial catalog=FubuSample;Integrated Security=SSPI;" providerName="System.Data.SqlClient" />

I also created an empty database in my local SQL Server instance called “FubuSample” And then I went back to SQLServerSessionSourceConfiguration and changed the value of IsNewDatabase to return true. This will create the schema for the database when the application first runs. There is a multitude of different ways that we can handle this, but this was easy for the tutorial purposes.

Next we will add a behavior to our core project and tell FubuMVC to apply that behavior to all or our ControllerActions.

Create a class named “access_the_database_through_a_unit_of_work” in your Core.Web.Behaviors namespace. The contents will look like this:

public class access_the_database_through_a_unit_of_work : IControllerActionBehavior

{

    private readonly IUnitOfWork _unitOfWork;

    public access_the_database_through_a_unit_of_work(IUnitOfWork unitOfWork)

    {

        _unitOfWork = unitOfWork;

    }

    public IControllerActionBehavior InsideBehavior { get; set; }

    public IInvocationResult Result { get; set; }

    public OUTPUT Invoke<INPUT, OUTPUT>(INPUT input, Func<INPUT, OUTPUT> func)

        where INPUT : class

        where OUTPUT : class

    {

        _unitOfWork.Initialize();

        try

        {

            var output = InsideBehavior.Invoke(input, func);

            Result = InsideBehavior.Result;

            _unitOfWork.Commit();

            return output;

        }

        catch

        {

            _unitOfWork.Rollback();

            throw;

        }

        finally

        {

            _unitOfWork.Dispose();

        }

    }

}

Now to tell FubuMVC what to do, open up Global.asax.cs or your Bootstrapper, wherever you are doing the configuration of FubuMVC. In this project we are doing it in Global.asax.cs Add a new behavior to the section that starts with “x.ByDefault.EveryControllerAction” so it looks like this:

x.ByDefault.EveryControllerAction(d =>

   {

       d.Will<execute_the_result>();

       d.Will<access_the_database_through_a_unit_of_work>();

   });

The last thing we will do is open up HomeController and add this code above the Index action:

private IRepository _repository;

public HomeController(IRepository repository)

{

    _repository = repository;

}

I also modified the Index action to go ahead and create some database values before we query for them just so we can test this thing. (I only did this for the tutorial, I swear) So modify the Index action to look like this:

public IndexViewModel Index(IndexSetupViewModel inModel)

{

    var prod1 = new Product {Name = "TestProduct1", Description = "This is a test product"};

    _repository.Save(prod1);

    var prod2 = new Product {Name = "TestProduct2", Description = "This is a test product"};

    _repository.Save(prod2);

    var outModel = new IndexViewModel();

    var productList = _repository.Query<Product>();

    outModel.Products = productList.ToList().Select(x => new ProductDisplay(x));

    return outModel;

}

Now with you should be able to run your web app and browse to /home and all this will be executed and you will be on your way to creating a whole bunch of persist able objects for use with your FubuMVC app.

As always, feedback is welcome.

• FubuMVC From Scratch Part 1 – Basic project structure setup
• FubuMVC From Scratch Part 2 – FubuMVC configuration and Controller setup

Preparing for our View

Another founding principal of FubuMVC is to have little to no logic in the View, no logic is preferred. So when we add .aspx pages, we will delete the code behind files since we won’t be using them. We will need another file in our Views folder named “View_Page_Type_Declarations.cs” We will declare all of our View Pages in this file.

This file looks like this at the moment:

using FubuSample.Core.Web.Controllers;

public class HomeIndexView : FubuSamplePage<IndexViewModel> { }

You will notice that we don’t have a FubuSamplePage class anywhere in our project. So let’s go ahead and add the 3 main classes all of our Views and controls will inherit from.

We also need to add a reference to System.Web to our FubuSample.Core project, so do that quickly before we move on.

Page Interface

We need to create an interface that all of our pages will implement to give us some standard results. Our interface just says that every page that implements IFubuSamplePage will provide an object that is our Model or ViewModel. This class just goes in the FubuSample.Core.Web folder.

public interface IFubuSamplePage : IFubuViewWithModel

{

    object Model { get; }

}

The rest of these classes will be created in the Core.Web.WebForms folder. These pages implement our interface as well as a FubuMVC View interface so the framework can work with our view pages.

FubuSamplePage

public class FubuSamplePage<MODEL> : Page, IFubuSamplePage, IFubuView<MODEL>

    where MODEL : ViewModel

{

    public void SetModel(object model)

    {

        Model = (MODEL)model;

    }

    public ViewModel GetModel()

    {

        return Model;

    }

    public MODEL Model { get; set; }

    object IFubuSamplePage.Model { get { return Model; } }

}

FubuSampleUserControl

public class FubuSampleUserControl<MODEL> : UserControl, IFubuSamplePage, IFubuView<MODEL>

    where MODEL : class

{

    public void SetModel(object model)

    {

        Model = (MODEL)model;

    }

    public object GetModel()

    {

        return Model;

    }

    public MODEL Model { get; set; }

    object IFubuSamplePage.Model { get { return Model; } }

}

FubuSampleMasterPage

public class FubuSampleMasterPage : MasterPage, IFubuSamplePage

{

    object IFubuSamplePage.Model { get { return ((IFubuSamplePage) Page).Model; } }

    public ViewModel Model { get { return ((IFubuSamplePage) Page).Model as ViewModel; } }

    public void SetModel(object model)

    {

        throw new System.NotImplementedException();

    }

}

Once we have these three classes all setup we are ready to start adding some views!

Creating a Site.Master

Let’s go ahead and create a Site Master file so we have a place to display our content once we create it. First though, we need to declare our SiteMasterView in view_page_type_declarations, so add this line to that file:

public class SiteMasterView : FubuSampleMasterPage { }

Add another folder to the Views folder in our Web project, named Shared. Inside this folder create a new Site Master File. I am changing a few things in this generated file

• Rename the ID for the main ContentPlaceHolder to be “MainContent” instead of ContentPlaceHolder1.
• Delete the code behind files
• Modify the page declaration like so:
• Delete “AutoEventWireup="true"
• Delete CodeBehind=”Site.master.cs”
• Change Inherits to “SiteMasterView”

We can customize this further later on if we want to.

Adding the Corresponding View for our HomeController

Since we have our controller ready to go, lets setup a View in our Web project. In the Views folder add another folder named Home. Inside this folder create a new .aspx web form named Index (Index corresponds with our method name in our controller)

Once this file is created, go ahead and delete the two code behind files, and all the html code that was generated.

Next modify the page declaration in Index.aspx from:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="FubuSample.Web.Views.Home.Index" %>

TO:

<%@ Page Inherits="HomeIndexView" MasterPageFile="~/Views/Shared/Site.Master" %>

Now instead of cramming a bunch of logic into our view we will use some of FubuMVC’s built in Html helper magic to make this simple. Add the following Html/C# code to your Index.aspx

<asp:Content ID="indexContent" ContentPlaceHolderID="MainContent" runat="server">

<div>

    <div>

         <%= this.RenderPartial().Using<ProductInfo>().ForEachOf(Model.Products) %>

    </div>

</div>

</asp:Content>

What we are doing here is saying that For Each Product in our list Products render part of the view using a UserControl called ProductInfo, let’s make this control now.

Creating ProductInfo User Control

Back to View_page_type_declarations real quick so we can define our UserControl. Add the following line to your view page type declarations file:

public class ProductInfo : FubuSampleUserControl<ProductDisplay> { }

Now add a new user control to the Views/Shared folder named ProductInfo, same as before delete the code behind files and make your ascx file look like this:

<%@ Control Language="C#" Inherits="ProductInfo" %>

<h2><%= Model.Name %></a></h2>

<div><%= Model.Description %></div>

We are almost ready to see if our labor has produced any fruit. But we need to modify our Web.config file. I am getting tired so I am not going to go in depth on what all has to change, I just copied the AltOxite Web.Config and modified what needed to be changed. Here are the results:

<?xml version="1.0" encoding="UTF-8"?>

<configuration>

  <appSettings>

  </appSettings>

  <connectionStrings />

  <system.web>

    <httpModules>

      <add name="UrlRoutingModule" type="System.Web.Routing.UrlRoutingModule, System.Web.Routing, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

    </httpModules>

    <compilation debug="true" defaultLanguage="C#">

      <assemblies>

        <add assembly="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089" />

      </assemblies>

    </compilation>

    <authentication mode="Forms">

      <forms loginUrl="~/login" defaultUrl="~/"/>

    </authentication>

    <pages>

      <namespaces>

        <add namespace="FubuSample.Core.Web" />

        <add namespace="FubuSample.Core.Web.Controllers" />

        <add namespace="FubuSample.Web" />

        <add namespace="FubuMVC.Core.View" />

        <add namespace="FubuMVC.Core.Html" />

        <add namespace="FubuMVC.Core.Html.Expressions" />

      </namespaces>

    </pages>

  </system.web>

  <system.codedom>

    <compilers>

      <compiler language="c#;cs;csharp" extension=".cs" warningLevel="4" type="Microsoft.CSharp.CSharpCodeProvider, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

        <providerOption name="CompilerVersion" value="v3.5" />

        <providerOption name="WarnAsError" value="false" />

      </compiler>

    </compilers>

  </system.codedom>

  <!-- 

        The system.webServer section is required for running ASP.NET AJAX under Internet

        Information Services 7.0.  It is not necessary for previous version of IIS.

    -->

  <system.webServer>

    <validation validateIntegratedModeConfiguration="false" />

    <modules runAllManagedModulesForAllRequests="true">

      <remove name="UrlRoutingModule" />

      <add name="UrlRoutingModule" preCondition="managedHandler" type="System.Web.Routing.UrlRoutingModule, System.Web.Routing, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

    </modules>

    <handlers>

      <remove name="WebServiceHandlerFactory-ISAPI-2.0-64" />

      <remove name="WebServiceHandlerFactory-ISAPI-2.0" />

      <remove name="WebServiceHandlerFactory-Integrated" />

      <remove name="SSINC-shtml" />

      <remove name="SSINC-stm" />

      <remove name="SSINC-shtm" />

      <remove name="SimpleHandlerFactory-ISAPI-2.0-64" />

      <remove name="SimpleHandlerFactory-ISAPI-2.0" />

      <remove name="SimpleHandlerFactory-Integrated" />

      <remove name="SecurityCertificate" />

      <remove name="PageHandlerFactory-ISAPI-2.0-64" />

      <remove name="PageHandlerFactory-ISAPI-2.0" />

      <remove name="HttpRemotingHandlerFactory-soap-ISAPI-2.0-64" />

      <remove name="HttpRemotingHandlerFactory-soap-ISAPI-2.0" />

      <remove name="HttpRemotingHandlerFactory-soap-Integrated" />

      <remove name="HttpRemotingHandlerFactory-rem-ISAPI-2.0" />

      <remove name="HttpRemotingHandlerFactory-rem-ISAPI-2.0-64" />

      <remove name="HttpRemotingHandlerFactory-rem-Integrated" />

      <remove name="ASPClassic" />

      <remove name="AboMapperCustom-78953" />

      <!--<remove name="PageHandlerFactory-Integrated" />-->

      <add name="UrlRoutingHandler" preCondition="integratedMode" verb="*" path="UrlRouting.axd" type="System.Web.HttpForbiddenHandler, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

    </handlers>

    <defaultDocument>

      <files>

        <remove value="index.html" />

        <remove value="index.htm" />

        <remove value="Default.htm" />

        <remove value="Default.asp" />

        <remove value="iisstart.htm" />

        <remove value="default.aspx" />

      </files>

    </defaultDocument>

  </system.webServer>

</configuration>

I will tell you some of the more important aspects though:

• Add UrlRoutingModule to <httpModules> under <system.web>
• Add all the namespaces your projects uses be default under <namespaces> inside <pages> under <system.web>

With any luck, this should work when you debug it. Using the integrated Visual Studio Web server you will have to manually type “/Home” at the end of your localhost address.

You can find some information on running a FubuMVC project with the Visual Studio Web server out on the wiki

Goal for this part of the series: Get a View up and running in our sample app.

 We will need to have several things in our projects before we can make our FubuSample app come to life:

• Web Registry – This is how we tell StructureMap what and how to build some things we need.
• Bootstrapper – This kick starts FubuMVC
• Global.asax – This is where all of our conventions and overrides for how we want things to work go.

Web Registry

First up is the web registry, go ahead and add a class to the FubuSample.Web project named FubuSampleWebRegistry. This class should extend the Registry class found in StructureMap.Configuration.DSL. You also need to generate a default (empty) constructor. We will use this to put all of our configuration in later as we expand on this project.

using StructureMap.Configuration.DSL;

namespace FubuSample.Web

{

    public class FubuSampleWebRegistry : Registry

    {

        public FubuSampleWebRegistry()

        {

        }

    }

}

Bootstrapper

Add another class to the Web project, named Bootstrapper. This class will implement StructureMap’s IBootstrapper interface, which is just a public void method named BootstrapStructureMap(). The code for this class is mostly copied from the AltOxite sample, but let’s take a look at it and see what is going on. Also, you will need to add a reference to System.Web.Routing for this step.

public class Bootstrapper : IBootstrapper

    {

        private static bool _hasStarted;

        public void BootstrapStructureMap()

        {

            ObjectFactory.Initialize(x =>

            {

                x.AddRegistry(new FrameworkServicesRegistry());

                x.AddRegistry(new FubuSampleWebRegistry());

                x.AddRegistry(new ControllerConfig());

            });

            ObjectFactory.AssertConfigurationIsValid();

            setup_service_locator();

            apply_action_conventions();

            initialize_routes();

        }

First up we have our interface method BootstrapStructureMap(). This method is only doing a few things as we can see. First up we are Initializing StructureMap with a call to ObjectFactory.Initialize. In this call we are adding a new FrameworkServicesRegistry, our own FubuSampleWebRegistry, and ControllerConfig registry. Registry items 1 and 3 both come from the FubuMVC framework, and we just added the FubuSampleWebRegistry.

Once this is done we are making calls to some of our own private methods.

private static void setup_service_locator()

{

    ServiceLocator.SetLocatorProvider(() => new StructureMapServiceLocator());

}

setup_service_locator is simply telling the ServiceLocator who the IOC provider is for this project.

private static void initialize_routes()

{

    ObjectFactory.GetInstance<IRouteConfigurer>().LoadRoutes(RouteTable.Routes);

}

initialize_routes() is grabbing the configured instance of IRouteConfigurer from FubuMVC and is loading up the Route Table from the System.Web.Routing class.

private static void apply_action_conventions()

{

    var fubuConfiguration = ObjectFactory.GetInstance<FubuConfiguration>();

    var actionConventions = ObjectFactory.GetAllInstances<IFubuConvention<ControllerActionConfig>>();

    fubuConfiguration.GetControllerActionConfigs().Each(actionConfig =>

        actionConventions.Each(conv =>

            conv.Apply(actionConfig)));

}

apply_action_conventions is a recent addition to FubuMVC. What this little gem does is add the application of conventions defined on action configs

into the Bootstrapper.  After StructureMap is configured, the

conventions for ControllerActionConfig are applied (making whatever

changes are appropriate per the convention(s)) and the app is then ready

to run.

And finally two methods to wrap up this class. These two methods are helper methods.

public static void Restart()

{

    if (_hasStarted)

    {

        ObjectFactory.ResetDefaults();

    }

    else

    {

        Bootstrap();

        _hasStarted = true;

    }

}

    public static void Bootstrap()

    {

        new Bootstrapper().BootstrapStructureMap();

    }

}

Before we move onto the Global.asax file, we need to create a class in FubuSample.Core.Web namespace called “ViewModel”. The code for this class is below, every Input and Output ViewModel we use in our controllers will inherit from this class, so we put properties in here that are global or site wide.

public class ViewModel

{

    public string SiteName { get; set; }

    public string LanguageDefault { get; set; }

    public string SEORobots { get; set; }

}

Global.Asax

The next thing our web app is going to need is a Global.asax file. Inside this file is where we will do the majority of our FubuMVC configuration. So go ahead and add a Global.asax file to your FubuSample.Web project.

This file will have a lot of methods in it once you open it, the only one we are really interested in at this point is the Application_Start method. In order to keep this simple, we will only add the absolute minimum things required to make FubuMVC work. There are several things we can do with FubuMVC inside the ControllerConifg.Configure expression, we can setup Using Conventions and ActionConventions, these are site wide conventions that will apply to every item of their respective application.

Initially we just need to tell the app that every controllerAction will Execute the Result and where to find our controllers we will make.

protected void Application_Start(object sender, EventArgs e)

{

    ControllerConfig.Configure = x =>

     {

         x.ByDefault.EveryControllerAction(d => d

             .Will<execute_the_result>());

         x.AddControllersFromAssembly.ContainingType<ViewModel>(c =>

            {

                c.Where(t => t.Namespace.EndsWith("Web.Controllers")

                             && t.Name.EndsWith("Controller"));

                c.MapActionsWhere((m, i, o) => true);

            });

     };

    Bootstrapper.Bootstrap();

}

At this point we have done the minimum required configuration to use FubuMVC. What we need to do next is create a simple object in our domain and hook a controller and a view up to it. I created a simple object named Product in my FubuSample.Core.Domain namespace.

public class Product

{

    public Guid Id { get; set; }

    public string Name { get; set; }

    public string Description { get; set; }

}

As you can see, this class is very simple, but that is all we need for now.

Setting up a Controller

Let’s create a class in our Core.Web.Controllers folder named “HomeController”. One of the key principals for FubuMVC is the Thunderdome Principal, or OMIOMO, One Model In One Model Out. So in order to make our controller function we will need to add a method named the same as our View which will be Index. Now our Index method should take an InputViewModel in the constructor and should return an OutputViewModel. We will need to make our respective ViewModel classes once we setup our controller action.

Our Index action looks like this at the moment:

public IndexViewModel Index(IndexSetupViewModel inModel)

{

    return new IndexViewModel();

}

Now we need to create two ViewModel derivatives, one for our input, and one for our output. Now all we are attempting to do with our Home/Index view is to show a list of products. So we will make our output viewmodel, IndexViewModel have a public IEnumerable<ProductDisplay> property.

public class IndexSetupViewModel : ViewModel

{

}

[Serializable]

public class IndexViewModel : ViewModel

{

    public IEnumerable<ProductDisplay> Products { get; set; }

}

You probably already noticed that I did not setup my list of products to use the domain object named Product that we just created. Instead I am using a display model named ProductDisplay. For the purpose of this sample we probably could have just used Product, but I really don’t like to pass domain objects directly to the view unless absolutely necessary. So create a new class named ProductDisplay in the DisplayModels folder in your Core.Web folder. Your class should look like this when it is done.

public class ProductDisplay

{

    public ProductDisplay(Product product)

    {

        Name = product.Name;

        Description = product.Description;

    }

    public string Name { get; set; }

    public string Description { get; set; }

}

So we now have our ProductDisplay class but we haven’t populated our IEnumerable on our IndexViewModel, so let’s make a hard coded list of products in our IndexAction. Our modified IndexAction now looks like this, I know some of the code is ugly with building our list, but hey this is a sample.

public IndexViewModel Index(IndexSetupViewModel inModel)

{

    var outModel = new IndexViewModel();

    var productList = new List<ProductDisplay>();

    productList.Add(new ProductDisplay(new Product { Name = "TestProduct1", Description = "This is a test product"}));

    productList.Add(new ProductDisplay(new Product { Name = "TestProduct2", Description = "This is a test product"}));

    productList.Add(new ProductDisplay(new Product { Name = "TestProduct3", Description = "This is a test product"}));

    outModel.Products = productList;

    return outModel;

}

This post has gotten long enough and there are a few more steps required to get our View running, so I am starting a new post. Check back real soon, I will finish it tonight.

As always, I do these posts as much for discussion as anything, so if I did something wrong, or something you have a better way of doing, please let me know.

-Ryan

Hardware

I have two machines for doing dev work, one is my laptop the other my workstation at the office. Yes, this is going to turn into a little bit of a brag session for a moment, but hey, we are computer nerds.

Workstation Specs

• Dell Precision Workstation T5400
• 2 x Intel Quad Core 2.50 GHz
• 8GB DDR2 Memory
• 3 x 15k 300GB SAS Hard Drives (Raid 5)
• NVidia Quadro FX1700 512MB video card
• 2 x Dell 24” Ultrasharp Monitors
• Windows Server 2008 Standard 64-bit as my Workstation OS

Laptop Specs

• Lenovo T500 Notebook
• Intel Core2 Duo – 2.53 GHz
• 4 GB DDR3 Memory
• 200GB 7200 rpm Hard Drive
• ATI Mobility Radeon 3650 256MB
• 15.4” Wide screen display
• Windows Vista Business x64 OS

The specs could be a little overkill on my workstation, but man is it fast! It literally only takes 2 seconds for Visual Studio to start up.

Development Tools

I am using the same tools on both machines so I will only list them once here:

IDE and Plug-ins

• Visual Studio 2008 + SP1
• Resharper – No explanation needed here really, this is the ultimate must have tool for VS.
• AutoHotKey – Not really a plug-in per say but this thing is great. I have a little BDD naming script that turns spaces into underscore which came from Jean-Paul Boodhoo

Version Control

I am not experimenting with anything new on this front. I am a convert to subversion away from TFS so these are pretty standard.

• Tortoise SVN – Must have Subversion tool for windows
• SVN-Monitor – A very nice complement to Tortoise SVN. SVN-Monitor is easy to setup and configure, it then automatically watches any source/repository and working copy you tell it to and it alerts you when there are changes, updates, or un-versioned files that need to be updated or committed. One of the other great things, is it sits on top of Tortoise SVN so it uses all of your ignore patterns from Tortoise. You can also monitor a source for changes based on all types of criteria.

Unit Testing

• NUnit – Of course
• SpecUnit.Net – I have been dabbling with BDD style spec’s and tests lately and I am trying this out, verdict yet to be determined. It was easy to get up and going with though.

Continuous Integration

Like many others, I am also using TeamCity. You can’t beat the price and it is aesthetically very appealing. Oh, did I mention that it just works and works well and it’s FREE!

The past month has been very hectic as I was wrapping up loose ends at my previous engagement. I started my new gig last week, but I have pretty much been building furniture and getting computer and server ready to go. The next few weeks will also be challenging as I start to assemble the team of people that is going to make this all happen.

How does this tie into the practice of Elegant Coding? Funny you should ask that, the current infrastructure they are built on is a maintenance nightmare so project number one is to completely redo their entire site infrastructure in ASP.Net, and yes it will be MVC based, but not ASP.Net MVC. I am going to architect and build their new infrastructure from the ground up on FubuMVC. So expect a lot more posts from me on FubuMVC and I may even have questions for you dear reader.

Side Note: I just finished deploying to production a small scale site built on FubuMVC, and it ROCKS! There is going to be some stuff that needs to be tweaked out and added to the core, but overall, fully functional MVC framework.

I hope I haven’t bored you with too much personal information, but I have to go. (I have several FubuMVC posts stacked up in my queue)

-Ryan

Upcoming Topics:

Setting up the Bootstrapper and Global.asax
Creating Models, Views, and Controllers with FubuMVC
Adding database connectivity
Using HTML helpers

I will most likely cross post these to the FubuMVC wiki once they are refined and final, so if any of you have comments, ways to do things better, or find things I should explain or do differently, please leave me a comment.

Before You Begin

Before you start your setup, head over to the FubuMVC website, grab the latest version of the source and compile it. This way you will have the references I am using below.

Project Setup

The first thing you need to do is go setup your project and folder structure. I am not going to detail the process here, because most people have thier own preferences and naming conventions but for my sampl I will be using the following folder structure:

• FubuSample
  • lib
  • src
    • FubuSample.Core
    • FubuSample.Web
    • FubuSample.Tests
    • FubuSample.sln

You may have noticed above that I am using three different projects: FubuSample.Core (class library), FubuSample.Web (Web Application) and FubuSample.Tests (class library). Setup these projects and we will move on, mine look like this:

Got it, great. Next thing I am going to do is add references required for FubuMVC to work. I added the following references to my projects:

1. 1. FubuSample.Core
      1. FubuMVC.Core
      2. FubuMVC.Container.StructureMap
      3. StructureMap
      4. Microsoft.Practices.ServiceLocation
   2. FubuSample.Web
      1. FubuSample.Core
      2. FubuMVC.Core
      3. FubuMVC.Container.StructureMap
      4. StructureMap
      5. Microsoft.Practices.ServiceLocation
   3. FubuSample.Tests
      1. FubuSample.Core
      2. FubuSample.Web
      3. FubuMVC.Core
      4. FubuMVC.Container.StructureMap
      5. NUnit.Framework
      6. Rhino.Mocks
      7. StructureMap

Once all the references are are in your 3 projects, you are almost ready to get going. The next thing to do is to setup a basic folder structure inside your projects. In the web project I added a Views folder and a Content folder; under the content folder I added seperate folders for images, scripts and stylesheets. Moving on to the Core project I added top level folders for  Config, Domain, and Web. Under the Web folder I also added folders named Controllers, DisplayModels, Html, and WebForms. My folder structure now looks like this for my projects:

I should also mention that the folder structure / layout I am using here, is following the Default conventions for FubuMVC, this can be customized to suit your needs however, but that is another post.

Next up, setting up the Bootstrapper, Global.asax and Web.config for FubuMVC

I can tell you this though, I am going to be managing and developing the software development side of a company that is in startup mode. We will be primarily doing Asp.Net Web Apps, MVC style. This is a little scary for me as I have been doing Win Forms development for the past 5 years, but I have kept my fingers in a lot of web stuff. I am also thinking we are going to build on top of FubuMVC vs. Asp.Net MVC . This is primarily because I am wanting to get involved with the development of FubuMVC as an Open Source Project this year. I have several pages of documentation on getting started with FubuMVC from scratch, I am sanitizing and creating posts / articles out of them as I have time.

I am really excited about this new job, I have a good feeling that it is going to open up lots of new opportunities for me to stay involved with the Alt.Net community, and maybe I will get to see more of you more often.

p.s. I will post more details if/when I am able.

Personally I think that university Computer Science programs are a
joke (at least in the U.S., can’t speak for other countries). In my 4
years at the U. of Toledo I think I had 5 classes that taught me
something relevant to real world software development. The words
"unit test" were never uttered in my classrooms <shudder>. College
grads take this education into workplace and have no idea how to
practically use the skills that they have learned.

As far as I know there is nowhere you can go to get a formal education
on advanced software development topics. User groups and conferences
are great, but there are tons of devs that don’t go to those things.
I’m talking about classes that teach you software development
principles like what unit testing is, how to do test-driven
development, what SOLID is, domain driven design, etc., or maybe more
technology specific things like how to use NHibernate, how to optimize
ASP .NET applications, etc.

I have to say that I wholeheartedly agree with this statement. In my 7 years in college I had never heard of Unit Testing, SOLID principles, etc. It wasn’t until I began to use the basic building blocks I was taught in daily software development that I realized, “Hey, there is a better way to do this stuff.” Then I found the Alt.Net community and began further educating myself on these topics. The most important part of what I just discussed is, “I educated myself.” In large part this is the one single thing that separates a great developer from a programmer, initiative. You have to want to continuously improve and hone your skills in order to become a great developer.

Why does this education breakdown exist?

I have my opinions on why this education breakdown exists and I would love to hear yours as well. I think one of the biggest reasons this happens is because Computer Science programs tend grow from within themselves. I mean obviously if you have been in college for 12 years and have a PhD in Computer Science then you are an expert software developer, right? I say WRONG; It becomes the blind leading the blind in a redundant cycle over and over. Most PhD Computer Science professors are what I would call “Research Oriented.” They go through their entire educational career never writing any real business software. They focus on research projects, and exercises that are only important in school. They are not forced into dealing with the pain and struggle that full-time normal developers encounter each and every day. The dynamics of developing software with a team and a boss, and their bosses boss, not to mention timelines and financial constraints. These “Expert” professors hold the students well being (grades) in their hands, and mandate that you do it their way or you fail. Nobody wants to fail so they do it their way, and the cycle continues.

Some professors may actually come from the industry, but many only join academia in retirement. More likely than not, they were not a developer when they retired, they had become “successful” and moved into management. Either way, it has probably been a while since they were in the trenches developing software on a daily basis. Compounding the problem are advances in language, methods, and principles. The software they wrote a long time ago was in different languages than what is taught at colleges and universities today. They are now learning new languages so they can teach them to students. They are so focused on the new languages that they neglect the principles that are language independent like Unit Testing, SOLID principles, ORM’s, TDD, etc.

What can we do to stop the cycle?

I believe we have to take action as individuals inside the community to change the path that our future team members are on as soon as possible. Each year, the cycle perpetuates itself.

One of the ways we can do this within our own teams is to have “The Way”. Inside our development team we have “The Way”, which is the way we develop software. We practice TDD, Unit Testing, DDD, we adhere to SOLID principles, we use NHibernate. That is “The Way” we develop software. Now this puts a burden on the company, and on the seasoned developers to spend time with new team members and teach them how to do these things. This does two things: it helps develop a team working environment and hopefully instills in them personal initiative to continuously improve their software skills.

Another way that I am currently doing is to get involved with your local college, community college, or University and teach some classes. Remember, the professor’s way is the students way. I currently teach classes at our local university and these are the exact things I want to engrain in the minds of these students. Next week I begin teaching an upper level Systems Analysis and Design class. During the semester we will design and begin developing an Open Source Learning Management System,will make the students learn and practice concepts such as pairing, unit testing, SOLID principles and practice using an ORM. They will create this project in C#, as that is my language of choice, but will understand that these tools and concepts are not tied to one language.

You may or may not be able to teach a class at your local university but I would be highly surprised if you could not, at the very least, give a talk at a “Computer Science Club” meeting about these things in an evening.

I know I do not have all the answers, but this is the best way for me to make a difference. I would like to hear opinions and other things we can do to help alleviate this breakdown in education of our future employees and teammates.

-Ryan