Domain Driven Design promotes the usage of an Ubiquitous Language, in a line, we should all speak the same language, from developers to domain experts.

So it happened that the project were I am it’s a financial one: FiX messages routing…

There’s always an on boarding time, a learning curve with a new domain…
But here things are slightly more complicated than usual…

The most important object of the system is a Fix Message.

It’s an interesting plain object with around a thousand of fields…

There are nice implementation like the mebeliQuickFix one where there’s some object oriented design… (not a surprise, ThoughtWorks was a big contributor of that project) but since we’re working with legacy code the choice in the current system it’s the Cameron implementation, where the APIs are something like message.setField(109, toSomething) or message.getField(115)!
But that’s not the point of the post.
The first days we built up to improve the current code coverage a nice FixMessageBuilder, to build up for us Cameron Fix messages with speaking names and fluent interfaces, just to understand what we are doing. As you know and as it’s valid for the internet protocol remembering letters and names it’s easier than numbers, right?
So another important thing that Domain Driven Design promotes is talk as much as possible with the client, with the Analysts, and that’s what we did.
And we were talking about OnBehalfOfCompID, ClientID and so on… With the result of being almost misunderstood or having always a reply back like ah, OnBehalfOfCompID, right, you mean 115!
We then moved (Shenmebeli first to be honest) speaking like them, there was no choice, I’m still struggling talking like a calculator. A typical (simplified!) conversation will now look like:
A message with 35=D and 15=AUD or 100=AX should not go to Fidessa.
Is there anything more agile than changing our language to better fit into the customer needs?
It’s all your fault Eric Evans!

More on financial fun soon, since the next step is a Domain Specific Language for playing with these things

What is a spike?
That question came out at the second Hong Kong Agile meeting, last Wednesday.
I was surprised, a spike was something in my base knowledge, something obvious.
I think I’ve learned first the world spike in a programming context rather than spike in any other context.
Probably is not so obvious and makes sense to blog about it.

knowledge spikes

My first spike was quite few years ago, on my first medium size Enterprise project.
The aim of the spikes was to understand a current system, from the database layer to the UI.
It was pain, I still remember it. It took me almost a week, asking help many times, it wasn’t an XP project.
At the end of the exercise I was able to understand very well the system, and able to contribute well on the project.
The code produced was checked in. To provide context, knowledge for future joiners in the project. Code that should not run in production.

Basically it was a main class, instantiating all what you need to start up the full system.
I’ve to say that the codebase was definitely casinospiele mit echtem geldwinners online casinocasino roulette spiel,online roulette spiel,roulette spielonline casino downloadjack black downloadonline video pokerall slotstop online kasinocasino online downloadkasino im internetcasino kostenlos spielenlotto onlinebeste spiel raumslot maschine online spielenslotmachine spielenmobiles casinobaccarat spielenroulette tipsblack jack online spielencasino downloadcasino online wiesbadenslot machines online spielengratis casino spielenroulette online spielencasino slots download,casino slots,casino slots gamesonline casino softwareamerican slotscasino online testein armiger banditcasino websiteinternet gewinn spielswiss casino bonus codeonline casino gamescasino online shoprealistische online spielbankvideo poker strategieonline baccarat spielecasino poker rouletteonline kasino,online kasino pl,online kasino spielen auf deutschcasino online slotswww casino spieleeve online rig slotsvideo poker onlineonline casino bonus ohne einzahlung,online casino bonus,online casino no deposit bonuscasino online österreichcasino online ohne einzahlungcasino club comcasino online comcasino club poker bonusslot machine spielen well designed, otherwise doing such an exercise cold be very very diffult.

spikes checked-in?

Conrad, while giving his presentation with Tom on Agile techniques stated that there should be no check in of the code, since that code should never go on production.
I disagree on most cases, there’s always a value on the spikes.

The only spikes I would not check in are my personal trials to understand what’s going on, crappy code that I would not show us to anybody, so ugly that it doesn’t deserve the honor to go on the code repository: One shot spikes.

design sets spikes

On my last project with Pat we tried different design sets (also including technology decisions) for a big problem of redesign/refactor we had.
Also in that case we put the code under version control. Why? For future joiners for instance, these was what we tried, the solution that won it’s on the trunk, the failures on a sperate trunk folder, spikes can be a good name right?
I’ll take the same approach also starting a new project. Let’s pretend I’ve to start a new java project, an app with a database layer. You can spike the database access with Hibernate, with Ibatis, with EJBS, etc…
It will help you in estimating future stories, in the understanding on how much the chosen solution is testable.

estimations?

A spike should always be estimated, a fixed amount of time can be allocated during an estimation session.
A spike should always achieve a final goal.

If a spike screw completely the estimation throw it away, something is wrong, probably the design, the technology you’re trying to use is too complex to play with it, don’t insist on.
Throw away but check it in, even if not working, on the spikes trunk! I can’t imagine any better documentation for new joiner to justify, to explain, that’s why we didn’t use EJBs, look at that!
Shall I write tests doing a spike? Why not. If you’re trying to find a design I can’t imagine anything better that some old good TDD, if you’re trying to understand the system you can write a main if you’re not familiar with tests or just some tests. A spike can be made of tests.

more on the web…

Take a look also on the definitions on C2.com.

XP.org has his definition as well.

On the italian XP mailing list, Tommaso Torti asked an interesting question to the list few days ago.

When do you define a team ‘mature’?

Translating myself, my reply was something like:

A mature team is a team that implements at its best the theories written on books, that makes concrete what’s on paper in value for the client.
It’s cohesion and communication.
A team that’s mature is a team that hasn’t nothing to do anymore, it’s mature, can still improve?
In my very personal opinion it’s a death team, the mission is achieved, it’s time to change, it’s time to shuffle the cards. Roll in new people, change.

Some other interesting replies to the question:

PierG wrote:

A mature team is a team robust to change, wich means that it’s able to change without crumbling the process.

Francesco, being a strong XPer wrote:

A mature team is a team that doesn’t need a manager, a project leader, an architect or a designer in order to produce results. It’s able in an autonomous way to increase its own productivity.

Luca Minuduel quotes from the website of Joseph Pelrine:

* Flexible and responsive to changing organisational conditions and wider environments.
* Able to work with pressure, uncertainty and disagreement.
* Able to be self-organising and self-regulating.
* Maximise the strengths and creativity of each team member.
* Satisfies both organisational and individual needs

and Marco:

A system in equilibrium naturally tends to resist to change and that’s why we need to apply a force (questions/retrospectives/etc for people, splitting for stories, refactoring for code), because we need to take the system at the edge of chaos to facilitate the emergence of a new, spontaneous configuration.

Definitely a nice conversation, and for you what’s a mature team?

Recently we migrated all our build scripts from a combination of bat files + msbuild to a couple of NAnt build files.

There are some reasons for this and some nice outcomes.

Reasons

First of all we wanted to have the same build scripts for Development, CI, QA, UAT and production Environment.

On the Dev machines we need to build, test and install few services (ms services, a web service and a web app).
On Cruise same as above but no installation of the services and, indeed some publishing of the artifacts.
The QA environment is as close as possible as the UAT/Production: it just needs installation scripts and a way to get the latest artifacts published by Cruise.
Using the same script gave us a great confidence when going to production: scripts were used every day by the QA, no surprises when going live.
We got completely rid of all the .bat files for 2 main reasons: they become messy after 1 year of patches/fixes/modifications and we can’t really achieve the goal of one script for all as we wanted.

After a short investigation on alternatives to bat+msbuild (boobs and rake) we went for nant.
We found boobs quite difficult to use and install (you need to build some libraries, install boo, etc…), in other words it does not came for free. Rake is a cool solution, we didn’t choose that cos 1) we were too lazy to install ruby everywhere (in production especially could be a problem) 2) our build, even if includes a client app, four services, a web app and a web services is fairly simple.

Nant is really a good translation from the Java Ant. It’s actually more than a one to one translation, it has more features and it’s somehow more powerful.

I really liked the functions for example. And the contrib project is plenty of nice, useful tasks ready to use.

Another important improvement on the build scripts was on the database scripts.
Again, migrated from few bat files to one script for all the needed tasks.
We had a lot of satisfaction using dbdeploy.net, it really speeds up the work, especially in the QA environment migrating the DB schema to the latest version keeping the data in.

Outcomes

Life easier for everybody: instead of calling a bat files with some parameters we had a file of properties (not a lot of properties, convention over configuration!) for each environment, it’s now harder to fail an installation. It’s also more clear of what’s going on thanks to the nant output log.

Maintenance it’s easier. There are only two files that you need to know. Tasks are pretty short and responsibilities isolated.
We kept also a low lever of dependencies avoiding imports and more than two level of dependency.

Sometimes rewriting everything from scratch is much easier than refactoring / patching.
It has been also interesting to write a build file after one year of development, usually it’s one of the first things you do in your project.

My suggestion is: if your build script causes problems, waste of time or if it just smells and it’s not clear what’s doing, try to spike out a different solution, the benefit could be enormous.