New-age Transactional Systems - Not Your Grandpa's OLTP
John Hugg discusses high volume transaction processing applications with high and low frequency profiles, and how VoltDB can be used for that purpose.
The content has been bookmarked!
There was an error bookmarking this content! Please retry.
Posted by Amr Elssamadisy on Nov 13, 2007
The original definition of a retrospective, as presented by Norm Kerth, was a 3 day, offsite meeting. Since then, the Agile community has co-opted the practice and made it part of every iteration. In, Agile Retrospectives, we are given 5 phases to be covered, but no specific guidance on time. In her recent article, Refactoring Your Development Process with Retrospectives, Rachel Davies suggests that we have 30 minutes per week under review. In many teams I have seen first hand, they tend to minimize the time for retrospectives - even as little as 15 minutes. How long should a retrospective be to be effective?
Esther Derby and Diana Larson, in Agile Retrospectives, tell us that each retrospective should cover the following phases:
For each of these phases, they give several different practices that can be used to effectively perform the phase(such as Mad/Sad/Glad for gathering data). But perform all the phases, it takes over an hour (probably no less than two). If you are running one or two week iterations, are you willing to put in two hours for a retrospective at the end of every iteration?
In Rachel Davies' paper, she suggests 30 minutes for each week:
A rough guide to timings is a team need 30 minutes retrospective time per week under review so using this formula allow 2 hours for a monthly retrospective and a whole day for a retrospective of a several months work.
Does this imply that we should be having retrospectives no sooner than once a month? Or does that mean we should have 30 minute and hour long retrospectives for one week and two week iterations respectively? And how do we fit in all the phases in the shorter retrospectives?
Finally, many teams on the ground practice 15-30 minute retrospectives that don't have all the phases. They get little to no value out of this practice and end up dropping it or doing it out of habit.
So, with the varied advice and practice out there - what is the most effective? What are your experiences? Do you perform retrospectives regularly? If so, how long are they? Are they effective or wasteful?
18 agile and lean practices for effective software development governance
A practical guide to choosing the right agile tools
agility@scale eKit: 10 Principles, Scaling Model, Metrics, Collaboration
In today’s hyper-competitive world, later may be too late to adopt Agile development and this Roadmap for Success will help you get started. Download "Agile Development: A Manager's Roadmap for Success" now!
I think Rachel has a nice, simple way of dimensioning retrospectives.
However, I don't belive she implies that Retrospectives should be done no sooner that monthly. For me, it's obvious that you need to have them at strategic moments, i.e. at the end of an iteration.
My guess is that she used the "one month" value based on the recommendation from Scrum, but that she avoided mentioning the word 'iteration' in order not to dilute the point of her paper.
If I had one-week iterations, I would still have 30-min long retrospectives. But of course, I'd rather have iterations that last at least 2 weeks.
Eric's interpreted my intention accurately.
Yes, I'd recommend a retrospective at the end of every iteration/sprint and the duration of that retrospective should be proportional to the sprint length. So short sprints have short retrospectives. I also recommend every few months having a longer session that looks back across several sprints/iterations.
Yes, I'd recommend a retrospective at the end of every iteration/sprint and the duration of that retrospective should be proportional to the sprint length.
Thanks Rachel. So, have you found 30 minute or 1 hour retrospectives useful? The majority of short retrospectives I've seen end up floundering. (but it may be just my luck)
Yes, I think it's valuable to discuss experience close to when it has happened. However, for short retros I'd recommend following an proper retrospective structure (based on ORID with a timeline) rather jumping straight to "start doing" and "stop doing" actions.
It also depends on how long a team has been working together. Early in a project, I recommend spending more time on the retrospective--up to 90 minutes for a week or two-week iteration. Early retrospectives offer both a) an opportunity to consider and continuously improve product, process, and practices, and b) time for reflection on the current state of the team's collaboration skills (how they work together to create value). Investing longer time up front to create solid team collaboration pays off in later iterations by building the capacity to get the most out of 30 minutes.
The majority of short retrospectives I've seen end up floundering. (but it may be just my luck)
Why do you think the retrospectives flounder? Does it take a long time to gather data? Or is it that you are not discovering anything useful?
I find if you do them often enough you may not end up with that much valuable output. On some teams I made these less frequent, as in every two weeks instead of one and increased the frequency if I got a sense there were more issues that need resolving.
John Hugg discusses high volume transaction processing applications with high and low frequency profiles, and how VoltDB can be used for that purpose.
Kevlin Henney examines code samples to see what can be learned from them starting from the premise that one won’t write great code unless he knows how to read it.
Jason Ayers share the observations he made watching a team of developers collaborating in real time on the same code base, pushing XP, pair programming and continuous integration to their extremes.
Michael Snoyman presents Yesod, a web framework written in Haskell and containing a web server, templating, ORM, libraries (templating, gravatar, etc.).
Richard Kreuter and Kyle Banker on how to avoid classical RDBMS transactional systems by using compensation mechanisms, transactional messaging or transactional procedures.
Attila Szegedi talks about performance tuning Java and Scala programs at Twitter: how to approach GC problems, the importance of asynchronous I/O, when to use MySQL/Cassandra/Redis, and much more.
One category of risk that project teams need to ensure they address is business value failure – delivering a product that fails to provide value for the business investor.
InfoQ spoke to the authors of Software Systems Architecture on a couple of new topics, the System Context viewpoint and Agile, which have been added to the second edition.
6 comments
Watch Thread Reply