Being Agile in Release Management
Join the DZone community and get the full member experience.Join For Free
2 great things happened in 2005: wales won the grand slam, and i had my first taste of “agile”. and after having worked on a 3-year-long waterfall project (which still wasn’t finished by the time i left) agile came as a breath of fresh air for me. i was hooked from day 1. i was working as a release manager in a fairly large development team, and since then i’ve worked in a number of different departments, such is the broad spectrum of the work involved in release management. i’ve also worked with teams of all sizes, including offshore teams and partners. each situation poses its own unique set of challenges and i like to think that working in an agile fashion has equipped me well to overcome these challenges.
you might wonder how a “development methodology” can help a release manager overcome so many different challenges, given that release management doesn’t necessarily lend itself to working like an agile dev team (mainly due to the number of unplanned interruptions) and the answer is simply that agile, for me, goes further than just being a development methodology, it’s a culture.
one of the things that i really love about agile is how it teaches you to think differently to how you otherwise might. it teaches you to evaluate things using different criteria – or rather it clarifies which criteria you should be using to evaluate tasks. for instance, i now look at the tasks that i work on in terms of business value and customer demand, rather than my value and my demand! in the past i have spent months working on complicated build and release solutions, which may well have been ultimately successful, but weren’t delivered on time and on occasion didn’t do everything that the users wanted.
these days, i certainly wouldn’t approach such a large challenge and try to get it right first time, it simply doesn’t make good business sense – it’s likely to be too costly in terms of time and effort, and by the time it eventually gets to the users it may well not be fit for purpose. adopting an agile approach certainly helps here. but it’s not quite as simple as this in real life…
thinking in an “agile way” doesn’t necessarily come naturally to release management – the solutions we’re tasked to come up with are often very complicated, need to support a multitude of projects and users, and still need to be simple and robust enough for the next person to be able to pick up. working out a system like this takes some time. the core problem in many cases is that we try to (or are asked to) produce a one-size-fits-all solution to a very disparate system. i’m talking about things like:
- we only want one ci system, but there are already 3 being used in the dev team.
- we only want to use one build tool, but we need to support different programming languages, and the developers have already chosen their favourites.
- everyone has their favourite code inspection tools but management want stats that can be compared.
- qa do things one way, dev do it another. and let’s not even start talking about how netops do it!
- deployments are done differently depending on which team you’re in, which os you use, and which colour socks you’re wearing that day.
the temptation to standardise and make things simpler leads us down a long and windy road wich invariably ends up being more complex than the problem you tried to solve in the first place. the fact is, there has to be complexity somewhere, and it often ends up in the build & deploy system!
how do i “think agile”?
well, first of all you have to stop looking at the big picture! i know it sounds crazy, but once you’ve got an idea of the big picture, instead of diving straight in and working on your sistine chapel, just write down what your big picture is in terms of a goal or mission statement, and then park it. i like to park it on a piece of a4 and stick it to the wall, but that’s just me! just write it down somewhere for safe keeping, so that you can refer to it when needs be.
i once had a goal to standardise and automate the builds and deployments of every application to every environment, a-la continuous delivery. at the time, that was my sistine chapel.
the next thing is to start gathering requirements in the form of stories. user stories help you get a real feel for what the users want – they give a sense of perspective and “real-life” which traditional requirements specs just don’t give. i honestly believe you’ve got a much better chance of delivering what people are asking for if you use stories rather than use cases or requirements specs to drive your development. speak to your customers, the developers, testers, managers and netops engineers, and write down their requirements in the form of stories. i literally go around with a pen and paper and do this. don’t forget to add your own stories as well – the release engineering team has its own set of requirements too!
next up is to turn these stories into tasks. some stories can be made up of dozens of tasks, and they may take several sprints to complete, but this is the whole point of this exercise. by breaking the stories down into tasks, you’re creating tangible pieces of work which you can then give relatively accurate estimates on. you’ll often find that some stories contradict one another in the sense that your solution to one story will almost definitely be rendered obsolete when you get around to completing another story later on. don’t be tempted to put one task off, just because you know you’ll end up changing it later!!
eventually, when the time comes, you will have to change the work
you’ve already done. this is the natural evolution of the process.
obviously it’s better to be future proof
and keeping one eye on the distance is a very useful thing. it would be
foolish to write a system that will need to be completely torn down in a
matter of a couple of weeks, but there’s a constant balancing act to
perform – you need to get tasks completed but you don’t want to be
making hard work for yourself in the future. my tactic is to make each
solution (be it a deploy script or a new ci system) self-contained, and
only later on will i refactor and pull out the common parts – but the
point to realise is that this won’t come as a surprise, and you can make
sure everyone knows that this work will eventually need doing as a
customers and prioritisation
i’ve learned that all stories must have a sponsor, or “customers”. as i’ve mentioned, these are likely to be developers, testers, management and netops engineers, as well as yourself! strangely enough the customers are actually a really handy tool in helping you manage your work…
there’s never enough time in the day to get everything done, or at least that’s the way it often seems when you’ve got project managers hassling you to do a release of the latest super-duper project, and management asking you automate the reports, and developers asking you to fix their environments, and then your source control system throws a wobbly. it’s organised chaos sometimes. however, when you’re working on your stories, and your stories have “customers”, you can leave it to your customers to fight it out over which work gets the highest priority! from the list above there are the following high-level tasks:
- automate the builds and deployments for the super-duper project
- automate the generation of management reports
- stabilise the dev environments
- implement failover and disaster recovery for your source control system (why has this not been done already???!!!!)
each of these tasks has a customer, and they all want them doing yesterday. simply get all the customers in a room and
then get the hell out of there
work together to sort out the priorities.
how to deal with unplanned work
probably the single hardest issue to overcome has been how to manage the constant interruptions and unplanned work. a few years back, rachel davies came in and gave us some valuable agile coaching, and from those lessons, and my own experiences, i’ve worked out a few ways of dealing with all the unplanned work that comes my way.
first of all, i’ll explain what i mean by unplanned work. i’m essentially talking about anything that crops up which i haven’t included in my sprint plan, which i have to work on at some point during the sprint . typically these are things like emergency releases, fixing broken environments, sorting out server failures and sometimes emergency secondment into other teams. “fixing stuff that unexpectedly broke” is probably the most common one!
the way i have come to deal with unplanned work is to start off by pretending it simply doesn’t exist. plan a sprint as if there will be no unplanned work at all. then, during the course of the sprint, whenever unplanned work comes your way, take an estimate of how long it took, and more importantly, make an estimate of how much time it has set you back. the two don’t necessarily equate to the same thing, i’ll explain: if i’m working on a particularly complicated scripting task that has taken me a good while to get my head around, and then i’m asked to fix a broken vm or something, the task of fixing the vm may only take an hour or two at most, but getting back to where i was with the script may take me another 2 hours on top of that, especially if someone else has changed it in the meantime! suddenly i’ve lost half a day’s work due to a one or two hour interruption. the key is to track the time lost, rather than the time taken. i record all of the time lost due to unplanned work in a separate sprint called “unplanned work”. i use acunote for this. this allows me to see how much time i lose to unplanned work each sprint. after a while i can see roughly how much time i should expect to “lose” each sprint, and i adjust my sprint planning accordingly.
one way of working, which helps to highlight the amount of unplanned work you’re carrying out, is to plan your sprints as normal, and then say to the customers/sponsors (who should ideally be represented in your planning session) “right, that’s what we could be doing without unplanned work, but now i’m afraid we have to remove x points”. this is a rather crude way of ramming home the reality of working in a department which has a higher than average amount of interruptions and unplanned work (certainly in comparison to dev/qa). it also works as a good way of highlighting the cost of unplanned work to the management team. they hate having work taken out of the sprints and when they realise that unplanned work is costing them in terms of delivery, they are far more likely to act upon it. this could mean investing in better hardware/software, reprioritising that work that you wanted to automate, or hiring more staff.
- if you’re interested to know more about user stories i highly recommend mike cohn’s book “user stories applied”.
is an agile consultant who co-authored the
“agile coaching” book
. she also runs
agile coaching courses
Opinions expressed by DZone contributors are their own.