Should I Bother?
You've never done "agile" before and you work on a legacy system which is extremely large, complex, fragile and bug-ridden. I'm guessing quite a few developers will be able to identify with this scenario. Does this mean "agile" is a no-go? On the contrary, applying "agile" techniques will probably make it easier to fix those bugs, faster and in the process improve the code just a little bit.
Here are my tips (prerequisites) before attempting "agile" within a legacy project:
- Remove blockers
- Legacy builds tend to be painfully long - setup an environment that allows you to build and test the changes you will make quickly.
- Protect yourself
- The changes you'll want to make are probably buried extremely deep within existing methods - use refactoring to pull out the code you want to change into a new method/class.
- Write tests that capture the existing functionality of the code you just extracted.
If it is too difficult to perform any of the above steps then don't bother with "agile" just yet (although by all means apply pragmatism), choose your "agile" battles carefully and you'll live to fight another day.
Simple isn’t Easy
After 2 days coaching on test first development within a legacy code-base (lots and lots of refactoring) it really hit home just how difficult it can be to do something simple. The English language doesn't help, because simple implies it should be easy, but in reality simplicity is extremely challenging. I suspect this holds true in many fields (physics springs to mind, how long did it take for e=mc²).
I'm left wondering whether it is something inherent in human nature that leads us to strive complexity or whether it is actually the way we are educated. Certainly, with regards to software engineering the majority of the agile techniques and practises appear to contradict what is being taught in universities. The comment I hear most often when coaching Test First Development is that the difficulty is in thinking backwards, suggesting that the practise itself isn't difficult per se, but it's the way we think that needs rewired.
Of course, not knowing what the problem is makes it difficult to formulate a solution - now there''s a real challenge for agile
Emotional Agile – Weather Poker
Ever since I attended a session by Rachel Davies on Project Mapping at SPA 2005 I have been interested in simple ways to use emotions to engage teams. On a recent gig for exoftware I introduced weather poker at the end of the daily stand-ups as a way to measure the feelings of the team.
In essence, each member of the team was given cards with weather symbols ranging from thunder to sunny. We would then take a vote on what yesterday felt like and average out the results. A larger image was then made highly visible on our information radiator for all to see. Despite this being a small experiment, it did look like this was a very quick and effective way to allow the team to express how they were feeling. Indeed, the one day when the team decided to display the thunder symbol lead to an intense interest from the on-site customer.
If you would like to try this in your team, I have attached a pdf with the cards ready to print and laminate.
PDF: weather-poker
Pair Programming from the Trenches
On a recent gig for exoftware I introduced pair-programming to a (very) small team and over the course of the engagement we held regular retrospectives specifically about how the pair programming was going. This was very much an exploratory exercise for a substantial company and the findings were extremely encouraging. To really benefit from pairing does require some major organisational and cultural changes and this is very early days, but fingers crossed...
Of course, when pair programming is done well, with a group of experienced developers the benefits are enormous, and if you're wondering what pair programming really means, then the following article from Rod Hilton sums it up extremely well...
http://www.nomachetejuggling.com/2009/02/21/i-love-pair-programming/
This not only provides an insight into the life of someone doing pair programming, but also hints to the true benefits of pair programming, which is always a tough sell...
My Agile Awakening
I've considered myself to be an agile developer (albeit of the pragmatic/lazy style) since the very early days of XP and through the course of my career have had the opportunity to experiment with most of the practises and methodologies in various 'flavours', but it wasn't until I joined exoftware at the start of this year that I truly appreciated what agile truly means.
"Agile" as a term has been niggling at me for years, because it has no clear defining definition, leading to abuse where everyone can, and often does, claim to be "Agile". Similarly, methodologies are extremely quick to jump on the bandwagon and claim to be agile (this is a topic for a future rant).
It is even more frustrating when there are so many purists out there advocating methodologies under the banner of agile. I'm sorry, but this just doesn't cut the mustard, if you're doing pure XP, you're an XP shop, but that doesn't necessarily follow that you're agile. Yes, the technical practise may be extremely good, but that doesn't mean the process is...
In just a few months at exoftware I have been fortunate enough to witness how a truly agile team doesn't follow any particular methodology, but continually improves their own processes, borrowing practises and techniques from any methodology. This sits extremely comfortably with me and confirms my beliefs of what agile is (mainly gleaned from Alistair Cockburn). But the surprise wasn't that agile should be pragmatic in it's application, but that in order to improve your agile process the best techniques and practises are themselves agile.
As an example of true agile, is there any real/substantial difference between an iteration, timebox or a sprint. I'm going to be happy to call this whatever the customer wants provided we can both agree a clear definition of what it means. And rather than get into the whole what does done mean, lets choose a term that means something in the customers context. Purists will have you release to production at the end of every sprint, but this will simply never fly for many large organisations (would you really want your online banking application being updated every 2 weeks with new features that had not been rigorously tested). Similarly, will I get bogged down in ceremony about when to hold a retrospective, of course not, I'll use them whenever I feel there is an opportunity to learn or adapt. I'll apply them not only to the deliverables, but also to the process being used to deliver.
The elitism inherent with many of the methodologies (and lets not forget the software craftmanship alliance) doesn't help with agile adoption, it just makes everyone else feel inferior... Wouldn't it be great if the team that brought us the manifesto got back around the table and gave us something SMARTER (specific, measurable, acceptable, realistic, timeboxed, energising, rewarding) rather than a few open-ended, fluffy statements so clearly open to abuse...





