Skip to main content

Wrapping Scrum in Evolutionary method(s)

The best grade I ever achieved in college (apart from English) was of all things in the subject of statistics. It wasn't particularly fun or fascinating for me. It was just easy, the rules were straight and the formulas were logical (well, I kinda dropped off when we reached quantum statistics, but luckily that wasn't within the curriculum).

The reason I mention it it that I just came back from this 3-hour presentation about Evo Project Management, signed Tom Gilb and Junior (Kai Gilb). In short, Evo is an agile method focused on measurements. They have a lot of other sound agile practices in there, but that's the main thing ringing in my head after the presentation: They use measurements to aid them in prioritizing the backlog.

Now Tom's been around the Oslo agile scene for quite a while, he did a presentation in XP-meetup a year ago. I also saw him around on the Smidig 2007 conference, doing an open-space on agile estimation or something.. Didn't attend it myself unfortunately (well, I even managed to miss my own open-space for that matter). Anyhow, this stuff isn't new to me, but it's good to get some freshup on it, cause each time I hear about it I think "this is good stuff that makes sense!".

And sense it makes. For instance, Kai started off by presenting the problems with requirement specs today: Requirements are expressed through describing the solution. By example: "Requirement 12a: The solution must be password protected.".

What's the problem with requirement 12a above? It describes the solution instead of stating the real requirement: Security. First state your requirements as qualities, then state the level of quality: The solution should be so secure that it takes a professional security-team more than 4 hours to break in.

Maybe your solution is better off using a fingerprint-scanner or smart-card solution for security.

State your requirements, make measurable goals, then let the developers decide on what solutions best serve the requirements.

This makes sense because it gives you a better way of saying when you're done with a task (big problem in agile methods).

In the long run, the method becomes a self-fulfilling prophecy. If you measure the implementations by their rate of measured of success, it means your discovering which developer efforts are making you money. Supposedly, the method has a track-record of zero failures recorded by the Gilbs. If one follows the method strictly, I'm not surprised. You will only do stuff that proves to reward yourself or your customers.

There is plenty of free documentation around on the subject, so I suggest you take a read, starting off with the Gilbs' blog.

Now onwards to the problems of the methodology. One of the last things that were said in the course was that it is a top-down method only. Errmmright. That will be a problem, being the floor-mopping, monkey-coder low level consultant with no political power that I am (I have to sneak stuff in) :)


So here we are: It's not a how-to, but more of a 10 ideas to get you started measuring success bottom-up for average agilists:

1. Learn statistics! Or Zed will kill you.

2. Managers love numbers, statistics and proof. Show them concrete figures and they will love you for it.

3. Try to avoid absolute requirements (meaning political requirements, or solution constraints). If you do get them, try to connect to a quality requirement - "Why do you want XHTML-compliance? Oh, usability, well there are plenty of other things we can do for usability that will be much cheaper and more effective than trying to be XHTML-compliant.."

4. Put some numbers on your backlog. If you've already got an agile method in use in your project, you've probably got a backlog shoved full of requirements (we've got more than we could ever hope to achieve in 2 years). Apply measurable goals to those tasks that you can do so for. "Fixing that bug will probably increase up-time to 5 nines."

5. Other things you could perhaps measure: Traffic in your webapp, number of error-lines in your log-files, number of sales. You're probably already measuring velocity on the function points you are delivering each sprint, but be sure to measure the tasks in something else than hours (measure them in difficulty/complexity and/or business value points).

6. Measure time-to-fix period. This could come in handy when convincing management to buy into larger rewrites/refactoring efforts. Right now, our mean time to get a larger functionality fix into production is 2-3 sprints. Given refactoring module X, the time will be reduced to 1 sprint.

7. Don't kill yourself measuring. Like in any other practice, be reasonable and use common sense. If it's gonna take you 2 weeks to get a web-traffic analyzing Apache instance up and running in front of your website, drop it (and put Google Analytics in or something). Use subsets, subjective input (you don't have to use empirical research data to measure), quick'n'dirty measurements.

Well, I'll try applying the list above when I get into work tomorrow. If I achieve anything remarkable with it I'll post back on the subject later. My biggest worry is that the backlog is choked with political requirements that are not based on measurable factors. Priorities are partly based on which stakeholder has got the biggest mouth or the biggest money-bag.


  1. Good post. Maybe you'd like to do a Lighning talk about this sometime in the future?

  2. Will just need to gather some more data for a couple o' sprints ;)


Post a Comment

Popular posts from this blog

Open source CMS evaluations

I have now seen three more or less serious open source CMS reviews. First guy to hit the field was Matt Raible ( 1 2 3 4 ), ending up with Drupal , Joomla , Magnolia , OpenCms and MeshCMS being runner-ups. Then there is OpenAdvantage that tries out a handful ( Drupal , Exponent CMS , Lenya , Mambo , and Silva ), including Plone which they use for their own site (funny/annoying that the entire site has no RSS-feeds, nor is it possible to comment on the articles), following Matt's approach by exluding many CMS that seem not to fit the criteria. It is somewhat strange that OpenAdvantage cuts away Magnolia because it "Requires J2EE server; difficult to install and configure; more of a framework than CMS", and proceed to include Apache Lenya in the full evaluation. Magnolia does not require a J2EE server. It runs on Tomcat just like Lenya does (maybe it's an idea to bundle Magnolia with Jetty to make it seem more lightweight). I'm still sure that OpenAdvant

What I've Learned After a Month of Podcasting

So, it's been about a month since I launched   GitMinutes , and wow, it's been a fun ride. I have gotten a lot of feedback, and a lot more downloads/listeners than I had expected! Judging the numbers is hard, but a generous estimate is that somewhere around 2000-3000 have listened to the podcast, and about 500-1000 regularly download. Considering that only a percentage of my target audience actively listen to podcasts, these are some pretty good numbers. I've heard that 10% of the general population in the western world regularly listen to podcasts (probably a bit higher percentage among Git users), so I like to think I've reached a big chunk of the Git pros out there. GitMinutes has gathered 110 followers on Twitter, and 63, erm.. circlers on Google+, and it has received 117 +'es! And it's been flattr'ed twice :) Here are some of the things I learned during this last month: Conceptually.. Starting my own sandbox podcast for trying out everythin

Considerations for JavaScript in Modern (2013) Java/Maven Projects

Disclaimer: I'm a Java developer, not a JavaScript developer. This is just what I've picked up the last years plus a little research the last days. It's just a snapshot of my current knowledge and opinions on the day of writing, apt to change over the next weeks/months. We've gone all modern in our web applications, doing MVC on the client side with AngularJS or Ember , building single-page webapps with REST backends. But how are we managing the growing amount of JavaScript in our application? Yeoman 's logo (not necessarily the conclusion of this blog post) You ain't in Kansas anymore So far we've just been doing half-random stuff. We download some version of a library and throw it into our src/main/webapp/js/lib , or we use it from a CDN , which may be down or unreachable when we want to use the application.. Some times the JS is minified, other times it's not. Some times we name the file with version number, other times without. Some

Managing dot-files with vcsh and myrepos

Say I want to get my dot-files out on a new computer. Here's what I do: # install vcsh & myrepos via apt/brew/etc vcsh clone mr mr update Done! All dot-files are ready to use and in place. No deploy command, no linking up symlinks to the files . No checking/out in my entire home directory as a Git repository. Yet, all my dot-files are neatly kept in fine-grained repositories, and any changes I make are immediately ready to be committed: config-atom.git     -> ~/.atom/* config-mr.git     -> ~/.mrconfig     -> ~/.config/mr/* config-tmuxinator.git       -> ~/.tmuxinator/* config-vim.git     -> ~/.vimrc     -> ~/.vim/* config-bin.git        -> ~/bin/* config-git.git               -> ~/.gitconfig config-tmux.git       -> ~/.tmux.conf     config-zsh.git     -> ~/.zshrc How can this be? The key here is to use vcsh to keep track of your dot-files, and its partner myrepos/mr for o

Git Stash Blooper (Could not restore untracked files from stash)

The other day I accidentally did a git stash -a , which means it stashes *everything*, including ignored output files (target, build, classes, etc). Ooooops.. What I meant to do was git stash -u , meaning stash modifications plus untracked new files. Anyhows, I ended up with a big fat stash I couldn't get back out. Each time I tried, I got something like this: .../target/temp/dozer.jar already exists, no checkout .../target/temp/core.jar already exists, no checkout .../target/temp/joda-time.jar already exists, no checkout .../target/foo.war already exists, no checkout Could not restore untracked files from stash No matter how I tried checking out different revisions (like the one where I actually made the stash), or using --force, I got the same error. Now these were one of those "keep cool for a second, there's a git way to fix this"situation. I figured: A stash is basically a commit. If we look at my recent commits using   git log --graph --