Release or Be Damned
If you aren't releasing your software in frequent increments, you aren't Agile. More importantly, your clients may be losing patience.
Join the DZone community and get the full member experience.Join For Free
Back when I was still paid to code I had a simple question I posed to troubled development efforts:
"Why can't we release tomorrow?"
This short simple question turns out to be amazingly powerful. I remember one effort I was involved with in California where a new CEO took over and started cutting jobs. I posed this question to the team and in a week or two we did a "beta release" — we did those sort of things back then. Asking this question was the key that allows us to question everything, to cut the feature list — or rather push work back; it stayed on the to-do list but we didn't let it stop us from pushing to release.
We rethought what we were trying to achieve: we didn't need the whole product, we just needed enough of the product to work to show to one specific target customer. Even if they signed there and then we had weeks before they used it in anger. But until we released something, until we had something "done" our team, our product, look like just another "maybe." We had to draw a line under it so the new CEO wouldn't draw a line under us.
Saying "only do the essential" is easy and comes up again and again, whether it is Minimal Viable Product, Minimal Subset, or Must haves in Moscow rules, but it is far easier said than done. One person's "essential" is so often another person's "optional extra." In this context, when I say "essential" I mean "the parts needed to make the system work end-to-end" — I'm far closer to the old walking skeleton idea.
I was reminded of this question by a couple of endeavors that came to my attention during the summer. Well, I say came to my attention, I feel a bit responsible. Both endeavors are happening to clients who I had fallen out of touch with. My style of working is to help clients who want help, I don't like selling myself. These clients didn't ask for more help so I didn't jam my foot in the door, although in retrospect maybe I should have.
In one case the team was doing very well. They were iterating, they were TDD/BDD'ing, they were demoing, they were working with the client, they were doing everything ...except releasing. Then one day the client asked, "When will it be done?"
Now think for a moment: What if you could release your product tomorrow?
The thing is, without actual products those around the team look for signs that the team can be trusted, that they will deliver, that the team is thinking about what is to be done. People ask for proxy-products: plans, schedules, risk-logs, budget forecasts, and so on. When stakeholders can't see progress, they look for things to assure them that there is (or will be) progress (soon).
Who needs plans and predictions about the future when the future is here tomorrow?
Actual releases are the key to reaching the new world, they change everything.
So I feel guilty: I should have inflicted myself on these teams, I should have been there again and again bugging them "Go to release", "Remove that barrier", "Force it through".
Being able to ship an update of your product has a transformative effect.
- It demonstrates the team have the ability to do the job in hand.
- It demonstrates you have quality. It obliterates the need for a test-fix-test-fix aka stabilisation aka hardening phase.
- It blows away sunk costs because something has been delivered.
- It removes "maybe" and "ready but..."
- It is probably the greatest risk mitigation strategy possible.
- It creates trust and provides a platform for solid conversations.
Most of all, a released product is a far better statement of progress than any number of plans or forecasts.
This does not mean everything is done. Sure, there are things left undone but there will be things left undone when I'm on my deathbed; that is the nature of life. As much as we (especially men) love to collect entire sets there are few prizes in life for completing everything on your bucket list.
Having a released product utterly changes the nature of the conversation. Conversations are no longer full of "ifs", "maybes", "shoulds", "How long will it take?", "What are the quick wins?". Those questions can go away. In its place, you can have serious conversations about prioritization and "What do you want tomorrow?"
This is all part of the reason I love continuous delivery. Teams can focus on real priorities and stop wasting time on conjecture.
In my book if you don't have a releasable product at least every two weeks — say, every second Thursday — you are not Agile. And if you haven't released a product to live in the last two weeks you are probably not Agile.
I don't care how close you get to a releasable product: it isn't a release if it isn't released to a live environment — "Close but no cigar," as they say. (OK, I'll accept the live environment may not be publicly known, or might be called a beta, but it has to be the real thing.)
Nor should you rest on your laurels once you have regular releases (to live) every second week. That is but first base. You have opened the door, now go further. There are at least 13 opportunities to improve.
If you cannot do that now then ask yourself: "Why can't we release tomorrow?"
And start working to remove those obstacles:
- Reduce the number of work items you are aiming to put in the release.
- Fix show-stopper defects now.
- Running tests now.
- Get those people who need to sign-off to sign-off.
Software development has diseconomies of scale: many small is cheaper than few large.
And once you have your release you can turn your attention to making sure these things don't happen again:
- Reduce the amount of work you accept into development at one time.
- Fix every defect as soon as they are found.
- Automate tests so they can run more often. (Automate anything that moves, and if it doesn't move, automate it in case.)
- Find a way to reduce the time it takes to get sign-offs: remove the sign-off, make sure the signer prioritizes signing or delegate someone else to sign (or automate the signature.)
If there are essential processes, activities, third-parties (or anything else) that has limited bandwidth which needs to be done before release but inject delay then re-orientate your process around that bottleneck. For example, if your code needs to pass a security audit before release (an audit you can't automate that is) then, downsize all the other activities so that the audit process is 100% utilized. (OK, 100% is wrong, 76% might be better, but thats a long conversation about queuing theory.)
Again and again, I seem condemned to learn the lesson: nothing counts but working software which is used.
As for my team, and my job in California, it didn't save me. I regret not asking the question sooner.
Published at DZone with permission of Allan Kelly, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.