sharp bites

git started #1. Using git with a svn server

2011-11-06T23:43:00.000+01:00

So, you already know that svn sucks and you want to switch to git because you know it's awesome, but you are stuck in a team environment of svn-zombies.

What can you do? You can try to convert all the non-deads at once... or you can use git-svn and get them into git one by one.

git-svn let's you interact with a svn server using git as your client. Some git GUIs support git svn. On Mac OSX you can use GitX(L) or SourceTree. Here is how to do it using the commandline.

To get a copy of your svn repo (assuming you have the de facto standard structure of trunk, branches and tags dirs) do:

git svn init -s http://path/to/your/svn/project

From here, use your local repo as usually, i.e. do some hacking, add your files and commit them. Rinse, repeat.

git add somefile
git commit
...

When you are ready to commit your changes, get the changes from the svn repo:

git svn rebase

and commit your changes:

git svn dcommit

That's it!

Change

2011-10-23T21:35:00.000+02:00

“You never change things by ﬁghting the existing reality. To change something, build a new model that makes the existing model obsolete.” — R. Buckminster Fuller

Becoming an Agile Manager: Transforming the Three Dysfunctions of Management

2011-04-15T22:10:00.000+02:00

A terrific talk by Diana Larsen on how to overcome 3 dysfunctional management traps: magical thinking, illusion of control and individual blame using Agile.

Setting up a ruby testing environment on Linux

2011-01-29T23:02:00.000+01:00

Now that we have setup our ruby environment on Linux, we are going to create a setup for testing purposes by adding some useful gems.

For that, we will use a feature from rvm called gemsets. A gemset is an independent setup for your environment. That means you can have many environments with a different set of gems (hence the name) installed independently on each one (even with different ruby versions).

Usually, when working on a project, you would create a gemset specific for that project, but in this case, we are going to create a gemset for practicing tdd, doing katas, coderetreats, etc. If you plan to use rvm in a serious project (which you should), please read first about rvm best practices.

A brief introduction to gemsets
For each version of ruby, rvm creates two gemsets, the default, empty gemset and the global gemset. You can list your gemsets with:

rvm gemset list

Gems that are installed to the @global gemset are shared to all other gemset for that ruby. We won't install anything here. Instead we will create our own gemset and put everything there.

Create a tdd gemset:

rvm gemset create tdd

Switch to that gemset:

rvm use gemset 1.9.2@tdd

If you want to make this your default gemset (the one that will be loaded by default) you can do that by doing:

rvm use gemset 1.9.2@tdd --default

Verify you are on the new gemset:

rvm gemset name

You should get:

tdd

Gems for testing that rock
You can install gems for your current gemset using:

gem install

To do unit testing in ruby, rspec is a great choice.

gem install rspec

To start using it, create an rspec file, like example_spec.rb inside a spec folder on the root of your project:

describe "something" do
  it "does something that passes" do
    5.should eq(5)
  end

You can then execute it by running:

rspec spec/

For a nicer, colored output, pass in the --colour flag to rspec

rspec spec/ --colour

Or create a .rspec config file on your project root (or in your home dir if you want to always use it), to tell rspec to use the colored output by default

echo "--colour" >> .rspec

Excecuting rspec by hand all the time gets boring quickly, and it turns out computers are quite good at doing tasks repeteadly, so you can instead use autotest, a cool gem from the ZenTest suite that will automagically execute your tests when you save your files.

gem install autotest

Execute it from your project root.

autotest --style rspec2 --quiet

The --style flag tells autotest to look for rspec kind of tests. The --quiet flag removes a bit of noise you probably don't care about.

If you have created the .rpec file on your project root, you can omit the style flag and autotest will still find the tests.

autotest --quiet

If you are really lazy like me, you can instruct autotest to be quiet by default by creating a .autotest file in your home:

echo "Autotest.options[:quiet] = true" >> ~/.autotest

So whatever option you want to use, let's try it. Modify your rspec file and save it. Awesome, isn't it? But wait, there is more!

We'll add a nice gem called test_notifier. This is the topping of the cake. It will notify your OS with the result of your tests.

In order to it on GNOME, we will need to install libnotify:

sudo apt-get install libnotify-bin

gem install test_notifier

Configure autotest to use test_notifier:

echo 'require "test_notifier/runner/autotest"' >> .autotest

Or add the following to your rspec/spec_helper file if you want to use it directly with rspec:

require "test_notifier/runner/spec"

Now you should get a nice notification when you save your file.

Setting up your ruby environment on Linux

2011-01-25T21:41:00.002+01:00

Here are the instructions on how to set up a ruby environment for Linux, in case you want to start playing with it.

NOTE: Don't use the packages from your distribution. They are outdated and will cause more harm than good. Use one of the methods below.

The quick and easy way
If you are planning to use Rails anyways, you can use the script from railsready.
It will install rails, passenger, and a shitload dependencies it need for everything to work smoothly.
You can install it by running:

sudo wget --no-check-certificate https://github.com/joshfng/railsready/raw/master/railsready.sh && bash railsready.sh

The script will ask if you want to build Ruby from source or install RVM. Choose RVM.

It will download around 50MB of libraries from the repositories and then download and compile rvm, ruby and download again some other gems, so it will take some time. Don't worry, you don't have to do anything, just wait.

The almost-as-quick, almost-as-easy way
If you don't intend to use rails and don't feel like installing all that stuff, use the following method. It's basically doing the same thing as the previous script, except you don't need so many dependencies, and you won't install rails or passenger.

Installing RVM

RVM (Ruby Version Manager) is a tool which allows us to easily install, manage and work with multiple ruby environments (interpreters and gems) on the same machine. This means we can create different environments with distincts versions, of ruby, rails, or whatever gem we want, without any headaches.

In order to install rvm, you'll need curl, git and some compiler tools. We can get them with the following command:

sudo apt-get install git-core curl build-essential

To install rvm execute:

bash < <( curl http://rvm.beginrescueend.com/releases/rvm-install-head )

This command will install rvm in your home directory.

You need to include a line at the end of the .bashrc file to tell it to load rvm.

Follow carefuly the instructions on your terminal, specially the part about converting the return to an if statement

"[ -z "$PS1" ] && return"

NOTE: The railsready script doesn't do this, and just appends the line loading rvm at the end of the file. RVM maintainers recommend otherwise, so you better do it their way.

If you find any problems, check rvm site troubleshooting information (section 'Trhoubleshooting your install')

Finally reload your envirnonment executing:

source ~/.bashrc

Installing ruby

Now you have rvm installed and running, you can proceed to install ruby. You'll need some packages first, the following command will tell you which:

rvm notes

In my case, these were:
# For Ruby (MRI & ree) you should install the following OS dependencies:

sudo apt-get install build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf

Now, we can install ruby 1.9.2:

rvm install 1.9.2

This will take a while, since it is dowloading ruby sources and compiling them.

You can check ruby is all fine and dandy by running

ruby -v

You should get something similar to:

ruby 1.9.2p136 (2010-12-25 revision 30365) [x86_64-linux]

On the next post I will explain how to setup your environment for testing using rvm.

12 months, 12 katas: January. String calculator

2011-01-01T21:29:00.000+01:00

As recommended by @plagelao on twitter, the kata for January will be String Calculator.
Here are the specs:

Create a simple String calculator with a method int Add(string numbers)
1. The method can take 0, 1 or 2 numbers, and will return their sum (for an empty string it will return 0) for example “” or “1” or “1,2”
2. Start with the simplest test case of an empty string and move to 1 and two numbers
3. Remember to solve things as simply as possible so that you force yourself to write tests you did not think about
4. Remember to refactor after each passing test
Allow the Add method to handle an unknown amount of numbers
Allow the Add method to handle new lines between numbers (instead of commas).
1. the following input is ok: “1\n2,3” (will equal 6)
2. the following input is NOT ok: “1,\n”
3. Make sure you only test for correct inputs. there is no need to test for invalid inputs for these katas
Allow the Add method to handle a different delimiter:
1. to change a delimiter, the beginning of the string will contain a separate line that looks like this: “//[delimiter]\n[numbers…]” for example “//;\n1;2” should return three where the default delimiter is ‘;’ .
2. the first line is optional. all existing scenarios should still be supported
Calling Add with a negative number will throw an exception “negatives not allowed” - and the negative that was passed.if there are multiple negatives, show all of them in the exception message
stop here if you are a beginner. Continue if you can finish the steps so far in less than 30 minutes.
Numbers bigger than 1000 should be ignored, so adding 2 + 1001 = 2
Delimiters can be of any length with the following format: “//[delimiter]\n” for example: “//[***]\n1***2***3” should return 6
Allow multiple delimiters like this: “//[delim1][delim2]\n” for example “//[*][%]\n1*2%3” should return 6.
make sure you can also handle multiple delimiters with length longer than one char

Enjoy!

New Year resolutions

2011-01-01T20:45:00.003+01:00

Here are my resolutions for the present year:
- Read LESS. Yes, less reading, more doing.
- Keep learning ruby.
- Practice! I'm resolved to do a kata EVERY day, one kata each month. Wanna join? Use the hashtag #12months12katas.
- Rediscover enjoyment, on many aspects. This is a tough one, since I first need to find direction, then courage to act in consequence.

Greed game koan

2010-12-20T02:10:00.004+01:00

@jjballano recently posted his version of the Greed game, as part of his learning experience with Ruby Koans. As I am following that very same path, I thought it could also be worth for me to share my implementation of Greed for people to comment on it.

The code could surely be much prettier since I am still trying to get my head around ruby block-passing, among others, so comments (and patches!) are welcome.

UPDATE: The code seems to update automatically to the latest version on github, you can find the original here.

Writing Better Object Oriented Code

2010-11-30T00:12:00.000+01:00

Greg Young did a great presentation at Oredev about writing Object Oriented code the right way. It's so full of good stuff I could not bother to make a summary out of it. Go watch the original video. Now.

I've read: Peopleware

2010-11-26T18:32:00.001+01:00

'Peopleware' is one of those classic books of our profession, a must-read. Unfortunately, it's not easy to grab a copy of it on the stores (it may have been discontinued, I'm not sure). After a failed attempt to borrow it from Jose Manuel Beas, a few weeks ago, I finally got the chance to read it (thanks Rubén!).

All I can say is, if you have the chance, read it! Just so you can have a glimpse at it, here are some notes I took from it. Most are direct quotes, although I reworded a few to synthesize.

Productivity
As long as workers are crowded into noisy, disruptive space, it's not worth improving anything but the workspace.
Experiments showed projects without deadlines had the best productivity.
Better performance can be explained entirely by more effective ways of handling people, modifying the workplace and corporate culture.
Developers main work is human communication to organize the user's expressions of needs into formal procedure.
People won't work better under a lot of pressure.
The manager's function is not to make people work, but to make it possible for people to work.
Best people outperform the worst by 10 and the median performer by 2.5.
Years of experience are not correlated to productivity.
Interrupting flow not only causes disruption but frustration.
There are two types of work: Individual work is noise sensitive and needs flow. Group work is noise producing. Adapt your workspace to make both kinds of work possible.
Measure and try to maximize flow time, but don't let managers access to data.
Ignoring the phone must be accepted by corporate policy.
Ask people about their workspace conditions, what affects their productivity.
Listening to music uses the right part of the braing, which is responsible for creativity.
Encourage teams to customize their space.

People
People who work for you will be more or less the same at the end as they were at the beginning, so they better be right for the job from the start.
Find the right people, make them happy, turn them loose.
Success or failure is in the cards from the moment the team is formed and the initial directions set out.
Corporate pressure is pushing towards the company average, encouraging you to hire people that look, sound and think like everybody else.

Hiring
(Tell about hiring a juggler) 'Don't you want to see me juggle?'
Make people bring their code portfolio for interviews.
Make candidates prepare an audition with the team 10-to-15 minute presentation on some aspect of past work.

Good organizations
Late promotion is a sign of health.
With a low and flat hierarchy, people at the lowest level have, on average more years of experience.
Strive to be the best
Grow a community feeling.
Focus on long term benefits.
Widespread sense that you are expected to stay
Invest in personal growth
Retrain your people
When you automate a system, you make it deterministic, so it looses its self-healing ability. A Methodology (capital 'M' here) can produce the same results on you organization.
To achieve convergence of methods, use training, tools and peer review.
Don't declare something a standard until it is a de facto standard.
Hawtorne effect (experiment of raising and lowering the light) People perform better when they are trying something new.
You have to make non-standard approaches to the rule. Whatever standard there is should be brief and gentle.
Let a hundred flowers blossom and let a hundred schools of thought contend. (Mao Tse-tung)

Jelled teams
Productive teams = challenge + team interaction
They have momentum.
They have a goal
The purpose of a team is not goal attainment but goal achievement.
People on jelled teams are often so involved you have to remind them that what they are trying to accomplish is not winning a war.
Jelled teams have low turnover and strong sense of identity.
Money, status and position for advance matter a lot less. Enjoyment is an obvious sign.
You can't make teams jell, just act to improve the odds.
Teamicide techniques:

Defensive management
Bureaucracy
Physical separation
Fragmentation of people's time
Quality reduction
Phony deadlines
Clique control

Good managers provide opportunities for the team to succeed together. The best success is the one in which there is no evident management. The best boss is the one who can manage without the team knowing they've been managed.

Growing jelled teams:

Give people autonomy and responsibility
Let them work alone, without constant supervision
They break the rules when they believe in it
Let them choose mates and projects
Let them exercise their natural authority in their area of expertise.

Chemistry for team formation:

Make a cult of quality
Provide satisfying confirmation
Build a sense of eliteness
Allow and encourage heterogeneity
Preserve and protect successful teams.
Provide strategic but not tactical direction

Chaos (it is not that bad!)
Small amounts of disorder are benefitial
Pilot projects, war games, brainstorming, provocative training experiences, training, trips, conferences, celebrations, retreats,...

If your corporation is fortunate enough to have a self-motivated superachiever on-board, it's enough to say "Define your own job"
"Free electrons" have a strong role in choosing their own orbits.

Being a Change Agent
Focus on one thing to change. Raise people's consciousness of it, so they help you change it.
Be careful with motivational posters, they can have the opposite effect.
Fuck overtime.
Competition inhibits coaching.
Any action that rewards team members differently is likely to foster competition.
The success of the individual should be tied to the success of the whole.
People hate change. Any change.
Your enemies are blindly loyals and militantly opposed to change.
The fundamental response to change is not logical, but emotional.
Celebrate the old as a way to help make change happen.
Be aware that chaos is an integral part of change. Otherwise, you mistake it for the new status quo and will want to change back.
Change always involves chaos, it is necessary and can't be shortcut. The more painful the chaos, the greater the perceived value of the new status quo.
Change won't even get started unless people feel safe when they know they won't be demeaned for proposing or trying a change.
Change only has a chance of succeeding if failure is also OK.

Organizational learning
Learning is limited by an organization's ability to keep its people.
If the retrained people leave, investment is lost and learning is gone.
Successful learning organizations are always characterized by strong middle management. In order for a vital learning center to form, middle managers must communicate with each other and learn to work together in effective harmony.

Waste
The ultimate management sin is wasting people's time.
Organizations have need of ceremony.
Ceremony is good when it fulfills a need for appreciation by the team.
Early over-staffing is waste.
Fragmented time is waste, it breaks flow.

Community
Building a community makes a difference, but requires talent, courage and creativity. And an enormous invest of time, to be, at best, the catalyst.

Bash completion for symfony

2010-02-27T17:01:00.000+01:00

Fran (a.k.a. tatai), one of my teammates at Biko, was kind enough to make us a nice (and unreadable) script to get symfony bash completion. Get it while it's hot!

You can read more about the script on tatai's blog.

Kudos @tatai for your work!

Sometimes You Have To Take A Step Back Before You Can Move Forward

2009-11-08T02:23:00.000+01:00

Or how I am moving to a PHP team to free myself from WebForms.

So expect to find some stuff (probably including some rants) here about PHP from now on.

AltNerDinner: Part 4. Introducing NHibernate. Because POCO is enough

2009-10-19T21:14:00.001+02:00

It's time already to introduce a proper persistence solution. NHibernate can be a little intimidating at first for a new-comer, but I undoubtedly think it's the way to go. And it's not really more difficult than the other contenders anymore. Its two major drawbacks (hand writing all that XMhelL mapping and not strongly typed queries) are solved (or in serious process of it) by Fluent NHibernate and NHibernate.Linq.

Other than that, the only difficulty relies in learning a few concepts inherent to OR/Ms. Most notably the Unit of Work pattern and Lazy Loading, and all the stuff around them (namely repositories, query objects, persistence ignorance, POCOs, DTOs, entities/value objects and equality, inheritance mapping, dynamic proxies, caching, anemic domains, active record, transactions, concurrency, session lifetime, unit testing, select n+1 problems and other pitfalls to avoid, ...). [NOTE: If you need more info on this topics I'd recommend you to visit the official nhibernate site.]

Sounds scary? It might seem using an OR/M brings in more problems that the ones it solves, but I don't think it is the case, except for maybe the most trivial apps (like AltNerdDinner, hehe, I know). Even if you are writing a relatively simple app, you can still greatly benefit from using NHibernate (or Active Record on top of it). If your app has inherent complexity, well, of course you'll have to do your homework and learn a few concepts, but that's not your OR/M's fault. Using a hand-rolled DAL won't make your problems go away (quite the opposite, I'd dare to say).

As I said, most (if not all) of this problems exist in all OR/M, it's just that some of them somehow try to hide this complexity in one or another way. The problem is, this is a can of worms that can lead to very bad practices and slap on your face at any moment. And this is were I think this is were NHibernate excels at, its flexibility. It gets out of your way.

Ok, enough talking! Show me the code!

To use NHibernate and NH.Linq we need to add a reference in our project to the following dll's: NHibernate, NHibernate.Linq, FluentNHibernate (if we hadn't already) and lastly NHibernate.ByteCode.Castle if we want to use Castle's dynamic proxy as our proxy generator of choice.

Here is the code for my DinnerRepository implementation using NHibernate:

public class NhDinnerRepository : IDinnerRepository
{
    private readonly ISession _session;

    public NhDinnerRepository(ISession session)
    {
        _session = session;
    }

    private INHibernateQueryable<Dinner> GetDbContext()
    {
        return _session.Linq<Dinner>();
    }

    public IQueryable<Dinner> FindAllDinners()
    {
        return GetDbContext().AsQueryable();
    }

    public IQueryable<Dinner> FindByLocation(float latitude, float longitude)
    {
        return GetDbContext().Where(d => d.Distance(latitude, longitude) < 100).AsQueryable();
    }

    public IQueryable<Dinner> FindUpcomingDinners()
    {
        return from dinner in GetDbContext()
               where dinner.EventDate > DateTime.Now
               orderby dinner.EventDate
               select dinner;
    }

    public Dinner GetDinner(int id)
    {
        return GetDbContext().SingleOrDefault(d => d.DinnerID == id);
    }

    public void Save(Dinner dinner)
    {
        if (!dinner.IsValid)
        {
            throw new ApplicationException("Rule violations");
        }

        _session.SaveOrUpdate(dinner);
    }

    public void Delete(Dinner dinner)
    {
        _session.Delete(dinner);
    }

As you see, I am returning IQueryable<Dinner> instead of traditional .NET collections. Some people think IQueryable is the best thing since slice bread, others are ditching repositories entirely, some prefer using query objects, others advocate for explicit repositories, some use generic ones and I just don't know yet, but decided to go at least with repositories because I want to take control of how entities are persisted.

To instantiate my NHibernate repository, I need to supply it with an ISession. I don't create the ISession inside the repository, since this is considered a bad practice. Instead, I create a new Session per request. To do that, I expected I would have some infrastructure in place in MvcContrib, but that was not the case. Jeffrey Palermo posted a NHibernate wrapper to manage ISession, but I thought that class had too many responsibilities, so I separated it in the following.

public class SessionFactoryBuilder
{
    private static ISessionFactory _sessionFactory;

    private readonly IPersistenceConfigurer _dbConfiguration;

    public SessionFactoryBuilder(IPersistenceConfigurer dbConfiguration)
    {
        _dbConfiguration = dbConfiguration;
    }

    public ISessionFactory Build()
    {
        if (_sessionFactory == null)
        {
            _sessionFactory  = GetDbConfiguration().BuildSessionFactory();   
        }

        return _sessionFactory;
    }

    public Configuration GetDbConfiguration()
    {
        return Fluently.Configure()
                .Mappings(m => m.FluentMappings.AddFromAssemblyOf<Dinner>())
                .Database(_dbConfiguration)                    
                .BuildConfiguration();
    }
}

This builds the session factory and also returns the configuration (useful to create the schema). It needs an IPersistenceConfigurer, which I supply from the constructor, in order to be able to switch between different configurations (i.e. MSSQL and SQLite), as shown below:

public class MsSqlPersistenceConfigurerFactory : IPersistenceConfigurerFactory
{
    private string _connectionString;

    public MsSqlPersistenceConfigurerFactory(string connectionString)
    {
        _connectionString = connectionString;
    }

    public IPersistenceConfigurer GetPersistenceConfigurer()
    {
        return MsSqlConfiguration.MsSql2005
                .ConnectionString(c => c.Is(_connectionString))
                .ShowSql()
                .FormatSql()
                .ProxyFactoryFactory<ProxyFactoryFactory>();
    }
}

Life of a Session

We need to create the aforementioned ISession somehow. In Web applications, it's generally a good practice to create a new Session on every request. For that, Ayende recently suggested to just stick it in the global.asax, but I prefer to put it in a separate IHttpModule.

public class NhSessionPerRequestModule : IHttpModule
{
    private readonly ISessionFactory _sessionFactory;

    public NhSessionPerRequestModule(ISessionFactory sessionFactory)
    {
        _sessionFactory = sessionFactory;
    }
    public void Init(HttpApplication application)
    {
        application.BeginRequest += delegate
                                    {
                                        CurrentSession = _sessionFactory.OpenSession();
                                    };

        application.EndRequest += delegate
                                  {
                                      if (CurrentSession != null)
                                      {
                                          CurrentSession.Dispose();
                                      }
                                  };
    }

    public static ISession CurrentSession
    {
        get { return (ISession)HttpContext.Current.Items["current.session"]; }
        private set { HttpContext.Current.Items["current.session"] = value; }
    }

    public void Dispose()
    {        
    }
}

In my Global.asax, I configure it as follows:

private static readonly ISessionFactory SessionFactory = CreateSessionFactory();
private static IWindsorContainer _container;

private static ISessionFactory CreateSessionFactory()
{
    string connString = ConfigurationManager.ConnectionStrings["AltNerdDinner"].ConnectionString;
    return new SessionFactoryBuilder(
            new MsSqlPersistenceConfigurerFactory(connString)
                    .GetPersistenceConfigurer())
            .Build();
}

private readonly NhSessionLifetimeModule _nhSessionLifetimeModule =
        new NhSessionLifetimeModule(SessionFactory);

public override void Init()
{
    base.Init();
    _nhSessionLifetimeModule.Init(this);
}

Lastly, this is my current configuration of the container in order to register the components:

private void RegisterComponents()
 {
     _container = new WindsorContainer();
     _container.AddFacility<FactorySupportFacility>();

     ControllerBuilder.Current.SetControllerFactory(
         new WindsorControllerFactory(_container));

     _container.Register(
             Component.For<ISession>()
                     .UsingFactoryMethod(() => NhSessionLifetimeModule.CurrentSession)
                     .LifeStyle.Transient);
  
     _container.Register(
             Component.For<IDinnerRepository>()
                     .ImplementedBy<NhDinnerRepository>().LifeStyle.Transient);

     _container.RegisterControllers(Assembly.GetExecutingAssembly());
 }

Java and (the lack of) CoC

2009-10-16T17:34:00.001+02:00

"Java is a DSL to transform big Xml documents into long exception stack traces."
-- Scott Bellware

AltNerdDinner: Part 3. Introducing Fluent NHibernate. Mapping, the easy way

2009-10-14T23:02:00.001+02:00

This is part 3 of the AltNerdDinner Series.

One of the things I always disliked the most when exploring NHibernate was the need of declaring all the mappings in XMhelL. And don't know about you, but that's not something I want to be spending my time creating, modifying, hand-refactoring or debugging tedious tons of this crap.

Fast forward to 2008 and say hello to Fluent NHibernate. (And don't forget to thank Jeremy Miller, James Gregory et al!). It is basically a way to programmatically declare the mappings, allowing you to go from this:

<?xml version="1.0" encoding="utf-8" ?>  
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"  
  namespace="QuickStart" assembly="QuickStart">  
 
  <class name="Cat" table="Cat">  
    <id name="Id">  
      <generator class="identity" />  
    </id>  
 
    <property name="Name">  
      <column name="Name" length="16" not-null="true" />  
    </property>  
    <property name="Sex" />  
    <many-to-one name="Mate" />  
    <bag name="Kittens">  
      <key column="mother_id" />  
        <one-to-many class="Cat" />  
      </bag>  
  </class>  
</hibernate-mapping>

To this:

public class CatMap : ClassMap<Cat>
{
    public CatMap()
    {
        Id(x => x.Id);
        Map(x => x.Name)
          .Length(16)
          .Not.Nullable();
        Map(x => x.Sex);
        References(x => x.Mate);
        HasMany(x => x.Kittens);
    }
}

What it gives you, you may ask? Compile-time checks and refactoring support, for a start.

But wait, there is more!

Fluent NHibernate is built with Convention over Configuration in mind. So, if you adhere to it, you can greatly reduce the amount of mapping needed, by virtue of auto mapping. And you can combine that with explicit ClassMap mappings, like the one above, they are not mutually exclusive.

Mapping your domain can be as simple as:

AutoMap.AssemblyOf<Product>();

And if you call within the next 5 minutes we throw in Conventions for free!

"Ok, that might be great for a greenfield project, but I am working in a big brown piece of ... code", I hear you saying. So you may not have the choice to call your Id's "Id" or name your tables exactly after your classes. Conventions can greatly help here, allowing you to define your own conventions. That is, if your database naming follows any convention at all, and wasn't defined by a bunch of monkeys typing at random.

For further info, check the site, wiki and mailing list.

AltNerdDinner's mappings

Here are the mapping files for AltNerdDinner.

public class DinnerMap : ClassMap<Dinner>
{
    public DinnerMap()
    {
        Id(x => x.DinnerID);
        Map(x => x.Address).Not.Nullable();
        Map(x => x.ContactPhone).Not.Nullable();
        Map(x => x.Country).Not.Nullable();
        Map(x => x.Description).Not.Nullable();
        Map(x => x.EventDate).Not.Nullable();
        Map(x => x.HostedBy).Not.Nullable();
        Map(x => x.Latitude).Not.Nullable();
        Map(x => x.Longitude).Not.Nullable();
        Map(x => x.Title).Not.Nullable();
        HasMany(x => x.RSVPs).Cascade.AllDeleteOrphan();
    }
}

public class RSVPMap : ClassMap<RSVP>
{
    public RSVPMap()
    {
        Id(x => x.RsvpId);
        Map(x => x.AttendeeName).Not.Nullable();
        References(r => r.Dinner).Nullable();            
    }
}

One gotcha that had me fiddling around for a while was that Nullable part on the Dinner reference in RSVPMap. If you don't set it to nullable, you'll get an exception when trying to persist the entities. And even if you set it to nullable, you'll find out, NHibernate executes two queries to insert the RSVP.

    INSERT INTO [RSVP] (AttendeeName, Dinner_id) VALUES (@p0, @p1);

    select SCOPE_IDENTITY();

    @p0 = 'alberto',

    @p1 = 9

    UPDATE [RSVP] SET Dinner_id = @p0 WHERE RsvpId = @p1; @p0 = 9, @p1 = 21

You can find more info about this behavior in the official nhibernate site.

So, what I have done instead is to set the RSVP as the managing part of the relationship, changing it back to not nullable and using Inverse() on the Dinner's mapping side.

It is not possible to make the "many part" responsible for this. What this means is that we have to persist our entities calling:

Dinner dinner = _dinnerRepository.GetDinner(id);
var rsvp = new RSVP{ AttendeeName = username };
rsvp.Dinner = dinner;
dinner.Rsvps.Add(rsvp);
_dinnerRepository.Save(dinner);

That's not very ideal, so I have included an AddRsvp() method in Dinner to handle that. Now I have:

Dinner dinner = _dinnerRepository.GetDinner(id);
dinner.AddRsvp(new RSVP{ AttendeeName = User.Identity.Name });
_dinnerRepository.Save(dinner);

Much cleaner! In order to avoid confusion when adding an RSVO, I have changed the type of the collection to an IEnumerable<RSVP>, so that the collection cannot be modified directly, but only by means of Dinner (which is a good practice if you want to follow DDD, anyway). Because of that, I had to modified the DinnerMap to use a backing field for it. In the future I might revisit this relationship to include the User in the domain again and change it to a less CRUD-y style. You can read more on Domain-Driven fluency from Udi Dahan.

Anyway, here is the final mapping I have come up with:

public class RSVPMap : ClassMap<RSVP>
{
    public RSVPMap()
    {
        Id(x => x.RsvpId);
        Map(x => x.AttendeeName).Not.Nullable();
        References(r => r.Dinner).Not.Nullable();            
    }
}

public class DinnerMap : ClassMap<Dinner>
{
    public DinnerMap()
    {
        Id(x => x.DinnerID);
        Map(x => x.Address).Not.Nullable();
        Map(x => x.ContactPhone).Not.Nullable();
        Map(x => x.Country).Not.Nullable();
        Map(x => x.Description).Not.Nullable();
        Map(x => x.EventDate).Not.Nullable();
        Map(x => x.HostedBy).Not.Nullable();
        Map(x => x.Latitude).Not.Nullable();
        Map(x => x.Longitude).Not.Nullable();
        Map(x => x.Title).Not.Nullable();
        HasMany(x => x.Rsvps).Access.CamelCaseField(Prefix.Underscore)
            .Inverse().Cascade.AllDeleteOrphan();
    }
}

AltNerdDinner: Part 2. Rich Man's Dependency Injection

2009-10-06T21:02:00.001+02:00

This is part 2 of the AltNerdDinner Series.

The classes in NerdDinner use dependency injection (constructor injection, to be more precise), which is a form of Inversion of Control that allows you to break the dependencies between classes, minimizing coupling (i.e. a Good Thing ™). Instead having classes with direct dependencies on other classes, and instantiating them directly, classes are dependent on interfaces, and the concrete implementation is injected via the constructor, in this case, or via a setter in the case of setter injection. Constructor injection is preferred for required dependencies, as it makes dependencies more explicit, and setter injection is usually reserved for optional dependencies.

Using this technique, the responsibility of providing the dependencies is delegated to the calling object (hence the term Inversion of Control).

Poor Man's Dependency Injection

The problem with the NerdDinner codebase is that, besides the constructor that accepts the required dependencies, they added a default constructor that news up those dependencies. Here is an example:

public DinnersController() : this(new DinnerRepository())
{
}

public DinnersController(IDinnerRepository repository) {
    dinnerRepository = repository;
}

This may look like a good compromise. You get the decoupling needed to run your tests (by means of the constructor accepting parameters) and you are also able to instantiate you classes calling the default constructor, without the added complexity of an IoC container. However this technique is considered an anti-pattern (although not everybody agrees) leading to many headaches. By adding this constructor we're almost at square one again. Our classes are still coupled, and if we need to add new dependencies, we'll have to go hunting around to fix all the constructor calls.

If I were a rich man

So now you are convinced to use an IoC container, you can have a look this container guidelines by Jimmy Bogard. He may not consider his recommendations as best practices, but I do (and so should you, IMHO). I picked Castle Windsor as my framework of choice. As usual, there are plenty of alternatives. Even though the API is not the cleanest of all the frameworks, I favored Windsor because it is very mature, is widely adopted, it also supports .NET 2.0, and has good integration with NHibernate. It also is the container used in S#arp Architecture, which is something I will probably end up using. Otherwise, my choice would be StructureMap.

In order to use Windsor, you have to reference on your project Castle.Core, Castle.MicroKernel and Castle.Windsor. To ease the configuration of the container, I also downloaded MvcContrib (which I was planning to use anyway) and added a reference to MvcContrib.Castle.

This is the code needed to register the controllers and the Repository.

private void RegisterComponents()
{
    _container = new WindsorContainer();
    ControllerBuilder.Current.SetControllerFactory(
        new WindsorControllerFactory(_container));
    _container.RegisterControllers(Assembly.GetExecutingAssembly());
    _container.Register(
            Component.For<IDinnerRepository>()
            .ImplementedBy<InMemoryDinnerRepository>());
}

To allow the creation of the controllers by the MVC framework, you need to supply a ControllerFactory that can instantiate them, as they now take dependencies on their constructors. MvcContrib provides one for Windsor, as well as the method RegisterControllers to, guess what, registering all the controllers in a specified assembly. I also registered my DinnerRepository, so that Windsor can resolve the references to it.

AltNerdDinner: Part 1. Removing unwanted dependencies

2009-10-03T18:56:00.001+02:00

The first thing I have done is to set up the project on github, so if you want to have a look at the code, check the AltNerdDinner repository. Then I set up the project following the guidelines of my series Continuous Integration series.

Now we are set, there is some stuff I don't want in AltNerdDinner, so I am mercilessly going to get rid of it.

Bye, MSTest

MSTest gives nothing useful beyond integration in VS (for which I prefer ReSharper's Test Runner or TDD.NET). I won't say it sucks, but Phil Haack did. It's just there to satisfy MS-Only shops. It's slow, and it evolves slowly too. It lags behind the alternative frameworks. Oh, and it requires VS to be installed on your build server (crazy!), and...

So I replaced it with good ol' NUnit. It basically involves replacing:

using Microsoft.VisualStudio.TestTools.UnitTesting; by using NUnit.Framework;

[TestClass] and [TestMethod] by [TestFixture], and [Test]

and a bunch of calls to Assert.IsInstanceOfType(object, type); by Assert.IsInstanceOf(type, object); (pay attention to the signature change!).

We don't need no membership provider

Right now I don't want to deal with membership provider. I think it's bloated and I don't want to have to mess with the authentication right now, so I am going to replace it with a FakeMembershipService for the moment and leave the decision of whether revisiting it or completely replacing it (probably the latter) for a later time.

LINQ to SQL is dead, long live NHibernate

L2S is probably a decent option for this kind of simple app, and it's very easy to quickly duct-tape a simple app. It has some goodies, like the visual designer and of course Linq. But it's not the best option if your app gets bigger and you need some more advanced ORM features, like different mapping capabilities or different databases support. It's not a bad tool, but it has some limitations that need to be addressed and, unfortunately, the fact that L2S is being killed means you are better not investing hard into it.

So I am planning to replace it with NHibernate, a mature and tested product that fits my needs. But just not yet. Right now, I will simply remove the L2S stuff and work with POCOs and an InMemoryRepository implementation (which is basically the FakeDinnerRepository present in the Tests project).

The model

As we can see on the picture of the original model, the domain is quite simple.

I have simply created POCO classes replacing the L2S generated ones.

After all the changes, we run all the tests and...

We're done!

The road to Continuous Integration. Part 3: Script it, build it, test it, break it, fix it. Commit it.

2009-09-28T21:03:00.003+02:00

Ideally, any new developer in your team should be able to build your project with a single command or double-click. To accomplish that, we are going to use a build script.
You can also pick your poison here, too. I am going to stick with nant for the moment, because it's the most mature and broadly used, and the one I know better, despite of the XMHell that is the angle-bracket orgy it imposes. Rake seems nice, and has less noise than the others, but I don't like the fact that I have to install ruby and rake separately. As I said, I like all of my dependencies being included in source control, so that my projects are self-contained (there are some efforts to get ruby and rake as a single executable, though). If you are hesitating between msbuild and nant, you can check out a comparison between nant and msbuild I did a while ago.

As you can see on the picture, I have added two build scripts to the root of AltNerdDinner. common-targets.build has, you know, common nant targets. It's a script I reuse between projects and it has all the tasks I usually execute (compile, recompile, publish or package the project, run the tests, analyze the code or binaries, etc). AltNerdDinner.build is the specific script for this project. By virtue of Convention over Configuration on the project structure and directory and file names, we can remove a lot of unnecessary noise. By adhering to conventions, we just have to set up a couple of properties and simply delegate on common-targets.build for most (if not all) of the tasks, just defining the dependencies between tasks and passing parameters to configure the task where needed.

You can see below how simple it gets, with only 16 lines of code:

<?xml version="1.0" ?>
<project name="AltNerdDinner" default="compile">
  <property name="dir.root" value="${path::get-full-path('.')}" />
  <include buildfile="${dir.root}/common-targets.build" />
  <property name="file.solution" value="${dir.root}/NerdDinner.sln" />
  <property name="file.project" value="${dir.root}/src/NerdDinner/NerdDinner.csproj" />
  <property name="assembly.tests" value="NerdDinner.Tests.dll" />

  <target name="compile" depends="common.clean, common.init, common.compile" />
  <target name="test" depends="compile, common.test" />
  <target name="publish" depends="test, common.publish" />
  <target name="zip" depends="publish, common.zip" />
  <target name="analyze" depends="publish, common.stylecop, common.ndepend" />
  <target name="build" depends="publish, analyze" />
  <target name="build-full" depends="publish, analyze, zip" />
</project>

There is also a go.bat script, which just calls nant, passing AltNerdDinner.build as the build file. As a side note, notice that my solution file is in the root of the project instead of in src. I like to keep it there so that I can easily refer to the root of the project from it (useful if you want to dome some pre/post build stuff on Visual Studio or for other tools than reference your solution).

What do you see on the picture?

2009-09-15T11:33:00.002+02:00

Monotouch 1.0 was released today. I was quite shocked when I saw the logo. Look at it for a second. What do you see there?
It might be my perturbated mind, but I was quite shocked when I felt it was "showing me the finger". It actually took me a minute (I said I was shocked) to realize it was not that finger. Still, maybe that logo deserves a revamp. Just making clear the first finger is a thumb will suffice.

The road to Continuous Integration. Part 2: Shake your tree

2009-09-13T20:11:00.001+02:00

As I stated in the first part of this Continuous Integration series, one of the aims of storing your stuff under source control is being able to build your project from a fresh checkout, without needing to manually install or configure anything.

To accomplish this, it is always useful to use a standardized tree structure. You can have a look at some of the popular open source projects you use and love to get ideas on how to organize things. Now that your have everything under source control (don't you?), we can start moving a few things around.

On the picture you can see a very typical structure for a project.

The src folder contains the different projects in their respective folders.
The lib folder will contain any third-party library needed to run our project. This is, any dependency that has to be deployed with our project (e.g. NHibernate, Windsor, etc).

The tools folders will contain any tools needed to build our project. It will contain tools like nant, nunit or fxcop, which we will use but won't distribute with our application.

The build folder will hold the artifacts of the build.

Again, the purpose of putting all these libraries and frameworks under source control is to make EVERITHING needed to build and run your project available. Any new developer getting into your team should then be able to checkout your code and build it successfully, without needing to download and/or install anything from the Internet or hunt down any other dependencies your project builds upon.

If you need further info, I would recommend you to watch this screencast by Kyle "Dissociative identity disorder" Baley.

The road to Continuous Integration. Part 1: Get your source under control!

2009-09-11T22:44:00.001+02:00

If you are not already doing so, put your stuff under source control. Right now. It doesn't matter how small your project is or whether you are working alone. If it's worth your time, it's worth putting it under source control.

What is Source Control?

Source control, often referred to as VCS (Version Control System) or SCM (Source Code Management) is the management of changes in files. It's a time machine that lets you see how your project looked like at any given point in time.

For a more detailed introduction, see Eric Sink's Source Control HOWTO or the SVN book.

Why you should use a SCM tool

It gives you an infinite undo-button. No matter how much you have screwed up, you can always go back to a stable point.

You can share code with other people.

You can keep track of your changes over time. This allows you to know who changed what, when and (luckily, if you use meaningful comments) why.

You can maintain multiple code bases of your software. Even if you only have one active version at a time, it's useful to start new development independently.

What should you store?

Everything you need to build your product. That includes your sources, of course, but also any libraries your projects depends on (avoid referencing GAC'ed or installed libraries), any tools you use and any scripts that you need as part of the process. Nothing should be dependent of your machine installation.

The goal is to be able to get into a clean machine, get a copy of the codebase from your source repository, build it (automatically) and voilà, you are done and ready to start working!

WHICH SCM ARE YOU?

There are many alternatives, just pick one, (oh well, not THAT one). If you don't want to set up and maintain a server, you can use one of the many online services available (some of them are just for open source projects, and some have free and paid plans). Which one is best will depend on your specific needs:

If you...

want an easy to install, easy to start tool -> svn
want a powerful tool, at the expense of a bit steeper learning curve -> git, mercurial, bazaar
need to use a mature GUI/integration with Visual Studio -> svn, tfs
need good branching and merging support -> git, mercurial, bazaar
need an all-in-one tool (source control, bug tracking system, continuous integration) completely integrated, even if the individual tools are not-so-great for the -> tfs
are a Microsoft-only shop -> tfs

For the clients there are also a myriad of tools available for all platforms. You have command-line interfaces, standalone GUI tools (tortoisesvn, tortoisehg, tortoisegit) and IDE integrated (VisualSVN, AnhkSVN, Git Extensions).

Agile enterprise culture

2009-09-08T20:38:00.002+02:00

Culture

View more presentations from Reed Hastings.

Some highlights:

"The real company values, as opposed to the nice-sounding values, are shown by who gets rewarded, promoted or let-go"

"The Keeper Test: 'Which of my people, if they told me they were leaving in two months for a similar job at a peer company, would I fight hard to keep?'"

"You should periodically ask your manager: 'If I told you I were leaving, how hard would you work to change my mind?'"

"In procedural work, the best are 2x better than the average."

"In creative work, the best are 10x better than the average, so huge premium on creating effective teams of the best"

"Vacation policy and Tracking: there is no policy or tracking"

"One outstanding employee gets more done and costs less than two adequate employees"

"It is a good idea, not a traitorous idea, to understand what other firms would pay you, by interviewing and talking to peers at other companies"

Three Tests for Top of Market for a Person:
1. What could person get elsewhere?
2. What would we pay for replacement?
3. What would we pay to keep person?

"We should celebrate someone leaving for a bigger job that we didn't have available to offer them"

"If manager would promote employee to keep them [...], manager should promote him now, and not wait"

"Mediocre colleagues and unchallenging work is what kills progress of a person's skills"

The road to continuous integration

2009-09-01T19:54:00.002+02:00

After my introductory post in the AltNerdDinner series, I thought it would be a good idea to roll out an independent series of posts about the things I have learnt in the past two years on setting up a code base for continuous integration. Nothing really new under the sun, but it might help a few people to get started.
I will update this post with links backs to each element of the series.
Part 1: Get your source under control

Part 2: Shake your tree

Part 3: Script it, build it, test it, break it, fix it. Commit it

Introducing AltNerdDinner

2009-08-27T19:49:00.004+02:00

This is the first in a series of posts in my quest to get my hands dirty with ASP.NET MVC framework, MVCContrib, Spark, NHibernate, FluentNhibernate, Linq2NHibernate, Windsor and a whatnot. For that, I have decided to take NerdDinner for a spin (not extremely original, I know), replacing what I think could be better and extending from there. If you are interested, you can have a look at the AltNerdDinner repository on github.

Here is a list of the posts published so far:

Part 1: Removing unwanted dependencies

Part 2: Rich Man's Dependency Injection

Part 3: Introducing Fluent NHibernate. Mapping, the easy way

Part 4: Introducing NHibernate. Because POCO is enough

TDD Masterclass

2009-08-26T20:38:00.003+02:00

Roy Osherove is giving an hands-on TDD Masterclass in the UK, September 21-25. Roy is author of "The Art of Unit Testing" (http://www.artofunittesting.com/), a leading tdd & unit testing book; he maintains a blog at http://iserializable.com (which amoung other things has critiqued tests written by Microsoft for asp.net MVC - check out the testreviews category) and has recently been on the Scott Hanselman podcast (http://bit.ly/psgYO) where he educated Scott on best practices in Unit Testing techniques. For a further insight into Roy's style, be sure to also check out Roy's talk at the recent Norwegian Developer's Conference (http://bit.ly/NuJVa).

Full Details here: http://bbits.co.uk/tddmasterclass

bbits are holding a raffle for a free ticket for the event. To be eligible to win the ticket (worth £2395!) you MUST paste this text, including all links, into your blog and email Ian@bbits.co.uk with the url to the blog entry. The draw will be made on September 1st and the winner informed by email and on bbits.co.uk/blog

It's the people, stupid!

2009-08-15T20:04:00.004+02:00

You need people who are passionate about what they do. People who care about their craft — and actually think of it as a craft. People who take pride in their work, regardless of the monetary reward involved. People who sweat the details even if 95% of folks don't know the difference. People who want to build something great and won't settle for less. [...]Anyhow, when you find those people, hold onto them. In the end, the folks on your team will make or break your project — and your company.
-- Getting Real, 37signals

Excellence

2009-05-08T21:08:00.000+02:00

We are what we repeatedly do. Excellence, then, is not an act, but a habit.
-- Aristotle

The role of the Scrum Sensei

2009-05-01T20:51:00.006+02:00

When you need me, but do not want me, then I will stay.
When you want me, but do not need me, then I have to go.

-- Nanny McPhee, via Björn Granvik

On value types vs reference types and premature optimization

2009-04-27T23:50:00.004+02:00

Eric Lippert, wrote a great post about value types vs reference types, and how, many times, the discussion is shifted to the-heap-and-the-stack, when it should really be about the differences when those types are passed (by value) as parameters.

He nails it when he says:

Making the nano-optimization of making a type that really should be a ref type into a value type for a few nanoseconds of perf gain is probably not worth it. I would only be making that choice if profiling data showed that there was a large, real-world-customer-impacting performance problem directly mitigated by using value types. Absent such data, I’d always make the choice of value type vs reference type based on whether the type is semantically representing a value or semantically a reference to something.

To plan or not to plan

2009-03-14T21:18:00.002+01:00

In preparing for battle I have always found that plans are useless, but planning is indispensable.

-- Dwight D. Eisenhower

The price of change

2009-03-12T17:20:00.001+01:00

Change is expensive, no question about it. However, consider the alternative—stagnation.

-- Jim Highsmith

Targetting .NET 2.0 with Nant and Visual Studio 2008

2009-03-10T13:20:00.003+01:00

If you try to migrate a solution to VS2008 and you are using nant, you'll probably find a few problems. This is one of them I am documenting for you.
I wanted to use VS2008 and nant, but still want target the .net 2.0 framework. I read somewhere I needed to install the .net 2.0 sdk, but I was still having issues, where msbuild was complaining it didn't recognize the format of the solution file.
It turns out you need to change nant.settings.currentframework to "net-3.5", so that it is the version of msbuild that comes with msbuild who compiles the solution (so I am not sure anymore you need the .net 2.0 sdk). It will still target the .net 2.0 framework for your projects if you set that that way in VS, as msbuild uses that info for the target.

Hope it helps someone out there.

Programming for the Mob sharks? No, thanks.

2009-02-22T19:12:00.004+01:00

Ward Cunniham, of Ward's Wiki fame, was the coiner of the term "technical debt". He made an interesting clarification in the following video:

According to his intention, the term is usually misused to reflect (and even encourage) the writing of sloppy code with the excuse that it will be refactored later. His original vision was more aligned with the XP style of simple design.

Doing bad code with the excuse of refactoring somewhere in the future is not technical debt we are going to pay, but rather asking money from loan mob sharks at an astronomic interest rate and the expenses of losing a few body parts in the way.

PS: It is funny how the metaphor was coined as an analogy that his boss could understand, but it has grown to be used and abused by everybody in the industry. Maybe that's also related to the debt culture that has drawn our uneducated society into the current situation.

Quality

2008-12-04T23:56:00.004+01:00

Quality means doing it right when no one is looking.

-- Henry Ford

Assumptions

2008-12-04T21:49:00.002+01:00

Assumption is the mother of all screw-ups.

-- Wethern's Law of Suspended Judgment

Achieving Mastery

2008-12-04T20:52:00.003+01:00

First, master the fundamentals.

-- Larry Bird

[SPAM-LOW] Isolator for SharePoint

2008-11-24T22:58:00.005+01:00

The Typemock guys have released a version of Typemock isolator for SharePoint. This is the announcement (which will hopefully grant me a license to try Typemock):

Typemock are offering their new product for unit testing SharePoint called Isolator For SharePoint, for a special introduction price. it is the only tool that allows you to unit test SharePoint without a SharePoint server. To learn more click here.

The first 50 bloggers who blog this text in their blog and tell us about it, will get a Full Isolator license, Free. for rules and info click here.

Fix: Can't install updates on Windows XP after installing SP2

2008-10-15T20:54:00.001+02:00

Just in case it happens to me (or you) again.

1. Open command prompt (or use a for a better console).
2. net stop wuauserv
3. regsvr32 %windir%\system32\wups2.dll (regsvr32 %windir%\syswow64\wups2.dll for win64)
4. net start wuauserv
5. exit

http://forums.cnet.com/5208-6142_102-0.html?forumID=5&threadID=276886&messageID=2660716
http://support.microsoft.com/kb/943144

Why SVN sucks

2008-09-26T18:54:00.004+02:00

"A common desire is to refactor source code, especially in Java-based software projects. Files and directories are shuffled around and renamed, often causing great disruption to everyone working on the project. Sounds like a perfect case to use a branch, doesn't it? Just create a branch, shuffle things around, and then merge the branch back to the trunk, right?

Alas, this scenario doesn't work so well right now and is considered one of Subversion's current weak spots."

-- Subversion book

The fact that subversion lacks a true rename operation (it is done via copy & delete) you can get into a lot of troubles if you rename or move files in subversion if somebody else modifies the same file meanwhile. And by troubles I mean losing data! (If you want more info about it, check this bug entry. You will find the detailed use cases in the attached files there.)

For a fast rename (or move, which is exactly the same operation) & commit, there is a low probability you run into this issue (assuming the other guy also updates frequently), so things aren't so critical here. But, when working with branches, it's a whole new story. They will live much longer (from days to weeks or months) so the probability of somebody modifying a file renamed in another branch increases a lot. That effectively means you cannot rename or move files if you use branches. Yeah, you read it right. If you use branches, moving files is not safe. End of story.

So, what svn is forcing us to do is either:
a) Don't rename files.
b) Don't use branches.
c) Don't use subversion.

a) is simply stupid, so let's forget it. b) might be ok for some people/enviroments. c) is what you really should be doing if b) is not an option (which makes perfect sense).

If you are looking for alternatives, use git or mercurial.

nant vs. msbuild

2008-09-05T20:19:00.006+02:00

Yes, this is yet another post on nant vs. msbuild.
I had to choose which one of the two to use at the company I work for. After doing a lot of research, it looks like there aren't many differences between them. Here are some of the pro/cons I found:

- msbuild comes from Microsoft (yes, that usually matters to some (not all, like me) people)
- msbuild is already installed in every .net developer machine (not a big deal)
- msbuild has probably better integration with VS build process
- msbuild supports parallel builds since .net 3.5 (not that it really matters, since you usually use msbuild from nant to build your projects, anyway).
- msbuild evaluates filesets at startup. This seems to cause some headaches when you want to manipulate files generated during the building process.
- you can redefine targets in msbuild. in nant you can define general targets and just make your build files call those (or create and use hooks, which is a solution I don't really like).
- nant has more examples and better documentation
- there is much more information about nant than about msbuild on the web, according to google trends and google search results (both in english and spanish)
- nant has some more tasks, but with msbuildtasks/sdc tasks it's on par with nant and nantcontrib.
- nant helper functions and expressions are better ¿?
- I like nant syntax better.
- nant is more mature, msbuild was born as an alternative (alt.alt.net :D) to nant for companies with ridiculous "no open source here" and Microsoft "I can't support an open source project I don't control" way of life.
- most open source projects tend to use nant over msbuild, so there are plenty of build files and task you can make good use of or have as a reference.
- I have already played with nant a little, so I know it's syntax better.
- I have started to use nant to automatically generate config files from templates for the different enviroments, and didn't find the way to do so in msbuild.
- nant is open source, so people can contribute to it.
- nant is not tied to microsoft release cycle, msbuild is.

There isn't any strong reason in itself to pick one, but adding them up, things favoured significantly nant over msbuild, so I ended up choosing the former.

If you want to read more on the subject, here are some of the links I used in my research (in no particular order):
http://ayende.com/Blog/archive/2008/02/25/Zero-Friction-and-why-Defaults-Matters.aspx
http://www.winterdom.com/weblog/2007/09/21/MSBuildVsNAnt.aspx
http://www.paraesthesia.com/archive/2008/01/08/why-nant-is-better-than-msbuild.aspx
http://www.innoq.com/blog/hw/2007/09/24/msbuild_vs_nant.html
http://www.codeproject.com/KB/books/msbuild.aspx
http://brandonbyars.com/blog/articles/2008/01/10/Managing-Config-Files
http://www.paraesthesia.com/archive/2008/01/08/why-nant-is-better-than-msbuild.aspx
http://kentb.blogspot.com/2008/02/fail-early-with-full-builds-from-within.html
http://weblogs.asp.net/rosherove/archive/2008/01/18/trying-out-team-city-looks-promising.aspx
http://codebetter.com/blogs/jeremy.miller/archive/2007/09/20/is-there-a-good-reason-to-switch-to-msbuild.aspx
http://codebetter.com/blogs/jeffrey.palermo/archive/2007/09/25/demo-on-automating-your-build-with-nant-and-ccnet.aspx
http://www.distribucon.com/blog/WhyMSBuildSucks.aspx
http://www.tkachenko.com/blog/archives/000643.html

Back from holydays

2008-07-20T12:49:00.003+02:00

Oh, my.

How does a project get to be a year behind schedule?

2008-06-18T21:07:00.004+02:00

One day at a time.
-- Fred Brooks, The Mythical Man-Month.

Fix Time and Budget, Flex Scope

2008-06-18T20:54:00.007+02:00

Here's an easy way to launch on time and on budget: keep them fixed. Never throw more time or money at a problem, just scale back the scope.
[...]
If you can't fit everything in within the time and budget allotted then don't expand the time and budget. Instead, pull back the scope. There's always time to add stuff later — later is eternal, now is fleeting.-- 37signals, Getting Real.

Experience

2008-06-15T18:24:00.003+02:00

Experience is what you get when you don't get what you want.

-- Dan Stanford

Exce(r)ptions

2008-06-01T19:28:00.006+02:00

Just a few notes on exceptions to remind, from Karl Seguin.
Handling exceptions
1 - Only handle exceptions that you can actually do something about, and
2 - You can't do anything about the vast majority of exceptions

Logging
You should log every exception. Ideally you'll centralize your logging - an HttpModule's OnError event is your best choice for an ASP.NET application or web service.

Handling database access (and its possible exceptions):

using (SqlConnection connection = new SqlConnection(FROM_CONFIGURATION))  
using (SqlCommand command = new SqlCommand("SomeSQL", connection))  
{  
   connection.Open();  
   command.ExecuteNonQuery();  
}

throw vs. throw ex
On occasion you'll need to rethrow an exception because, while you can't handle the exception, you still need to execute some code when an exception occurs. In this case you should use throw to preserve the full exception stack. Contrary, if you find yourself in a situation where you think you want to rethrow an exception with your handler as the source, a better approach is to use a nested exception:

catch (HibernateException ex)
{
  if (transaction != null) { transaction.Rollback(); }
  throw new Exception("Email already in use", ex);
}

When to throw
A method should throw when it wasn't able to do what it was suppossed to do.

If you want a more in-depth explanation on the subject, I recommend you go and read the article

The key to success

2008-06-01T11:38:00.001+02:00

I don't know the key to success, but the key to failure is trying to please everybody.

-- Bill Cosby

Don't let that wall stop you

2008-05-11T22:05:00.004+02:00

Brick walls are there for a reason: they let us prove how bad we want things.

-- Randy Pausch

Ayende's Challenge #2: The directory tree

2008-04-14T21:14:00.004+02:00

Here comes a new challenge.

Given a set of versioned file, you need to cache them locally. Note that IPersistentCache semantics means that if you put a value in it, is is always going to remain there.

I'm glad this one wasn't on a real interview, it took me quite some time to get this right, I guess I wouldn't have get the job this time. xD

You can download the source from here or see it below. :)

    public interface IPersistentCache

    {

        void Set(string key, params string[] items);

        string[] Get(string key);

        ICollection<string> Keys();

    }

    public class PersistentCache : IPersistentCache

    {

        readonly Dictionary<string, List<string>> cache = new Dictionary<string, List<string>>();

        public void Set(string key, params string[] items)

        {

            if (cache.ContainsKey(key))

               cache[key].AddRange(items);

            else

               cache[key] = new List<string>(items);

        }

        public string[] Get(string key)

        {

            if (!cache.ContainsKey(key))

                return null;

            return cache[key].ToArray();

        }

        public ICollection<string> Keys()

        {

            return cache.Keys;

        }

    }

    public class VersionedFile

    {

        public int Version { get; set; }

        public string Name { get; set; }

        public override string  ToString()

        {

            return Name + ";" + Version;

        }

        public static VersionedFile FromString(string versionedFileString)

        {

            string[] nameAndVersion = versionedFileString.Split(';');

            return new VersionedFile

                       {

                           Name = nameAndVersion[0],

                           Version = int.Parse(nameAndVersion[1])

                       };

        }

        public string GetParent()

        {

            int index = Name.LastIndexOf("/");

            if (index > 0)

                return Name.Substring(0, index);

            if (index == 0 && Name.Length > 1)

                return "/";

            return null;

        }

    }

    public enum Recursion

    {

        None,

        OneLevel,

        Full

    }

    public interface IFileSystemCache

    {

        void Add(VersionedFile[] versionedFiles);

        string[] ListFilesAndFolders(string root, int version, Recursion recursion);

    }

    public class FileSystemCache : IFileSystemCache

    {

        readonly IPersistentCache cache;

        public FileSystemCache(IPersistentCache cache)

        {

            this.cache = cache;

        }

        private void WriteToPersistentCache(VersionedFile file)

        {

           WriteToPersistentCache(file.Name, file);

        }

        private void WriteToPersistentCache(string key, VersionedFile file)

        {

            cache.Set(key, file.ToString());

        }

        public void Add(VersionedFile[] versionedFiles)

        {

            foreach (VersionedFile file in versionedFiles)

            {

                WriteToPersistentCache(file);

                string parent = file.GetParent();

                if (parent != null)

                    WriteToPersistentCache(parent, file);

            }

        }

        public string[] ListFilesAndFolders(string root, int version, Recursion recursion)

        {

            switch (recursion)

            {

                case Recursion.None:

                    return GetFolder(root, version);

                case Recursion.OneLevel:

                    return GetFilesAndFolder(root, version);

                case Recursion.Full:

                    return GetAllFilesAndFoldersIn(root, version, false);

                default:

                    return null;

            }

        }

        private static string[] FilterByVersion(string[] strings, int version)

        {

            var versionedfiles = new List<string>();

            foreach (string s in strings)

            {

                var versionedFile = VersionedFile.FromString(s);

                if (versionedFile.Version == version)

                    versionedfiles.Add(versionedFile.Name);

            }

            return versionedfiles.ToArray();

        }

        private string[] GetFilesAndFolder(string folderPath, int version)

        {

            return FilterByVersion(cache.Get(folderPath), version);

        }

        private string[] GetFolder(string folderPath, int version)

        {

            var files = GetFilesAndFolder(folderPath, version);

            if (files == null)

               return null;

            foreach (string file in files)

            {

                if (file == folderPath)

                {

                    return new []{folderPath};

                }

            }

            return null;

        }

        private string[] GetAllFilesAndFoldersIn(string folderPath, int version, bool rootIncluded)

        {

            var allFiles = new List<string>();

            var files = GetFilesAndFolder(folderPath, version);

            foreach (string file in files)

            {

                if (file != folderPath)

                {

                    allFiles.AddRange(GetAllFilesAndFoldersIn(file, version, true));

                    allFiles.Add(file);

                }

                else if (!rootIncluded)

                    allFiles.Add(file);

            }

            return allFiles.ToArray();

        }

    }

And there are a few tests too, just to make sure everything works as intended. ;)

        [Test]

        public void get__should_return_the_files__when_key_exists()

        {

            var target = new PersistentCache();

            var key = "/";

            string[] values = { "/", "/foo" };

            target.Set(key, values);

            string[] actual = target.Get(key);

            Assert.IsTrue(ContainsAllIn(actual, values));

        }

        [Test]

        public void old_values__should_persist__when_adding_new_ones()

        {

            var target = new PersistentCache();

            var key = "/";

            string[] values = { "/", "/foo" };

            target.Set(key, values);

            string[] otherValues = {"/foo/bar", "/test.txt"};

            target.Set(key, otherValues);

            string[] actual = target.Get(key);

            Assert.IsTrue(ContainsAllIn(actual, values));

            Assert.IsTrue(ContainsAllIn(actual, otherValues));

        }

        [Test]

        public void get__should_return_empty_array__when_key_does_not_exist()

        {

            var target = new PersistentCache();

            var key = "/";

            string[] values = { "/", "/foo" }; 

            target.Set(key, values);

            var key2 = "boo";

            Assert.IsNull((target.Get(key2)));

        }

        public static bool ContainsAllIn(string[] actual, string[] array)

        {

            var actualValues = new List<string>(actual);

            foreach (string s in array)

            {

                if (!actualValues.Contains(s))

                    return false;

            }

            return true;

        }

    }

    [TestFixture]

    public class FileSystemCacheTests

    {

        readonly PersistentCache cache = new PersistentCache();

        private FileSystemCache fsc;

        [SetUp]

        public void SetUp()

        {

            fsc = new FileSystemCache(cache);

            fsc.Add(new[]

                        {

                            new VersionedFile {Version = 1, Name = "/"},

                            new VersionedFile {Version = 1, Name = "/foo"},

                            new VersionedFile {Version = 1, Name = "/foo/bar"},

                            new VersionedFile {Version = 1, Name = "/foo/bar/text.txt"},

                        });

            fsc.Add(new[]

                        {

                            new VersionedFile {Version = 2, Name = "/"},

                            new VersionedFile {Version = 2, Name = "/foo"},

                            new VersionedFile {Version = 2, Name = "/foo/bar"},

                            new VersionedFile {Version = 2, Name = "/foo/bar/text.txt"},

                            new VersionedFile {Version = 2, Name = "/test.txt"},

                        });

        }

        [Test]

        public void should_be_able_to_get_files__without_recursion()

        {

            var actual = fsc.ListFilesAndFolders("/", 1, Recursion.None);

            Assert.IsTrue(PersistentCacheTest.ContainsAllIn(actual, new [] { "/" }));

        }

        [Test]

        public void should_be_able_to_get_files__with_one_level_recursion()

        {

            var actual = fsc.ListFilesAndFolders("/", 1, Recursion.OneLevel);

            Assert.IsTrue(PersistentCacheTest.ContainsAllIn(actual, new [] { "/", "/foo" }));

        }

        [Test]

        public void should_be_able_to_get_files__with_full_recursion()

        {

            var actual = fsc.ListFilesAndFolders("/", 1, Recursion.Full);

            var expected = new[] {"/", "/foo", "/foo/bar", "/foo/bar/text.txt"};

            Assert.IsTrue(PersistentCacheTest.ContainsAllIn(actual, expected));

            expected = new[] { "/", "/foo", };

            actual = fsc.ListFilesAndFolders("/", 1, Recursion.OneLevel);

            Assert.IsTrue(PersistentCacheTest.ContainsAllIn(actual, expected));

            actual = fsc.ListFilesAndFolders("/", 2, Recursion.OneLevel);

            expected = new[] { "/", "/foo", "/test.txt" };

            Assert.IsTrue(PersistentCacheTest.ContainsAllIn(actual, expected));

        }

    }

Ayende's Challenge

2008-04-09T22:36:00.008+02:00

Ayende challenged the whole intarweb to resolve a problem similar to the ones he uses in his job interviews. It goes like this:

The task is listing the first 10 products that we can sell to a customer. The UI is console application, and the database design and data access method are whatever you want.

Additionally you have to filter those products according to some arguments given as input parameters to the application (representing different categorizations of products).

Now, my solution. :)


    public enum Category
    {
        PG13,
        Vegetarian
    }

    public class Product
    {
        public string Name { get; set; }
        public decimal Price { get; set; }
        public IList Categories { get; set;}

        public override string ToString()
        {
            return string.Format("{0}\t{1}", Name, Price);
        }
    }

    public class Filter
    {
        public static IEnumerable ApplyFilter(IEnumerable products, Category category)
        {
            return from p in products where p.Categories.Contains(category) select p; 
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var categoryMapper = new Dictionary
                                     {
                                         {"-pg13", Category.PG13},
                                         {"-vegetarian", Category.Vegetarian}
                                     };

            var products = new List
                               {
                                   new Product {Name = "Milk", Price = 1.0M, 
                                       Categories = new List {Category.PG13, Category.Vegetarian}}, 
                                   new Product {Name = "Bread", Price = 1.3M, 
                                       Categories = new List {Category.PG13, Category.Vegetarian}},
                                   new Product {Name = "Sausage", Price = 2.5M, 
                                       Categories = new List {Category.PG13}},
                                   new Product {Name = "Horror Movie", Price = 5.0M, 
                                       Categories = new List {Category.Vegetarian}}
                               };

            var filteredResults = (IEnumerable) products;
            foreach (string arg in args)
            {
                if (categoryMapper.ContainsKey(arg))
                {
                    filteredResults = Filter.ApplyFilter(filteredResults, categoryMapper[arg]);
                }
            }

            filteredResults = filteredResults.Take(10);

            foreach (Product product in filteredResults)
            {
                Console.Out.WriteLine(product);
            }
        }
    }

You better don't break the build

2008-04-06T19:52:00.002+02:00

/trunk must compile and pass regression tests at all times. Committers who violate this rule are publically humiliated.

-- svn best practices

I Know What You Coded Last Summer

2008-02-18T21:53:00.006+01:00

At all times, I want to produce code that is readable, maintainable and simple. [...] [I]t is considered polite to do this in a manner that would make sense to the next developer that would have to touch this code. [...] A good suggestion that I take to heart is to assume that the next developer to touch your code is an axe murderer that knows where you live, and has a very short fuse.

-- Ayende, Building Domain Specific Languages in Boo

Returning null vs. Empty Collection/Default Object

2008-01-24T21:57:00.000+01:00

In a nice thread on the cli_dev list (formerly altdotnet) they discuss whether you should return null or an Empty Collection/Default Object when a query returns no results.

There is a more or less common approach I agree with of returning a null collection when your query yields no results, like in GetUsers(), being therefore able to iterate it with a foreach(User user in GetUsers()) witout having to use safe-guards.

I think Luke Breuer makes a good point too in this post when talking about retrieving a particular result:

I like null checks to actually have significant meaning. I've actually adopted a convention -- GetAwesomeObject will return a valid object or throw; FindAwesomeObject might return null. The idea is that a NullReferenceException means you really screwed up somewhere -- you have a glaring logic error, because you didn't account for possible emptiness.

2008 will be the year of...

2008-01-12T13:29:00.000+01:00

Linux.
Hehe, I'm kidding. I think 2008 will be the year of Test Driven Design. I know it has been already there for a long time already, but I hope that it will become mainstream with the final release of the ASP.NET MVC framework Microsoft is releasing this year.

Well, in fact, depending how long it takes for them to ship it, it may actually take a bit longer to be widely used tough, but I'm happy this is going to be finally adopted for web development.

ASP.NET 2.0 Page Life Cycle

2008-01-10T17:55:00.000+01:00

Geez, I better move onto ASP.Mvc than learn the inner tricks of all that stuff. Seriously.

Via Steve Pietrek

Nullable Types and the Coallescence Operator

2007-12-12T21:26:00.000+01:00

I'm going to talk a bit about a couple of nice features introduced in .NET 2.0. It's nothing new, but it's sweet anyway.

Nullable Types
Nullable types address the scenario where you want to be able to have a primitive type with a null (or unknown) value. This is common in database scenarios, but is also useful in other situations. This is a PITA to deal with in .NET 1.1, and you have to do some boxing or wrapping to get along with it.

Since .NET 2.0 we have Nullable Types, a much cleaner way to do it.
Nullable Types are declared either as:
System.Nullable variable
or the simpler way:
T? variable
where T is the underlying type of the nullable type. T can be any value type including struct; it cannot be a reference type.

Examples of Nullable Types:

int? i = 10;
double? d1 = 3.14;
bool? flag = null;
char? letter = 'a';
int?[] arr = new int?[10];

To do a null check we could write:
if (i.HasValue) {...}
but again we can just simplify it to:
if (i != null) {...}

Nevertheless, there are a few things to consider when dealing with nullable types:

Exceptions:

int? n = null;
//int m1 = n;      // Will not compile.
int m2 = (int)n;   // Compiles, but will create an exception if x is null.
int m3 = n.Value;  // Compiles, but will create an exception if x is null.

Operators:

int? a = 10;
int? b = null;
a++;         // Increment by 1, now a is 11.
a = a * 10;  // Multiply by 10, now a is 110.
a = a + b;   // Add b, now a is null.

Comparisons: If one of the nullable types is null, the comparison evaluates to false

int? num1 = 10;
int? num2 = null;
if (num1 >= num2)
{
    System.Console.WriteLine("num1 is greater than or equal to num1");
}
else
{
    // num1 is NOT less than num2. --> WRONG ASSUMPTION!!! 
}

The bool? nullable type can contain three different values: true, false and null. As such, the cannot be used in conditionals such as with if, for, or while. It would give a compilation error.

bool? b = null;
if (b) // Error CS0266.
{
}

The ?? (Coalescence) Operator
The ?? operator defines a default value that is returned when a nullable type is assigned to a non-nullable type.

int? c = null;
// d = c, unless c is null, in which case d = -1.
int d = c ?? -1;

This operator can also be used with multiple nullable types. For example:

int? e = null;
int? f = null;
// g = e or f, unless e and f are both null, in which case g = -1.
int g = e ?? f ?? -1;

Don't fear the unknown

2007-12-12T19:08:00.000+01:00

"If we only code to what the lowest-common-denominator can do then we're never going to get anywhere."

James Gregory

In other words. If the problem is the coders, not the code, change the coders, let the code alone.

Get a Build Server and Keep it Clean

2007-12-12T11:23:00.000+01:00

One goog tip from Jeremy Miller on continuous integration is to generate your builds in a separate server to detect early problems with dependencies with libraries from Visual Studio, some third-party or whatever you might have in the GAC.

Public fields vs. Public properties

2007-12-12T01:13:00.000+01:00

ScottGu blogged some time ago, among other interesting things, about the difference between public fields and public properties.

I had always seen comments about the convenience of using public properties instead of public fields, but I hadn't seen a real explanation until now. I tought, "why should I bother writing a getter and a setter? If I just use a public Foo field, I can refactor it into a Property if it turns out I have to." It seems I wan't the only one that thought this very same thing.

But it turns out there are some differences:

You can't databind against a variable.
Changing a variable to a property is a breaking change. When you change a field to a property you need to re-build all code that used that field.
Reflection works differently on variables vs. properties, so if you rely on reflection, it's easier to use all properties.

There are some other relevant points in both posts.
From Jeff's:

Distinguishing public and private using only case is an accident waiting to happen. I still don't have a clear view if I should be using _bar = bar or this.bar = bar.
Is it a property or a method? A property should do less work-- a lot less work-- than a method. Properties should be lightweight. If your property incurs significant effort, it should be refactored into an explicit method.

From Scott's, there is some syntactic sugar for C#3 (or is it 3.5?):

Automatic Properties
This cleans up our classes from all the innecesary private fields.

public class Person {
public string FirstName { get; set; }
   public string LastName { get; set; } 
   public int Age { get; set; }
}

Object initializers
Allow you to atomically initialize an object lacking an appropiate constructor. More on this.

Person person = new Person { FirstName="Scott", LastName="Guthrie", Age=32 };

Collection initializers
Same annonymous methods, but applied to collections.

   List people = new List {
    new Person { FirstName = "Scott", LastName = "Guthrie", Age = 32 },
    new Person { FirstName = "Bill", LastName = "Gates", Age = 50 },
    new Person { FirstName = "Susanne", LastName = "Guthrie", Age = 32 }
 };

Write your test first... because adding them later sucks

2007-12-10T19:44:00.000+01:00

So true. As jason points out:

It's boring. Write the obvious tests. Check code coverage - what did I miss? Write more tests capturing more edge cases. Wash, rinse, repeat. Ugh.
It's not trivial. I'm trying to put tests around code that was created months ago, and trying to capture the mental state of the coder and what he was doing is damn near impossible.

If you write the test first, you get all the benefits of TDD.

You don't get just unit testing, but instead you let your design lead your development.
As you are writing the minimum code necessary to achieve the behaviour your test is checking, you end up with full code coverage.
You can refactor as you test-and-code (and test, and code,...), and you have your tests to cover your ass as you go. If you need to refactor when it's all finished, poor you. You are just left out in the wild.

The Peter Principle

2007-12-09T16:18:00.000+01:00

"In a hierarchy every employee tends to rise to his level of incompetence."

-- Laurence J. Peter. 'The Peter Principle', (1969).

This principle states that in any company or organization, people who do their job right get promoted to higher responsibility jobs repeteadly, until they end up in a job they are incompetents for.

The logic behind this theory is that recruiting people for a new vacancy look first for the people already working in the organization. If an employee is performing well in his current duties, they feel he deserves to be promoted and deduce he will be equally efective in the new role. So, this employee will keep promoting while he is competent, and therefore he will eventually end up in a post he is no longer apt for, and he will get stuck in it.

As a consecuence, we can infer that many high-end positions are occupied by people who don't have enough qualifications for their jobs, and this leads to big mistakes in the decision being made by people leading those organizations.

Thus, the Peter Principle is a big warning for people involved in the recruiting process. The requirements for the new job must be defined clearly, and when analyzing the aptitudes of existing employees for the vacancy, those people should be treated as any other applicant, despite of their efficiency at their current tasks.

Handling library dependendancies

2007-12-09T16:03:00.000+01:00

It seems some smart people is taking the same approach I have ended up with in my projects. I still don't like it very much, but it seems the only way to go until we have a complete continous integration environment, fully backed-up by TDD, a consistent versioning policy and a tool like Maven to handle those dependencies for us.

Software is art

2007-12-07T03:49:00.000+01:00

"Software design is an art, and like any art it cannot be taught and
learned as a precise science, by means of theorems and formulas."

-- Domain-Driven Design Quickly, by Abel Avram & Floyd Marinescu

Did you think your shit didn't stink?

2007-12-04T08:01:00.000+01:00

"No matter how good the code you write is, it’s crap to another developer."

-- Phil Haack

Next time I am honored with some unmanageable code, before I start swearing, I'll try to remeber all the crap I endep up doing under deadline pressures.

What tests are for

2007-12-04T01:05:00.000+01:00

"Tests are absolutely not for checking to see if things went wrong. They are for articulating what code should do, and proving that code does it."

-- Giles Bowkett