Last week I went to a customer that is about to release a quite big web application composed by various modules and services. I worked with them to resolve some issues and close the development cycle.

The thing that let me a little bit disappointed is the way they work: they don’t have unit tests (and this sadly, in Italy, is quite normal) so to “test” the application they have to run it and navigate to the interested page.

The problem is that from the moment that I press F5 it takes about 2 minutes to the moment that the Login page is available, to this adds a bunch of seconds to do the login and another bunch to arrive to  the page that I want to test (in total about 3 minutes).

Let’s do some computation:

They are in the final phase of development so they do little modifications to the code and some bug fixing, so the F5 key is pressed a lot of times during the day, let’s say 50-60 times a day. So:

3 minutes * 50 times = 150 minutes = 2,5h

This mean about 2,5 hours a day spent in doing nothing

Without introducing unit tests that in this final stage will be a loss of time, what about a script that speed-up the Build&Run phase? And maybe an “#ifdef debug” then don’t ask me for username and password but go directly to  the home page? And if we take off from the main solution the projects that are not subjected to modification? And if we will do pair programming so I can avoid to press F5 if my pair see that I make a visible mistake?

These are only some of little actions that helps the team to save some seconds at every debug session, that in a day will be hours! 

I would like to talk about the Factory Support.

The default mode for an object registered in the configuration file to be constructed is by the new operator that calls the constructor in which, if necessary, the container inject the parameters. But sometimes we need to create an object using a factory class.

Castle support this construction mode using the Factory Support Facility that means configure it in the right way. Suppose that you need to use Windsor container to get an instance of an NHibernate Session, that, like you know, it cannot be created using the new operator but it must be constructed using a SessionFactory class.

Sometimes this SessionFactory is encapsulated in a NHibernateHelper class:

public static class NHibernateHelper
{
    private static readonly ISessionFactory sessionFactory;

    static NHibernateHelper()
    {
        Configuration cfg = new Configuration();
        cfg.Configure();
        sessionFactory = cfg.BuildSessionFactory();
    }

    public static ISession GetNewSession()
    {
        return sessionFactory.OpenSession();
    }

    // ...
}

This class has a static method GetNewSession that return a new instance of ISession. I want to use this class (and the GetNewSession method) to obtain the session using the IoC container and I want to inject this session in a repository:

public class UserRepository : IUserRepository
{
    public UserRepository(ISession session)
    {
        //...
    }
}

The only things that I need to do is to configure Castle in this way:

<castle>
    <facilities>
        <facility id="factorysupport" type="Castle.Facilities.FactorySupport.FactorySupportFacility, Castle.Microkernel" />
    </facilities>
    <components>
        <component id="session"
            type="NHibernate.ISession, NHibernate"
            factoryId="sessionFactory"
            factoryCreate="GetNewSession" />

        <component id="sessionFactory"
            type="NHibernateHelper, CodicePlastico.Samples" />

        <component id="userRepository"
            service="CodicePlastico.Samples.Repositories.IUserRepository, CodicePlastico.Samples"
            type="CodicePlastico.Samples.UserRepository, CodicePlastico.Samples" />
    </components>
</castle>

The first block (facilities) add to Windsor the necessary support to use the factory facility after that there’s the components registration:

The first (session) is the object that will be created using a factory, I specified the type (ISession) and the Id of the component that works as a factory (sessionFactory) and the method (factoryCreate) that should be called for the construction of ISession (GetNewSession).

Obviously you must register the factory class (sessionFactory component) and the IUserRepository (userRepository) using the usual syntax.

What happen when I request an object of type IUserRepository?

The container sees that the concrete type is UserRepository and see that the constructor receive an instance of ISession. Then it goes to see how to build an ISession object, and see that it needs to use the GetNewSession method of NHibernateHelper.

This is a quite useful technics to use when you cannot use the constructor to build an object but still want to use an IoC container.

Sometimes this characteristics are measurable giving just a fast look at a piece of code. Here an example: which one of this two snipped do you think is better?

Even if you can’t read the code (I applied a blur effect) you can see at a glance which one seems better.

The first contains a lot of executable path, nested if and one long method, (it smells!). The second is more linear and well-organized.

The problem with the first one is that is hard to read. Consider the following image which shows the path that my eye has to do to read them:

To read the first one I have to continually enter in a new context (code block), this because the McCabe index is quite high for this method.

This doesn’t mean that the first piece of block is absolutely better than the second, it’s just a quick evaluation based on what the code look like (remember that readability is a quality of good code).

That’s the day of the second ALT.NET Conference, if you want to join us you can take a look here (sorry the page is in Italian :-|).

The day is focused on developing a blog engine using the agile methodologies, the ASP.NET MVC, IoC and all the others things that we like.

During this days, we are planning to write some stories that we will implement at the conf, so you can help us if you want on the mailing list of italian ALT.NET movement (here).

http://testdrivendevelopment.wordpress.com/

The name speak for himself.

I don’t like stored procedure for various reasons. The main one it tight to code maintainability. If you begin with one SP you end up you application with thousand of SPs that extract data from database in multiple forms (the customers ordered by name, the customers filtered by country, filtered by company, filtered by whatever).

What happen when I need to add a new field to the customer table? A mess!

Another reason is about business logic location. In my opinion the user request "I want to view all the customers filtered by Country" is a business rule, and as a business rule I want to code that in the business layer of my application. So I don’t want to code that in T-SQL but I want to code that in a high level, object oriented, strongly typed, debuggable, testable, manageable, readable language: C#, Java,…

One of the arguments that DBA take in favor of SP is performance. Apart that I’m not so sure that the SP give more performance (read here), are performance always the most important thing?

I agree if we talk of reporting applications, or application that have a HUGE database that has to be responsive in milliseconds (automation industry for example), but most of the application are used by humans that count in seconds, not milliseconds. So performance in not a real issue, you can get the same with ORM (if it’s rightly tuned).

Maybe the solution will came when the database vendors fill the gap between application world and database world making database more abstract from the physical representation of data.

I want to think in objects not in bytes. Instead the DBA still today has to think in bytes!

I talk some months ago about T-SQL like an assembly language for database, you can read it here.

Reduce: reducing the code. It seems strange, but it is often more difficult cancelling some code than adding some new one. Adding too much code is often due to overengineering, by implementing functions that are not stricly necessay, and that do not give an additional value to the final customer. It just contribute to pollute the application, making it difficult to maintain. Therefore reduce the code dimension brings to remarkable results: simplification of codebase, ease of maintainance, and in general an improvement of performance.

Reuse: do not invent the WHEEL every time. Writing classes that can be used again or using library of third parts that already do the requested task, is a good habit. Using a class, that was already writtne, brings advantages boths in terms of realization time than in terms of debugging time (hoping that the class you are reusing is bug free…)

Recycle: it may sometime happen that a class could be reused, but it is not exactly as we need. So, sometimes by using CTRL-C, CTRL-V you just introduce duplications and polluted code. If you do some refactoring you could reuse a part of the code already written adapting it to the new application. Also in this case the advantages are a lot: the quantity of the code we are adding is lower, we avoid to create classes that are too alike (or even identical) and of course we spare time and we do not pollute.

I like this idea of the enviromentalist code, as in general all the enviromentalist attitude.

What do you think about it? Do you feel code enviromentalist?