tag:blogger.com,1999:blog-48860648346253701802024-03-19T14:44:34.970+01:00Scrum FTW - Scrum for the win!Scrum for the win. Thoughts and lessons learned during the introduction of Scrum, Lean and Agile Development in software development organizations.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.comBlogger62125tag:blogger.com,1999:blog-4886064834625370180.post-45198865937992014942011-10-03T10:21:00.011+02:002011-10-11T22:47:11.214+02:00Agile testing: Importance of a testing strategyAs you know from <a href="http://scrumftw.blogspot.com/2011/09/agile-testing-our-background.html">our history</a> we didn't have much (if any) systematic testing going on, when we decided to introduce Scrum back in 2009. <div><br /></div><div>A history of no testing equates to several challenges:<div><ul><li>The system is (was) not very well tested</li><li>The codebase and architecture is (was) not very <i>testable</i> (it hasn't been written to be tested)</li><li>The developers are (were) not used to having to care much about "testing"</li></ul></div><div>It was important for our success that the strategy was clear from the beginning, from a management perspective. Testing had to be made important, it needed to be lifted up from the bottom to the top of the priority list. And, as they say, the proof is in the pudding. From a management perspective such as strategy has to be backed up by the attitude of allowing quality assurance to take time.</div><div><br /></div><div><div>Our aim from the beginning was the following:</div></div></div><div><ul><li>We should introduce the Tester role in the team and clearly define its responsibilities (certainly harder than it sounds, more on this topic later).</li><li>We should immediately stop taking new shortcuts (i.e. stop increasing our <i>Technical debt</i>)</li><li>Test early and test often. All functionality implemented during a sprint should be tested and, if needed, corrected during the <i>same</i> sprint; while still having a reasonably short sprint length (i.e. two weeks maximum)</li><li>Every user story that we implemented and delivered in every sprint had to be tested</li><li>Create a minimal set of test cases that we could start using to verify the fundamental functionality of the system</li><li>Be pragmatic and realize that we can't go the entire distance in the first sprint. We had to accept that despite our intentions we wouldn't have a truly releaseable product increment after every iteration. There would be critical bugs that we wouldn't have time to fix, there would be too few test cases to cover all functionality, etc. But striving towards the goal was a great start, and it meant we got better and better with every sprint.</li></ul></div><div>Since we wanted to include testing in every sprint (and each sprint was just 1-2 weeks long) we had to figure out a way to expand test coverage without spending unreasonable amounts of effort. The solution (of course) was to automate testing. More on that in coming articles... :-)</div>Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com57tag:blogger.com,1999:blog-4886064834625370180.post-447117607758634422011-09-30T13:52:00.025+02:002011-10-03T09:08:29.711+02:00Agile testing: Our backgroundI usually refer to the group of people I manage as "my team", but in fact we are several teams today. <div><br /></div><div>When the development of the product first started back in 2004, as a prototyping/proof-of-concept effort, the "team" then consisted of only 1-2 developers and a very visionary leader (not me :-)). As the prototype became more and more potent and the market showed a positive response, the team was allowed to grow but it was still, in many ways, in a "prototyping/proof-of-concept" mode.<div><br /></div><div>Up until 2008/2009 there was very little systematic testing going on. The development didn't follow any particular development model or strategy. But on the other hand the developers were very skilled, highly motivated and committed, passionate even, largely I think because they had a lot of influence on what went into the product back then. They all pretty much had their own specialist area and their own agendas in terms of what "cool stuff" they wanted to work on and put into the product.</div><div><br /></div><div>And that was all ok, most of it was intentional, and it obviously worked well. In fact, it was a necessity, I think, to have that way of working in order to achieve what was achieved back then; to quickly get a proof-of-concept out there to check if the idea worked and if there was a market for it, and build it from there.</div><div><br /></div><div>However. As the team size grew it became increasingly obvious that some structure was needed. As more and more customers installed the product the need for control from a product development perspective grew too; i.e. the need to be able to decide exactly what features the team should work on and when. Likewise, the need for maintaining project overview grew. And so did the need for testing. The result (i.e. the quality and contents of a release) needed to become controlled and predictable. Also, it was desired that the team should adopt development processes and practices used in other parts of the company - and hence no longer be allowed to work in such a chaotic unplanned/uncontrolled manner. It was time to align the product, the team and its way of working with the rest of the company.</div><div><div><br /></div><div>It was at this point that I joined, early 2009, and we immediately started introducing Scrum and the Agile philosophy. There had been some efforts to introduce Scrum ("Scrumish") in other parts of the company but there were no success stories, and nobody had really tried to implement Scrum "all the way". </div><div><br /></div><div>To give you an idea of what the situation was like before the Scrum introduction, here are a few characteristics (end of 2008):</div><div><div><ul><li>Relatively unorganized development efforts</li><li>High entrepreneurial spirit in the group</li><li>Plenty of shortcuts taken (Technical debt created)</li><li>Unclear project control/steering</li><li>Highly motivated, committed, self-organizing individuals</li><li>High degree of freedom and innovation spirit</li><li>Very little degree of cooperation among engineers</li><li>Direct contact with customers</li><li>No structured testing</li><li>No "tester" role existed</li><li>Definitely no automated testing</li><li>No process improvement efforts</li><li>Aging codebase, with a continuously increasing technical debt</li><li>No requirement or test specifications</li><li>The work didn't follow the established policies and processes within the rest of the company</li></ul></div><div>And here is that wishlist, i.e. what we wanted to achieve:</div></div><div><div><ul><li>Maintain same or achieve better efficiency</li><li>Maintain same or achieve better level of commitment and creativity</li><li>Maintain same sense of freedom and influence</li><li>Possibility for a "product manager" to be responsible for, and in control of, the direction & content of the product</li><li>Reliable and repeatable delivery result</li><li>Possibility for maintaining project overview</li><li>Stop increasing the technical debt (no more shortcuts)</li><li>Partial refactoring of the codebase/architecture to improve/remove some of the prototype code that remained</li><li>Introduce systematic testing of some kind</li><li>Use the resources available in the company's QA department</li><li>Customer Support department to handle direct customer contacts</li><li>Start following the established processes and policies within the rest of the company</li></ul></div><div><div>Thankfully, largely due to good, flexible, patient and somewhat daring managers (such as Head of QA, Head of our department, the Head of R&D and also Product Management) my team was allowed to deviate somewhat from the established (largely waterfall-based) processes in favor for a "true" Scrum implementation. </div><div><br /></div><div>Now, almost three years down the line, we've come far. The team is much bigger and we (think we) work in an agile way and have more or less fully adopted the Scrum methodology. </div><div><br /></div><div>Here are a few characteristics of how we work today (2011) so you get an idea of what changes we've struggled with:</div></div></div><div><div><div><ul><li>We are now 4 cross-functional Scrum teams working in parallel on the same product</li><li>All team members sit together</li><li>5-7 persons in every team, including 1-2 testers</li><li>Still highly motivated and committed team members; both the "old" and the new</li><li>Highly self organizing teams with a high degree of and natural focus on cooperation</li><li>1 Scrum Master (might not be optimal now that we've become as many as 4 teams)</li><li>1 Scrum Product Owner</li><li>Each iteration is 9 work-days long (starts on a Thursday and ends on a Tuesday)</li><li>Estimation is done in Story points</li><li>We measure Velocity and we keep a Release plan up to date, and base time commitments on, measured velocity</li><li>High degree of test automation; 1350 automated function (blackbox) tests, 100 automated "GUI tests"/"end-to-end tests", 2534 automated unit tests and around 110 manual test cases</li><li>Small working (completed) product increments are delivered every iteration</li><li>Our goal is to be continuously releaseable (truly releaseable after every sprint) but we are not there yet</li><li>Natural and continuous focus on process improvement by every team and team member</li><li>Continuous and reoccurring discussions about efficiency and quality</li><li>We have a strategy (and resources) for handling "old" bugs found during sprints</li><li>We have a strategy (and resources) for replacing some of the manual tests with automated tests</li><li>We have a strategy (and resources) for writing automated unit tests for old (legacy) units and not just new ones</li></ul></div><div><div>A lot of work remains and I'm sure we wouldn't pass any Scrum Compliance Test (even if there was one) with a 100% score, but we've come a long way compared to where we were only two-three years ago. And besides; we haven't adopted Scrum for the sake of adopting Scrum.</div></div></div></div></div><div><br /></div><div>In following articles I'll describe and elaborate on some of the experience and lessons I think we've stumbled across during this journey, in particular lessons related to testing and quality assurance (as this article series focuses on Agile Testing :-)).</div></div>Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com21tag:blogger.com,1999:blog-4886064834625370180.post-58759730412394282992011-09-30T11:35:00.004+02:002011-09-30T11:48:33.305+02:00Agile testing: Start of article seriesWow. It's sure been quiet on my part for a while now. I guess that is what happens when you have kids; priorities in life change. With a 1.5 year old at home and a full-time job I've found myself having virtually no time to spare to write these posts about Agile development and Scrum.<div><br /></div><div>However, I was recently asked by a colleague to come to the Q3 meeting of SAST Öresund (Swedish Association for Software Testing: <a href="http://www.sast.se">http://www.sast.se</a>) and hold a 45-minute presentation on the topic of Agile Testing (under the theme "Agile methods in practise"). This was the first time in a while that I've had the chance, and the challenge, to really focus my thoughts around an agile topic and had do an in-depth analysis of my own opinions and experiences. </div><div><br /></div><div>The presentation was quite interesting and great fun to do, and from what I could tell the interest from the audience was quite high. </div><div><br /></div><div>So. In the name of openness I figured that I'd share on this blog the topics I brought up in the presentation. I'll post this as an article series and do a bit more elaboration on each topic than what is possible in a brief concentrated 1-hour seminar.</div><div><br /></div><div>So keep on popping by this blog from time to time, as I'll be posting articles in this series here as often as I have time.</div><div><br /></div><div>And as always, feel free to drop me a comment with your opinions and own experiences, it's always interesting to hear what other people think.</div>Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com15tag:blogger.com,1999:blog-4886064834625370180.post-41695880430955164272011-03-02T16:37:00.007+01:002011-03-04T09:45:14.516+01:00How to fail with a Scrum introductionThe journey of introducing Scrum in an organization is a huge topic in itself, and nowadays there are loads of books and articles describing different aspects of this. Tens of thousands of companies have successfully adopted an Agile methodology. “Scrum” is no longer just a buzzword as it was a few years ago. The hype, the initial excitement and thereby, hopefully, some of the overconfidence has settled a bit. At least that is the feeling I get when speaking to managers and colleagues “out there”. One would think, then, that the process of introducing Scrum would be easier today. With all that collective experience in the industry, with all those books and articles.<br /><br /><br />But looking around at all those companies and organizations who claim they have adopted (or tried to adopt) Scrum, I wonder how many of them are/were really doing Scrum “by the book”? How many of them modified Scrum beyond what could still reasonably, with a clean conscience, be called Scrum – and struggled and had problems with what they <i>thought</i> was Scrum because of it?<br /><br /><br />It doesn’t really matter in the successful cases, where the modifications to Scrum work and the result is something that is at least as good as whatever was being done previously. I guess those organizations would still, in the end, claim that their Scrum implementation was successful – regardless of it <i>really</i> is Scrum or not. But what about all those cases where an organization tried Scrum, concluded it didn’t work, and maybe even decided to go back to dysfunctional..err..sorry, traditional, waterfall-based approach? How many of those ever stopped and pondered on the reasons – the root causes – of why Scrum didn’t work? Ever heard something like “Well, Scrum just didn’t suit our organization/business/team, I think Scrum is over-rated and as I thought it wasn’t the magic bullet answer to everything”?<br /><br /><br />Scrum and Agile is so simple and made up mostly of common sense behaviors and values, that if it really doesn’t work for you then you’re <i>really</i> special. And no offence but it is likely that you’re pretty much like everyone else – no matter how special you want to believe you are.<br /><br /><br /><b>So why doesn’t Scrum work?</b><br /><br /><br />The person responsible for driving the Scrum introduction – the “Scrum driver” – is key to the outcome of the change. In my experience there are four (five) common traps that a Scrum adopting organization risk falling into. All relate to the Scrum driver:<br /><ol><li>He or she lacks sufficient knowledge about what the Scrum methodology and the Agile philosophy is all about.</li><li>He or she is also a Project Manager (or a group of Project Managers).<span style="WHITE-SPACE: pre" class="Apple-tab-span"> </span></li><li>He or she lacks enough time to focus on things like coaching, monitoring, adjusting, educating and motivating the Scrum teams and the stakeholders.</li><li>There is no plan on how to introduce Scrum.</li></ol><br />Maybe a fifth one should be listed also, for the record; <u>the failure to realize that there is need for a “Scrum driver”</u>.<br /><br /><br /><b>Lack of conviction</b><br /><br /><br />I think a common reason for failing with Scrum is that the introduction is driven by someone who lacks conviction and (true) passion – i.e. someone who consequently lacks credibility in the eyes of all stakeholders. Introducing Scrum requires a firm and honest belief in its benefits. The need for conviction is not unique to a Scrum driver but apply to any change process. Introducing Scrum will mean drastic changes for everyone; team members, project managers, stakeholders and managers surrounding the development organization/team. The ways of thinking, the methods, attitudes and expectations will need to change. From day one. You can’t introduce Scrum in steps. It’s All in – or leave the table. And people are naturally conservative. It’s always easier to stick to what you know and have experience with. The unknown is scary. Especially at times of stress, when the going gets tough. That’s when conviction and passion will be required in order for the changes – the Scrum methodology – to persevere.<br /><br /><br /><b>A Project Manager is put in charge</b><br /><br /><br />A Project Manager ought to be the one with the best understanding of how to run a software development project. Right? They are (mostly) educated, intelligent, communicative and multi-tasking individuals with loads of real-life experience of stressful situations, risk management and change management. They are used to following checklists, processes and project methodologies. If anyone should be able to introduce Scrum it would be a Project Manager. Right? Well. Would you let a taxi driver be responsible for introducing free subways? Silly analogy perhaps, but my point is that it would be fair to expect their level of commitment to be less than maximal.<br /><br /><br />Don’t get me wrong, some people are less conservative than others. Open-mindedness is a property that some people have more of – and some less. Introducing Scrum will without a doubt affect the every-day work of the Project Manager, their entire role and responsibility. It may even eliminate the need for a Project Manager altogether. Therefore, to me at least, it is simply not natural that the project manager by default becomes the person responsible for driving that change. They are an involved and affected party. Someone else should be in the driver’s seat, someone like a line manager, a manager of the project office, whoever is the project manager’s boss, or even someone external to the team.<br /><br /><br /><b>Underestimating the challenge</b><br /><br /><br />Introducing Scrum isn’t free – and I’m not talking about a few thousand bucks to get someone a Scrum Master certification, or a couple of books. The adopting organization will need to put the money where its mouth is. In my mind it is not enough to only educate whoever becomes Scrum Master. The entire team needs to have a good (or great) understanding of Scrum; about what problems it solves, what are Agile attitudes (and what are not), what parts of Scrum are fundamental and about what parts can be tailored to the organization/business/team (and which can’t). Educating an entire team will cost time and money.<br /><br /><br />And education is only the beginning. Using Scrum will require lots of monitoring, coaching and adjustments along the way. Continuous improvement. Inspect and adapt. At first that will be managed by the person driving the Scrum implementation, and therefore will require a lot of time & effort from that person to stay close to the team, to keep up-to-date – by the hour – about what’s going on in the team and outside. But as the Scrum team grows used to the new way of working they will start helping each other out, correcting each other and helping each other with staying within the boundaries of Scrum.<br /><br /><br />Another aspect often underestimated may be that of getting everyone onboard. Getting the team members to accept Scrum is a pretty obvious challenge that has to be dealt with. The same should be true for the project manager(s), and maybe even the customer(s). But what about surrounding managers, departments and other roles and neighbors within the organization? Those are the people that will be indirectly affected by the Scrum introduction. It is important to have a good idea about who those persons are, so that you can actively work on their expectations. Take control. If surrounding expectations are not in-line with what Scrum is capable of you’re in trouble. That’s why it’s a good idea to form a plan on how to get them to accept Scrum.<br /><br /><br /><b>Lack of strategy, lack of plan</b><br /><br /><br />It’s surprising (disturbing), I think, how little planning is generally made for introducing Scrum – considering that it happens in an environment where people are usually very used to making rigorous plans, managing risks, etc.<br />A sufficient “plan” in this case would mean taking the time to think about things like;<br /><ul><li>Why are we introducing Scrum? What are the expected benefits? Are they realistic?</li><li>What are the expected drawbacks of introducing Scrum? Will all stakeholders accept those?</li><li>Who will be in charge of the Scrum introduction, i.e. who will be the “Scrum driver”? Is the person in charge also a Project Manager? </li><li>Which persons will be directly affected by the change? Is the Scrum driver one of them?</li><li>Which persons will be indirectly affected? Is the Scrum driver one of them?</li><li>What is the level of credibility, passion and conviction of the Scrum driver? Is he/she able and ready to be a source of inspiration to others during the change process?</li><li>Are all affected persons (directly and indirectly) onboard?</li><li>Do we have any key people to get onboard as assisting informal Scrum advocates within the organization/business/team?</li><li>What is our education plan (plan for getting people on the bus) for people directly as well as indirectly affected by the Scrum introduction?</li><li>What is the budget for “education” (getting people on the bus), in people-time or in money, for the persons directly affected by the change? </li><li>What is the budget for “education” (getting people on the bus), in people-time or in money, for the persons indirectly affected by the change?</li></ul><br /><b>Summary</b><br /><br /><br />Introducing Scrum is a challenge. But I’m pretty sure most would agree that it’s worth the effort, if you can get it to work for you. But please don’t underestimate the challenge. And please consider letting someone other than a Project Manager be in charge of the Scrum introduction.<br /><br /><br />Whoever is put in charge of the Scrum introduction it needs to be someone with:<br /><ol><li>mandate and authority to implement the change; and </li><li>someone with a wholehearted belief in the benefits of the change; and</li><li>someone with a budget for the extra effort caused by the Scrum introduction.</li></ol><br /><br /><br />Let me be clear on this: I don’t think that Scrum really is the solution to everything. I’m sure there are many cases and circumstances where it simply doesn’t suit the organization/business/team. But if you tried it and failed, I think it’s worth to ponder on whether or not it was Scrum that really failed – or the implementation of it.<br /><br /><br />As always, I’m interested in getting some feedback via comments on this blog.<br /><br /><br />Cheers.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com12tag:blogger.com,1999:blog-4886064834625370180.post-63236315807773274642011-02-10T14:22:00.006+01:002011-02-16T13:46:20.374+01:00Overcommitment is better than undercommittment<div>This time I want to talk about the amount of user stories that a scrum team decide they feel comfortable committing to at the beginning of a sprint (at spring planning) - and what happens when they're approach the end of the sprint.</div><div><br /></div><div>At sprint planning, have you ever had a discussion with (or in) your team about whether or not to include that last story or not in the sprint backlog? The one that they're unsure they'll be able to complete. What did you/they decide, and why? Did you hear anyone say something like "Well, let's stick with these fewer stories - we can always include that other one later during the sprint, if we should find ourselves with time to spare"?</div><div><br /></div><div>If the team undercommits, i.e. includes a set of user stories that sums up to a lesser scope (a smaller sprint backlog), it means that they're reasonably likely to complete all stories committed to - and at the end of the sprint they have a good chance of getting a feeling of accomplishment and success. They delivered all the stories! Yay! And, as indicated by the quote above, they can always add that extra story at the end of the sprint if they complete the committed sprint backlog early. Right?</div><div><br /></div><div>Constant overcommitment - on the other hand - might cause a feeling of failure, as the team never really manage to deliver what they commit to. </div><div><br /></div><div>But, to be honest, how often has your team found themselves with time to spare at the end of a sprint? And how many times have they included that extra story from the top of the backlog at the end of the sprint? Somehow, the time available in a sprint always seem to be just enough for exactly (or less than) those stories committed to at the sprint planning - rarely more.</div><div><br /></div><div>While I think we need to recognize and respect the potential negative consequences of constant failure by constant overcommittment, I think we also need to remember that people often need (and like) a <u>healthy</u> amount of stress/pressure in order for them not risk producing waste by extra effort (refer to Lean Software Development for more information about extra effort and waste). </div><div><br /></div><div>The Agile approach is of course to try both alternatives a couple of times, and then inspect and adapt. Find out what suits your team(s). In my personal preference, however, I think reasonable overcommitment carries greater benefits than drawbacks.</div><div><br /></div><div>Either way, the team owns the decision. It's their commitment. I for one want to remind my teams about and get them thinking about this for themselves. Keep it in mind at sprint planning.</div><div><br /></div><div>There is a name of this phenomenon: <b>Parkinson's Law</b>; "Work expands so as to fill the time available for its completion" (<a href="http://en.wikipedia.org/wiki/Parkinson's_law">http://en.wikipedia.org/wiki/Parkinson's_law</a>).</div><div><br /></div><div>Another approach used by some, is to not expect the team to include more stories during a sprint even if they finish early. As a general rule. The thinking behind that practice is that the team's commitment at the beginning of a sprint is what they agree on with the scrum product owner. And since that's what the scrum product owner expects, that's what is enough to deliver. Any spare time at the end of the sprint is used for other things; anything from free time (off work), lab activities, or whatever other fun things you could think of. </div><div>I think this approach is excellent in theory, and it sure sounds nice; if you finish early, you can go home. However as a general rule, in practice, when a deadline is approaching and you want to get as far as you can down the product backlog, i doubt that it would be possible to stick to this. Let me know if this works for you. I'm curious!</div><div><br /></div><div>And as always, please give me some feedback. Let me know how you think about and handle this.</div>Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com14tag:blogger.com,1999:blog-4886064834625370180.post-54075161609340475232010-11-02T07:45:00.000+01:002010-11-02T09:59:40.223+01:00Back in business - with questions about Test and DevelopmentLong time no see!<br /><br />I've been silent for a while now, due to the extremely premature birth of my daughter this spring (she was born over 3 months early). Everything is OK now and she (Emelie, is her name by the way) is doing well. It was, not surprisingly, very chaotic times there for a while, and add to that getting used to being a parent which in itself is a big change.<br /><br />Anyway, for these reasons I haven't really been focused on working with Scrum, but lately, as I'm getting back in to the groove of things here at work, I find myself thinking more and more about Why's and Why-Not's with regard to Scrum & Agile software development.<br /><br />My team(s) here have expanded during the year. They're now a total of about 15 engineers (about 1/4 testers and 3/4 software developers). Which brings me to the topic of this post; how do other organizations cope with running Scrum in a traditional organization where there's one department for "Software development" and another for "Software Quality Assurance"?<br /><br />I've managed to bring the Test Engineers into the team by means of physically locating them here where the Software Developers sit (instead of having the testers sit on another floor). Very cross-functional. Excellent! But, that was the easy part, now to the trickier bit; how do you get the team to think of themselves as one unit with a joint mission (and thereby sharing tasks without particular regard to their formal role) rather than one group of Software Developers and one group of Test Engineers? I often have to remind members of the team (more often Software Developers than Test Engineers, to be honest) that tasks such as "Write automatic test" or "Execute test case A" doesnt automatically <em>have</em> to be done by a Test Engineer just because the task description includes the word "test" - it may just as well be done by a Software Developer.<br /><br />As you can probably guess I am of the firm opinion that <em>every</em> task on the Scrum Board should be up for grabs by anyone in the team (at least that should be the default), regardless of if says "Software Developer" or a "Test Engineer" on the individual's employment contract. They're all comitted to achieving the sprint goal and it's thereby in everyone's interest that every task is completed.<br /><br />It all sounds good and is easy enough to grasp in theory, but in reality it's harder to achieve. Partly (I think) because this is a traditional organization where people are employed specifically as "Test Engineer" and "Software Developer". People tend to kling to that, and I sometimes have a hard time getting them to step outside the boundaries of their formal/traditional role. A complicating factor is that it is not naturally bidirectional; a Software Developer usually have no real problem of carrying out a task that says "Test" on it, but a Test Engineer is not as often able to carry out a task that says "Program" on it.<br />Does this support the notion not to try to share tasks across roles?<br /><br />Well. I like to think of the role "Test Engineer" as a person with a (usually :-)) formal education and experience in the field of "software quality assurance" and that those guys and girls are those who are skilled in identify testing challenges, quality risks and generally ensure that what they (the Scrum team) build is tested "enough". But "Test Engineer" doesnt automatically mean "Those are the guys and girls who should carry out all the tasks with the word 'Test' written on them".<br /><br />To sum this up; If it was completely up to me I would get rid of the formal roles and just hire "Scrum Team Members" with different backgrounds (some who are more skilled in programming and some who are more skilled in the field of software verification & validation).<br /><br />As always, I like getting feedback and comments from you about this and other posts.<br /><br />See you soon(er)!Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com6tag:blogger.com,1999:blog-4886064834625370180.post-46875919234277784872010-03-21T18:57:00.004+01:002010-03-21T19:05:45.874+01:00It's all about prioritiesI've been pretty silent on my Scrum blog lately (well, for the past few months even). The main reason is that we've been expecting a child and we've had a relatively problematic pregnancy; the climax of which led up to my beautiful daughter Emelie's very premature birth on the 17th of March 2010.<br /><br />She was born in week 26 + 3 days only, so she is 3 months premature. She was 1230 grams, 38cm tall, when she came out. She entered the world at 09:57 in the morning, with three minutes to spare to my team's Daily Scrum!! :-)<br /><br />Kidding aside, me and my girlfriend Helene are now living at the hospital in Lund, tending to little Emelie's needs and helping her grow and get stronger.<br /><br />I'm currently on leave from work and I will continue to be somewhat out of the Scrum & Agile loop for some time ahead. We're taking it day-by-day here.<br /><br />Such are priorities in life.<br /><br />I keep a blog about my daughter's progress. You can find it here: <a href="http://litenemelie.blogg.se/">Liten Emelie</a> (sorry, only in Swedish - she doesn't know English just yet ;-)).Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com6tag:blogger.com,1999:blog-4886064834625370180.post-47416117228351005082010-03-10T10:40:00.003+01:002010-03-10T10:46:14.078+01:00New version of Backlog ManagerRecently I've had some time to spare, so I decided to refactor my Backlog Manager into a new version.<br /><br />Here it is: <a href="http://www.gunillaryberg.com/Backlog_Manager_v10_1.xls">Backlog Manager v10.1</a><br /><br />It is more robust than the previous versions, and has better support for Release Planning.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com11tag:blogger.com,1999:blog-4886064834625370180.post-51967178935049653422010-02-18T13:59:00.003+01:002010-02-18T14:02:24.592+01:00Moved/updated Excel tool linksDue to some technical issues the Excel tools that I've made has been unavailable for a week or so. The files have now been moved to a new temporary location.<br /><br />Here are new links:<br /><br /><a href="http://www.gunillaryberg.com/BacklogManager-v8.xls">Backlog Manager</a><br /><a href="http://www.gunillaryberg.com/VelocityLog-v1.xls">Velocity Log</a><br /><a href="http://www.gunillaryberg.com/EstimationSheetTemplate-v4.xls">Estimation Sheet</a>Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com7tag:blogger.com,1999:blog-4886064834625370180.post-69802896874322790482009-11-27T08:01:00.001+01:002009-11-27T08:43:46.627+01:00What unit to use in burndown?What unit do you use for plotting your Burndown Chart? Do you use “Remaining Hours” of the tasks? Or perhaps “Story Points” of the stories in the sprint backlog? Or something else?<br /> <br />Up until recently I’ve taught Scrum teams to just sum up the number of remaining hours for all tasks on their Scrum Board, and plot that sum on the burndown chart. That has been my default approach and I haven’t really experimented with it.<br /><br /><span style="font-weight: bold;">Why even bother breaking down a Story into Tasks?</span><br />The immediate answer to this question is of course that we do it to be able to sum up estimated Remaining Time. Duh :-). But I think there’s more to it, because a Story is more than just the sum of its Tasks. The real reason, I believe, is to get the team thinking; to get the team to reflect over what challenges the Story hides so that they maintain an as clear picture as possible of where the implementing is heading and how the sprint is progressing. This implies that breakdown of a story shouldn’t be done just once (e.g. at sprint planning). The view of what tasks a story contains changes as the implementation progresses and things are discovered. It’s natural that the contents of the story vary over time. Nothing of what I have written here is controversial. It’s all part of Scrum.<br /><br /><span style="font-weight: bold;">What happens in practice?</span><br />Plotting a burndown based on the sum of Remaining Time obviously requires that the team first breaks down the Stories into Tasks. This, in my experience, has always been somewhat of a challenge; for the team to actually end up with <span style="font-style: italic;">useful</span> tasks. A good breakdown of a scope into User Stories is hard enough, and then to also successfully break a Story down into good Tasks … Well, it is hard and it requires lots of practice. I’ve always struggled getting teams to continuously reflect over their breakdown and about how to improve it. But in the end, tasks often seem to end up saying more or less meaningless things like “Implementation”, “Testing” and “Review”. Fail.<br /><br />Failure in Task breakdown like this effectively prohibits the team from having any use of it. A breakdown like this doesn’t say much about the Story and consequently there is little or no use in continuously reviewing the breakdown to try to learn more about the Story as implementation progresses. The only remaining purpose of the breakdown, then, is to force a daily re-estimation, so that numbers can be summed up and plotted on the chart. The burndown and the estimation of Remaining Time becomes an end in itself.<br /><br /><span style="font-weight: bold;">We started counting "Number of remaining tasks</span>"<br />My team, being in the situation described above, felt that the daily task re-estimation was (more or less) meaningless, and proposed that they should try and completely skip the estimation all together. If nothing else, it would save them that estimation-time that was borderline waste anyway. But they also realized that the burndown has an important purpose (yesterday’s weather, indicating progress, early indication of problems, etc) so they felt that they still needed burndown. But if they don’t estimate Remaining Time, then what do they plot on the burndown chart? Well, they agreed to try to plot the number of remaining (not done) Tasks. Simple! And not completely new; it’s a fairly common practice, if I’m not mistaken.<br /><br /><span style="font-weight: bold;">Interesting consequences of this change</span><br />This change in the process had a very interesting side-effect: all of a sudden the Task breakdown produced a large number of highly meaningful tasks. Instead of just saying “Implementation” the tasks that the team now produce actually describe what needs to be done, in pretty deep detail. The number of tasks produced both at the sprint planning and on the Standups is significantly higher now than before, and they say a lot more about what needs to be done.<br />It just seem to come more naturally now. The only difference is that we no longer estimate the tasks afterwards. That’s it. I think this is very interesting. It’s like if there was a mental block before, that has now been removed once the team doesnt have to bother estimating the tasks. I don’t know, but whatever the reason, I think it's great. The team is satisfied with the change. I feel that the quality of the task breakdown of the Sprint backlog is much higher now, and consequently the understanding of the team’s progress is much better (both for themselves and for me as a stakeholder). The project is more transparent.<br /><br />The drawback of this change might be that the burndown probably is a little less accurate, because the size of tasks vary a lot. On the other hand, how accurate was the burndowns before, when we were estimating remaining time almost as an end in itself? Hopefully the accuracy now is not much worse. And if it is, I think it is outweighed by the gain in insight and increased feeling of progress.<br /> <br />Let me know how you work with tasks, and why… As always I’m curious to get some feedback.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com7tag:blogger.com,1999:blog-4886064834625370180.post-29881895514704944992009-11-20T17:18:00.004+01:002009-11-20T17:26:17.518+01:00Agile projects are never lateIn the post I want to talk alittle about "late projects". It is a topic that is somewhat current for me and I have spent some time pondering about this phenomenon :-).<br /><br />The question I ask is: What does it mean for a project to “be late”?<br /><br />Well, in my view, in order to “be late” there has to be a target-date or a target-state (e.g. deadline or a certain scope or both) that the project’s current state is compared against, and the result of the comparison is that the state is such that either expected date or expected scope isn’t achievable.<br /><br />If we can agree that this would be some reasonably valid definition of “being late” then it implies that the following factors are involved in “becoming late”:<br />• Date<br />• Scope<br /><br />When a project “is late” it means that (for whatever reason) what was expected to be ready at a given time, isn’t. Date doesn't match scope - or vice versa.<br /><br />Now, let’s assume that I fix the date, i.e. I commit to delivering my software on a certain date, but I don’t commit to an exact scope by that date. Instead, I make sure that the scope is allowed to flex so that I can deliver only whatever is ready by the time I reach the date that I have committed to. As you all know by now this is what Agile is all about. It is OK to commit to either date or scope, but never both.<br /><br />Is it now possible for my Agile project to “be late”?<br /><br />And I believe the answer is "No". An Agile project can never “be late”, because it is impossible. “Late” is a concept that does not apply to Agile projects. By allowing the scope to flex you effectively remove one of the two required factors for becoming late in the first place. Consequently; if the project is late, then it is not an Agile project.<br /><br />One could of course argue that “being late” can also be when a stakeholder desires the scope to be in a certain state sooner than it actually is. However, in my book this is called “wishful thinking” on the behalf of the stakeholder, and it has nothing to do with the project “being late”. That needs to be handled by proper management of expectations – which Agile and Scrum projects in particular solve by opening up the project with full transparency to stakeholders (velocity measurements, release plan based on velocity, highly visible burndown charts, deep involvement of customers and other stakeholders, short feedback loops with regular deliveries and demos, etc).<br /><br />What the stakeholder above has to realize is that the scope will be delivered as fast as reality allows. The state the project will be in on any given date is determined largely by the “context” in which the project is being realized. When I say “context” I mean all those factors that are affecting how fast the realization can happen: the competence of team, the cooperation of team members, the availability and effectiveness of tools used, the ability for the team to focus on the task (i.e. disturbances), the mood & motivation of individual team members, the availability of information, the clarity/understanding of what is requested, and so on.<br /><br />So, let’s agree to never again claim that an Agile project is “late”.<br /><br />OK? :-)Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com7tag:blogger.com,1999:blog-4886064834625370180.post-34285601108019342762009-11-05T08:16:00.007+01:002009-11-05T08:23:42.257+01:00Scrum. You're doing it wrong when...…your sprint is so long that you feel you have to make a time-plan for it.<br />…your Scrum Master tells people in the team what to do and when.<br />…the team report their progress to the Scrum Master.<br />…estimates are not done collectively by the team-members who will be doing the work.<br />...you hear one team-member say to another; “Sorry, I’m really focusing on my own tasks here in order to finish by the end of the sprint, so you will have to solve your own problem yourself.”.<br />…all stories in the sprint finish on the last day of the sprint.<br />…lower-priority stories in the sprint gets done before higher-priority ones.<br />…the team has as many stories in progress as it has team-members.<br />…the Scrum Product Owner can’t explain every single story in both the Product Backlog and the Sprint Backlog.<br />…you still think it’s a good idea to write down all requirements before you start coding.<br />…you consider customer feedback a risk.<br />…the team doesn’t know who their Scrum Master is.<br />…your system testing happens all at once, after a couple of sprints.<br />…you still think that a detailed Gantt chart is a useful planning tool for the software development tasks.<br />…your sprints are 6 weeks long.<br />…the team’s burn-down has been flat-lined for three days and they’re not discussing why.<br />…you think the customer knows what he wants.<br />…you think the team knows how to build what the customer says he wants.<br />…the team doesn’t know how much work is remaining of the sprint.<br />…you think it’s OK if the team has 45-minute Daily Scrum meetings.<br />…you come running to the team after a sprint and yell “Hey, we have to release now!” and someone in the team responds “…Oh, but wait, we still haven’t done any system testing… And there’s some more code review to be done too.”.<br />…the team doesn’t know when and where the sprint demo will be held.<br />…the team constantly over-commits.<br />…you think it’s OK that the team has their Daily Scrum meetings every other day instead; “It’s their choice, and meetings take so long, so….”.<br />…the team is persuaded to add more to the sprint than they really want.<br />…the team accepts to include stories that have not been estimated.<br />…you don’t collect feedback from the customer after every sprint.<br />…the team doesn’t know who their Scrum Product Owner is.<br />…your team is larger than 8 team members.<br />…the team doesn’t know what the sprint goal(s) are.<br />…your Scrum Product Owner misses a sprint demo or a sprint planning every now and then.<br />…the team decides (or doesn’t follow or care about) the order of the stories in the sprint backlog.<br />…you think the Scrum Master is sort of like a Project Manager.<br />… you think Scrum doesn’t require or need planning.<br />… you think you can’t have a deadline or commit to a scope "because you’re using Scrum".<br />… you think you don’t need to document "because you're using Scrum".<br />… you commit both to a certain scope and to a certain date.<br />...you need to add stuff to the sprint half-way through.<br />…you think the Scrum Product Owner is sort of like a Project Manager.<br />…the team doesn’t know their velocity, or the meaning of it.<br />…the team haven’t met the Scrum Product Owner for a week.<br />…the contents of a sprint demo comes as a surprise to the Scrum Product Owner.<br />…the team doesn’t know or understand the overall vision of what they’re working towards.<br />…you can’t release the software after every sprint.<br />...Scrum doesn't work.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com12tag:blogger.com,1999:blog-4886064834625370180.post-76820931505119027492009-10-27T09:07:00.005+01:002009-10-27T09:28:35.432+01:00Follow-up on the Scrum Practitioners meeting Oct 15thThank you everyone who participated on the Scrum Practitioners meeting on the 15th of October at Axis Communications in Lund.<br /><br />Some of the things discussed were;<br /><ul><li>Distributed Scrum; does it work? A few of the participants had some experience in this, and the opinions were mixed. Bottom line is; yes it is certainly possible to get it to work. I.e. it doesnt automatically fail. It requires work, though. But that is true for any methodology; if you have team members on a distance you have to deal with the overhead cost in terms of extra communication, tools, activities, travel, whatever. Depending on how the distribution looks you can try different approaches; divide into teams per site, or distribute teams and work with conference solutions, digital whiteboards, etc for the daily meetings. Experiment. Distributed teams and distributed Scrum is not ideal, but if you're faced with a situation where you have a distributed team, don't automatically rule out using Scrum. </li><li>How/if sort out design-issues before sprint start? The problem discussed was that of things taking a long time to finish if you do "design stories" in one sprint to discover what/how to implement, and actually implement in in the following sprint. With 4 week sprints it can take you 8 weeks to finish a story, even if it is not that big. The concept of "spikes" was discussed, i.e. prototyping and delivering a piece of working and valuable code in each sprint, rathen than doing "only design" separated from "only development". If you do "design stories" it may be wise to timebox rather than trying to estimate it, because the definition of done for "design" is hard to grasp. Another tip can be to consider shortening the sprints, to e.g. 2-3 weeks instead of 4. </li><li>The problem of traditional, conservative customers, demaning fixed-price-fixed-scope contracts was discussed. The concept of "Money for Nothing and Change for Free" was discussed as an interesting theory. None of the participants had experience with that approach, though.</li><li>Coping with less-than-fulltime resources in a Scrum Team: The problem of traditional customers and product owners who do not realize that Scrum requires a much higher degree of involvement. Not sure we came to any intelligent conclusions on how to address this problem, other than the importance of realizing that it is a problem if the customer/PO is not involved.<br /></li><li>Problems with large team size was discussed, and consequently the problem of daily scrums taking too long time. </li><li>Is the traditional project manager automatically the best choice for Scrum Master when introducing Scrum? Not necessarily, was the conclusion. This seems to be the default choice in the industry, but it is not necessarily the best. It depends on your organization, the people, the problem domain, etc. The Scrum Master may be a good choice for the Project Manager, but Scrum Product Owner may be too.<br /></li></ul>Several other interesting things were discussed too, but I will not go into more details here.<br /><br />I'm looking forward to the next meeting.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com5tag:blogger.com,1999:blog-4886064834625370180.post-71752915057322810062009-10-05T09:11:00.005+02:002009-10-07T22:05:46.911+02:00October meeting Scrum Practitioners South of SwedenI'm planning the October meeting for the network <a href="http://www.linkedin.com/groups?about=&gid=2085225&trk=anet_ug_grppro">Scrum Practitioners South of Sweden</a>. I'll update this blog post as details are decided. For now, the meeting is planned for Thursday October 15. It will be between 17:00 and 19:00, hosted by myself, in Axis Communications' office at Emdalavägen 14 in Lund.<br /><br />The topics of discussion are (under construction ;-)):<br /><br />* Distributed Scrum; Does it work?<br />* How/if sort out design-issues before sprint start?<br />* How do I get the product owner more involved?<br />* Coping with less-than-fulltime resources in a Scrum Team<br />* Is the Project Manager the best choice for Scrum Master when moving from a Traditional to a Scrum organization? Who decides, and who is the best choice?<br />* Is the "Product Manager" the best choice for "Scrum Product Owner"?<br />* Story formulation, estimation, story breakdown into tasks and prioritization<br />* ...<<a href="http://www.linkedin.com/groups?about=&gid=2085225&trk=anet_ug_grppro">insert</a> topic here>Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com4tag:blogger.com,1999:blog-4886064834625370180.post-34064921962924614982009-09-16T08:05:00.002+02:002009-09-22T14:48:11.728+02:00Follow-up on the Scrum Practitioners meeting Sept 7thTo follow up on our first meeting in the Scrum Practitioners South of Sweden network;<br /><br />I don't intend to recap all the discussions and conclusions on the meeting, but rather I just wanted to briefly list the major topics discussed as I recall.<br /><br />The meeting was held as planned at Labs2 in Lund with a total of 8 participants including Mathias Thinsz (Product Manager & Scrum Product Owner at Labs2) who was our host.<br /><br />Mathias went through and explained the major parts of Labs2's Scrum implementation. It seems to me that they have a very solid and healthy view on how they development software. It's a clean and well-thought-through implementation of Scrum. A great example on how well Scrum works.<br /><br />Related topics discussed were;<br />* How Labs2 use JIRA and a custom developed web application for managing the backlog<br />* How and when Labs2 estimate their work in the backlog, and how they use the storypoints unit<br />* How Labs2 has divided their development organization<br />* How and why Labs2 have divided their development time into fixed-length iterations<br />* How Mathias (as Scrum Product Owner) prepares for a new sprint and who is involved when<br />* How and why Labs2 use "Sprint Goals" as a major tool for directing development inside a sprint<br /><br />There were tons of other interesting questions and discussions as well, but too much for me to go into here.<br /><br />The general feeling, in my understanding, was that the meeting was interesting and inspiring and everyone had a lot of questions and topics which they wanted to continue discussing.<br />The number of participants was optimal and the length of the meeting as well. Hence; my conclusion is that there is a definate interest for meeting again and that the next meeting should be in the same format.<br /><br />I want to take the opportunity to thank everyone who joined and not least Mathias Thinsz and Labs2 for the openess with how they work!Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com21tag:blogger.com,1999:blog-4886064834625370180.post-85542196040841768502009-09-04T08:34:00.004+02:002009-09-04T08:43:30.512+02:00Mon Sep 09: Meeting Scrum Practitioners South of SwedenOn Monday the 7th of September 17:00-19:00 we're a bunch of people meeting at Labs2's office in Lund (Sweden :)) to discuss how Labs2 are working with Scrum. Anyone intersted in joining and sharing experiences is welcome.<br /><br /><a href="http://www.linkedin.com/groups?home=&gid=2085225&trk=anet_ug_hm">Join the LinkedIn group "Scrum Practitioners South of Sweden"</a> and post your interest if you want to join the meeting.<br /><br />My idea with this is to get software professionals in the Öresund region to meet informally, network, and not least share experiences and help eachother improve our way of working with agile software development. Meetings will be hosted by a different group member each time, and the discussion theme will vary from meeting to meeting.<br /><br />See you there!Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com2tag:blogger.com,1999:blog-4886064834625370180.post-39218392320920190152009-09-03T11:34:00.003+02:002009-09-03T11:36:47.320+02:00Scrum but... testThis has been around for some time, but if you haven't taken it already then do it. It's a good way to compare yourself to others and help emphasize your points of improvement.<br /><br /><a href="http://antoine.vernois.net/scrumbut/?page=intro&lang=en">Go to the Scrumbut test</a>!<br /><br />I just took the test and my team currently scores 7.1 out of 9.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com3tag:blogger.com,1999:blog-4886064834625370180.post-57628611961416817112009-07-20T08:15:00.001+02:002009-07-20T08:46:07.964+02:00Estimating & prioritizing the product backlogOne of the things that I’ve been struggling with getting my head around since I started using Scrum is; <span style="font-weight: bold;">how much effort do I put into estimations of the product backlog, and do I or don’t I estimate all at once? And do I re-estimate stories as I go along and learn more?</span><br /><br />Originally I’ve been under the impression that I shouldn’t attempt to estimate it all up front. It's easy to argue that it is rather un-agile to do so: because I would be spending effort on low priority stuff, which is a big risk for waste. On the other hand, if I don’t estimate the backlog up front, I can’t tell its entire size and consequently I can’t (potentially) tell what I will have ready by when.<br /><br />So far, I’ve been trying a couple of different approaches. One of my favorites has been to estimate in priority order up to a few months worth of stories (a "handful" of sprints). The remaining unestimated stories I apply an average size to based on the estimated ones. I know, it’s risky, but it’s at least something. And obviously, as time passes, I estimate more and more; trying to keep about 2-3 months worth of stories estimated at all times. For some time this has been my approach to release planning without estimating everything up front.<br /><br />A problem I only recently realized I’ve had is that this approach requires me to prioritize before estimating; and consequently my prioritizations can’t take size into consideration. My prioritization has only been made based on “value” (whatever that is) without regard to cost. Is that optimal? I think the answer is No. Given I have a choice prioritization should take size into account. Or at least, if I don’t take it into account it needs to be a conscious decision not to. Which brings me back to my original question; how do I do it, <span style="font-weight: bold;">do I estimate everything up front or not?</span><br /><br />Recently, I’ve decided to try changing my approach (inspect and adapt, right?) and actually estimate the entire backlog up front, before prioritization. The good thing is that estimating in story points is very quick (the team usually doesn’t have to spend more than a few minutes per item) so the time spent on (potentially) low-priority items is minimal.<br /><br />Once I have the story point estimates of all backlog items I use a prioritization technique called “Theme Scoring”. Let me try to describe it with a simple example;<br /><br />The first step is to decide on a couple of aspects ("selection criteria") to judge stories on; for example “<span style="font-style: italic;">Improves user interface</span>”, “<span style="font-style: italic;">Simplifies maintenance</span>”, “<span style="font-style: italic;">Brings revenue in Q3</span>” and so on. The combined criteria will represent what you call “business value” so whatever you put in that term should in one way or another be reflected by those criteria that you pick. Try, however, to keep it rather simple e.g. up to a maximum of 4-6 criteria or otherwise your scoring will become very tedious and the effort you spend on scoring (and consequently the risk of waste) I think will be too great compared to the benefit.<br /><br />Once you’ve decided on your criteria you need to weigh them relative to each other. Maybe “<span style="font-style: italic;">Brings revenue in Q3</span>” is the most important criteria to you right now, so let’s give it the weight of (for example) 5. “<span style="font-style: italic;">Simplifies maintenance</span>” is not that important right now so you give it the weight 2 (it’s less than half as important as the revenue criteria). “<span style="font-style: italic;">Improves user interface</span>” is almost as important as the revenue aspect, so you assign it the weight 4. Here are your criteria and their weights so far; “<span style="font-style: italic;">Brings revenue in Q3</span>” = 5, “<span style="font-style: italic;">Improves user interface</span>” = 4 and “<span style="font-style: italic;">Simplifies maintenance</span>” = 2.<br /><br />The next step is to go through all of your backlog items, one by one, and score them on a scale from 1-5 in terms of how they affect each of your selected criteria. For each criteria you can usually identify a “baseline story”; a story that gives you a fair amount of value in terms of that criteria, yielding in a 3 point score on that 1-5 scale. There should be stories that yield in a higher score as well as lower. Stories should be compared to that baseline story for each criteria to determine if it should get a higher or a lower score than the baseline.<br /><br />This could be your result after going over all criterias for all stories;<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjaKXd6FyTpSZqsoXls28c1dX-F_LrOJN-kLayTd7xpMB2y-OvW70BIeWpQYC_Y3HwNww_p4QfYCCskxU7zVCuaJ36DhEEahWSDxZnXrKrWoXXwI3tCreOf-DeZv2dWNLSnmNO4u3rpx_g/s1600-h/ThemeScoring001.PNG"><img style="cursor: pointer; width: 400px; height: 208px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjaKXd6FyTpSZqsoXls28c1dX-F_LrOJN-kLayTd7xpMB2y-OvW70BIeWpQYC_Y3HwNww_p4QfYCCskxU7zVCuaJ36DhEEahWSDxZnXrKrWoXXwI3tCreOf-DeZv2dWNLSnmNO4u3rpx_g/s400/ThemeScoring001.PNG" alt="" id="BLOGGER_PHOTO_ID_5360429514891877730" border="0" /></a><br /><br />The numbers marked red are the baseline stories for each criteria. The black numbers in the criteria columns are grades I assign each story on a scale from 1-5 relative to the baseline. 1 and 2 means much lower and lower than the baseline, and 4 and 5 means higher and much higher than the baseline. A grade of 0 means that the criteria doesn’t apply to the story. The Score is simply your grade multiplied by the weight, for each criteria.<br /><br />Given your selected criteria and their weights, in the example here Story 3 is the one giving you the most value (37), followed by Story 2 (18) and then Story 1 (17), Story 5 (8) and Story 4 (6).<br /><br />Now, it is time to compare value to cost (estimated size in Story Points);<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiOqRQS-x0NFBtDugHCDLp4lxpX-YB38ZJ8U4sVIutbUjGNSY3ppJsNHo-cctughi8rYQ7BXz5cRSDNeHy_Jmmbk_-IwQtPBBfbHf30zQllOu05ckD57P_7iQa2ZoUsqueAzgmtGELvf-g/s1600-h/ThemeScoring2.JPG"><img style="cursor: pointer; width: 286px; height: 145px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiOqRQS-x0NFBtDugHCDLp4lxpX-YB38ZJ8U4sVIutbUjGNSY3ppJsNHo-cctughi8rYQ7BXz5cRSDNeHy_Jmmbk_-IwQtPBBfbHf30zQllOu05ckD57P_7iQa2ZoUsqueAzgmtGELvf-g/s400/ThemeScoring2.JPG" alt="" id="BLOGGER_PHOTO_ID_5360428002886829970" border="0" /></a><br /><br />So far this technique has been possible for me to do all along, even while I have been lacking estimates of parts of the backlog. But the following part – taking cost into the equation – obviously requires me to have the estimates. Putting the Benefit in perspective to Cost is a great idea; it gives me the opportunity to maximize benefit while minimizing cost.<br /><br />So, divide Value (your total score for each story) with Cost (measured in story points) and sort your backlog by the result: the higher the value the more value I get back on the effort put in:<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEif3xaCmm22mHINrL0ausvkajWD6uXkklKFe8whjugD3TfzZ8_s-bAwkYENSWPOljey1kYrIOzafAfx07xLkeFOi5gcBjmLBJQaRXjxoKbMErb6VTHKnqBR1JN0W926zdG-JTfj41D-Lb4/s1600-h/ThemeScoring3.JPG"><img style="cursor: pointer; width: 400px; height: 158px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEif3xaCmm22mHINrL0ausvkajWD6uXkklKFe8whjugD3TfzZ8_s-bAwkYENSWPOljey1kYrIOzafAfx07xLkeFOi5gcBjmLBJQaRXjxoKbMErb6VTHKnqBR1JN0W926zdG-JTfj41D-Lb4/s400/ThemeScoring3.JPG" alt="" id="BLOGGER_PHOTO_ID_5360428199306966962" border="0" /></a><br /><br />The above table is the resulting suggested prioritization based on the Theme Scoring technique and on calculating value/cost. Obviously it is worth noting that this is a suggestion only. It is an aid that I can use when prioritizing my backlog, it’s not something that replaces my thought-process – I still need to think and consider every item and e.g. be careful that I don’t miss any dependencies between stories (yes I know, we shouldn’t have any dependencies between stories, but sometimes we do anyway! :-)).<br /><br />As always, I’m interested in input on how other people do things…!Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com9tag:blogger.com,1999:blog-4886064834625370180.post-33108676832703172842009-07-08T08:05:00.007+02:002009-07-08T11:22:24.564+02:00Technical debt in Scrum projectsCode deteriorates with age. The older the system, the worse the maintenance. Why is this?<br /><br />One answer may be that it is because of the maintenance itself: the things done over the years to keep the system afloat and the new features added, removed and changed. And people come and go. Some quit the team and new ones join. Sum it all up: deterioration.<br /><br />Let’s talk about some of the causes and effects of deterioration.<br /><br /><span style="font-weight: bold;">Reinventing the wheel</span><br />An example of this is when a system contains several versions of the same function implemented at different times, often by different people, with only small differences. A similar situation is where a design (architecture) problem is solved in different ways in different places in the system. Either way, reinventing the wheel increases the complexity of the system and makes it harder to maintain. Developers won’t know which function is used where or even if they are still used at all (and consequently leave them there).<br /><br />This is a negative spiral; the more complex the system gets the harder it is to understand, and consequently the harder it is to know if “my” problem has been solved already somewhere – which might lead me to unintentionally write my own version of a function that actually already exists. The lesson is to not reinvent the wheel. But it is easier said than done.<br /><br />Maintainability is not something you can just add down the road. Building a maintainable codebase starts from the first line of code and it never ends.<br /><br /><span style="font-weight: bold;">Fear of changing what works – Legacy code</span><br />Once a system reaches a certain level of deterioration, people will be afraid to change certain parts. It’s often some critical and central component. Since it is central and critical it means it has been patched up numerous times, and changed and adjusted and changed again – over a long time. And hey, it works – now. And since it works, now, and since the code is so complicated and confusing, the developers don’t dare touch it. Consequently any features that would result in work in that critical component will be held back.<br /><br />The way I see it, one of the root causes for this, is lack of regression testing abilities. With proper means for continuous and whole-covering regression testing, there is little to fear even when it comes to modifying old “legacy code”. Otherwise there are only two options when it comes to modifying legacy code; a complete rewrite, or just not touching it at all.<br /><br /><span style="font-weight: bold;">Lack of (efficient) regression testing abilities</span><br />The purpose of regression testing is to verify that every part of the system – even the less obvious parts – still works after a change or addition somewhere has been completed. The point with regression testing is to test a lot, over and over and over again. If you are in a situation where regression testing requires immense resources (which it does if you do it completely manually), then you will not be able or willing to do it as often or as extensive as is required. As a consequence your regression testing become inefficient, or even non-existent.<br /><br />One of the steps in the right direction is to start automating your tests, and start running those automatic test cases continuously. The challenge, of course, is to;<br />(A) find a practical means - a tool - for automatic testing of your type of code, and<br />(B) figure out where to start.<br /><br />I can’t help you with A (...psssst: <a href="http://junit.org/">JUnit</a>, <a href="http://sourceforge.net/projects/cppunit/">CPPUnit</a>, <a href="http://cunit.sourceforge.net/">CUnit</a>, <a href="http://sourceforge.net/projects/phpunit/">PHPUnit</a>), but for B I suggest you just start <span style="font-style: italic;">somewhere</span>. Don’t try to do it all at once – you won’t make it! Instead, just pick a simple starting-point, for example the most recent and newly added feature/module/component/part. Forget about the old stuff for now, just add automatic testing for the new things from now on. Something is better than nothing.<br /><br /><span style="font-weight: bold;">People joining and leaving</span><br />This is, unfortunately, unavoidable in most projects that are longer than just a few months. It happens. Either people get reassigned, or they choose to quit. And best-case, people join the team. Apart from a change in productivity caused by a team member leaving or joining, it obviously has an effect on the code itself too. People leaving will take knowledge with them, and people joining bring in new ideas (and misunderstand parts of what exists, too). One way to minimize the effects of this is to organize into “Feature Teams” that has a lot of close cooperation and joint commitments (like – tada! – Scrum suggests). This way you naturally spread knowledge among several people. It is also a pretty effective way of introducing new team members into the groove of things.<br /><br />The classic method to minimize the problem of people leaving and joining is to write documents. I however argue that this is <span style="font-style: italic;">not </span>the silver bullet for spreading & retaining knowledge. In fact, I think it's dangerous to rely on documents as the main tool for this; documentation is an extremely cost-inefficient and overrated way of transferring knowledge, and something that is often forgotten is the cost of keeping documentation up-to-date. As soon as documentation falls behind it becomes untrustworthy – and untrustworthy documentation will cause confusion and misunderstandings, and in the end no one will dare rely on documentation, and the time writing and updating it up to that point becomes waste.<br /><br />In my opinion the guideline should be: don’t over-document – document just enough. Code Comments, I think, is a great benchmark of what level of documentation is “enough” for most situations. And remember; one excellent thing about code comments is that it is automatically (well…) kept up to date as the code changes – there’s little or no added cost for keeping it up to date.<br /><br />Oh, and for the record, I’m not saying “Don’t write documents!”. If you really need to document then of course you should. I’m merely suggesting that you at the very least question the reason for doing that effort, and that you don’t forget to take into account the cost of keeping the document up-to-date as the system evolves.<br /><br /><span style="font-weight: bold;">Taking shortcuts - the Dirty that remains long after the Quick has been forgotten</span><br />“Well, we’ll do the quick-n-dirty fix now, just to get it done, and then we’ll go back later and clean it up...”. Have you ever said or heard something along those lines?<br /><br />Short term gains such as reaching some immediate deadline makes it tempting sometimes to take shortcuts, and often it’s, sadly, a conscious decision. The problem with shortcuts is that they seldom or never get fixed afterwards, because there’s always that next deadline coming up with a new bunch of stuff to do with a new bunch of shortcuts that “has” to be made.<br /><br />Doing things right from the beginning often requires a little more effort up front. And I think that different times call for different ways of acting. Sometimes it might be a correct decision to look only at short-term gains and cutting down on the immediate effort, and forgetting about those long-term consequences and drawbacks. But many teams and managers, I think, tend to be shortsighted by default – even when they don’t have to and there would in fact be room to do things properly. And in that case it is a matter of attitude (and competence). Do you do things fast and sloppy now and accept to pay for it later, or do you let it take a little longer now and reap the benefits of it later (for example in terms of costs saved on maintenance)?<br /><br />It’s a challenge to figure out what is a shortcut and what is not. Remember Lean Software Development and the idea of “Extra effort” (and “Extra features”) being Waste. How do you know what is “Just enough effort”? There is no default answer to that. It depends. It’s up to you to figure that out for your system and for your business. But by figuring that out (or deciding on it) you will know what level to strive for; and anything below it is a shortcut and should not be accepted.<br /><br />Don’t forget that you need to make sure that whatever your level is, it should be gut-felt by every team-member.<br /><br /><span style="font-weight: bold;">Bug fixes</span><br />Bug fixes have a tendency to deteriorate code. Enough patches in one place and the code will become more and more messy – at least if you have other problems too that cause code deterioration, such as people coming and leaving, inability to do regression testing, etc.<br /><br />Bugs found in a production environment are often time critical to remedy. It can be tempting to take shortcuts to just fix the problem quickly and get a patch out there. But if you do that enough times but never take time to clean out the mess, you are destroying your system. See section above about taking shortcuts…<br /><br /><span style="font-weight: bold;">Summing things up – dealing with Technical Debt</span><br />A nice way to think of this deterioration of code is to think of it as “<a href="http://www.youtube.com/watch?v=pqeJFYwnkjE">Technical Debt</a>” - a term coined by <a href="http://sv.wikipedia.org/wiki/Ward_Cunningham">Ward Cunningham</a>.<br /><br />Technical Debt is a long-term loan that we for some reason choose to, or have to, take from ourselves in order to achieve some short term gain. The Technical Debt increases for every individual loan and the debt never just goes away by itself. We have to pay “Interest” in the shape of things taking longer to complete because of this deteriorated code, and the only way we can decrease the Interest is by decreasing the loan – by paying “mortgages” e.g. by refactoring.<br /><br />The most common (and worst) approach to dealing with Technical Debt is to ignore it. To pretend it doesn’t exist, and just push development forward without considering whether or not we’re taking loans.<br />The better approach to dealing with Technical Debt is to recognize it and have an active plan on how to deal with it in various situations.<br /><br />I suggest you deal with technical debt into two steps: First <span style="font-style: italic;">stop increasing the debt</span> <span style="font-style: italic;">further</span>, and secondly <span style="font-style: italic;">start decreasing it</span>. Only once you know that your debt is not increasing, you can start actively working with decreasing it.<br /><br />To support you in the first step I suggest you insert a row in your Default Definition of Done that says “The Technical Debt has not increased”. It sounds trivial, but the intended effect is that it recognizes that it is OK that things take longer to complete if done in a way that doesn’t increase the debt - e.g. that it is OK to not take shortcuts. Remember to constantly remind people about this, and really do put your the money where your mouth is. Whenever faced with a choice, make sure you consider that the decision should be in-line with the attitude of letting things take longer in order to not increase the technical debt.<br /><br />Once you’ve gotten used to that approach (it probably takes you a while and, if nothing else, will probably cause your velocity to drop significantly at first), the next step is to change the Definition of Done to instead say “The Technical Debt has decreased”. This is intended to recognize the fact that it is OK to also do some refactoring of things surrounding the current implementation “while you’re at it”. For example, urge all developers to modify the methods above and below the one currently worked in - even though it wouldn’t be necessary to complete the story itself! This way, for every new story completed the existing debt will decrease.<br />This type of refactoring will puts a lot of demands on your regression testing abilities. If you don't already have an automatic testing environment I suggest you start with introducing that first. Refactoring working code will (as explained in a section above) will otherwise be much too scary.<br /><br />That's it from me for now. As always I'm interested in hearing other people's experiences and opinions in this matter.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com4tag:blogger.com,1999:blog-4886064834625370180.post-14047478140973516192009-07-03T08:00:00.002+02:002009-07-03T09:39:49.376+02:00Scrum Practitioners South of Sweden on LinkedInI just started a LinkedIn group: <a href="http://www.linkedin.com/groups?about=&gid=2085225&trk=anet_ug_grppro">Scrum Practitioners South of Sweden</a>.<br /><br />The idea is to collect a bunch of people in the south of Sweden who want to meet face to face regularly, in an informal manner and share experience of Scrum, Agile and related topics with the intent of helping each other out and improving how we work.<br /><br />Not sure if such a network already exists but I certainly see a need for it personally.<br /><br />Follow <a href="http://www.linkedin.com/groups?about=&gid=2085225&trk=anet_ug_grppro">this link if you're interested </a>in joining.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com3tag:blogger.com,1999:blog-4886064834625370180.post-88063796222344902192009-06-26T12:43:00.002+02:002009-06-26T12:50:16.375+02:00Done EnvironmentIn addition to intelligent version control, I like to have a set of “test environments” that map closely to my <a href="http://scrumftw.blogspot.com/2009/06/agile-version-control-another-magic.html">Agile Version Control policy</a>.<br /><br />First, it is necessary to have some sort of “Development Environment” where the most recent code from the Development Branch in the version control system can be tested and worked on.<br /><br />Similarly, I like to have a “Done Environment” (sometimes also known as “Next Release Environment”, or “NR Environment”) where the most recent code from the Done Branch can be seen. The power of this environment is that it allows (forces) you to integration test early. If your Done Environment is an accurate representation (e.g. replica) of your live environment then you will be able to integration- and system test as early as the first story being delivered there – and I always include in the Default Definition of Done that the story should be working and available for demo in the Done Environment. In fact, I like to setup an automatic build and distribution script here, that every night packages the most recent version of the Done Branch in the version control system and puts it on the Done Environment. This way you know that you will always be able to see the stories that are Done-Done on in this environment, without any risk of them being infected by code in progress. This also means that once the release day comes you have (hopefully) already done a lot of the steps required, and consequently making a release becomes less of a deal than it otherwise often is; avoiding or at least minimizing the Big Bang problem.<br /><br />If you’re short on servers, server-space and/or money (actually, regardless) I think it is a great idea to use <a href="http://en.wikipedia.org/wiki/Virtual_private_server">virtual</a> servers for hosting the environments. It gives a great flexibility when it comes to setting up new environments and cloning existing ones. If you have a live environment consisting of 40 physical servers, and you want to replicate that environment as a Done Environment, it’s not always practical to buy 40 new physical servers. Especially not if you have three teams and each has its own Done Branch, and consequently needs its own Done Environment (3 x 40 servers ;-)). But maybe it is OK to buy just a few physical servers, and instead run the Done Environment servers virtually. Virtual servers is a great and powerful tool – try it. You can find a list of software here: <a href="http://en.wikipedia.org/wiki/Comparison_of_platform_virtual_machines">http://en.wikipedia.org/wiki/Comparison_of_platform_virtual_machines</a>Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com3tag:blogger.com,1999:blog-4886064834625370180.post-21265501773814297212009-06-22T07:20:00.005+02:002010-02-18T13:45:18.539+01:00The velocity log - another Scrum toolDo you measure velocity? If so, how do you record it? (And if not: start!)<br /><br />You measure (or should be measuring) velocity in order to be able to adjust the intake of future sprints, allowing the team to optimize the size of its commitment, facilitating for keeping a constant pace. What you should be measuring, at the very least, is the number of story points completed according to the Definition of Done in each sprint. This is, as you probably know, called <span style="FONT-STYLE: italic">Actual Velocity</span>. You should also measure how many story points the team originally thought they would complete when they started the sprint (on the sprint planning meeting). This is called the <span style="FONT-STYLE: italic">Estimated Velocity</span>.<br /><br />I like to do the counting as part of the Retrospection. The team review what they have delivered and we do the math and record it.<br /><br />The actual (and estimated) velocity are dependent on the context in which the team work; plenty of disturbances, impediments, new people etc will yield in a lower actual velocity. The velocity is also dependent on the sprint duration and on the team size. You want to keep both as constant as possible, so that the team really has a continuous pace – a “beat”. However, there’s a reality, where people have vacations and there are parental leave and educations, and there are holidays and day-before-holidays and what not. Despite best efforts, the sprint duration and the team size will vary over time – a lot, sometimes. This makes it hard to compare the velocities of different sprints; one sprint resulted in 25 SP and another 40. Was that because the environment was such that it allowed the team to complete almost double the amount, or was it because the sprint had a few extra days and a couple of people less on vacation?<br /><br />I like to remove sprint duration and team size from the equation so I get something comparable over time (across sprints); because variances in velocity should point out differences in the context, and not differences in the sprint duration or team size.<br /><br />For this reason, I record also <span style="FONT-STYLE: italic">sprint duration</span> (in number of working days) and <span style="FONT-STYLE: italic">team size</span> (in number of people), together with every pair of velocity (actual + estimated). I try to keep the numbers to integers, but sometimes I have to count “half” people (because of e.g. parental part-time leave, educations, or similar). I try not to go into more details than halfs – if I’m just consistent in the way I measure and in the level of detail, it won’t matter in the end – so why waste time and effort trying to figure out if I have 5.18 persons or 5. Anyway, with this information (<span style="FONT-STYLE: italic">Sprint Duration</span> and <span style="FONT-STYLE: italic">Team Size</span>) I can calculate the number of available man-days in the sprint (<span style="FONT-STYLE: italic">number of days</span> x <span style="FONT-STYLE: italic">number of people</span>), and then I can use that to calculate the “Estimated Story Points per Man-day” and “Actual Story Points per Man-day”. It will say something like “1.5”. It means that for every man-day the team completes 1.5 Story Points.<br /><br />I’ve made an Excel (I always do ;-)) for recording velocity like this. I call it “Velocity Log”. It also has some nifty charts to plot velocity and trends over time. It’s available for download here:<br /><a href="http://www.gunillaryberg.com/VelocityLog-v1.xls">VelocityLog-v1.xls</a><br /><br />As an example, here’s the velocity of my current team over a couple of sprints:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjiYdSHV5bhZ_zaF_NWltuuibT7hEVqy4rhpmk6kQ8pYw1aLSpVmqxkrwvDU3J3QkBmZaKrUyWomzJsn3rR51-_bRWnLK4KH3JaLqFDav5XF8St6djUV1-WsF5yWrvGB0HhX3Moin9uup0/s1600-h/Velocity1.JPG"><img style="TEXT-ALIGN: center; MARGIN: 0px auto 10px; WIDTH: 430px; DISPLAY: block; HEIGHT: 344px; CURSOR: pointer" id="BLOGGER_PHOTO_ID_5348189620214172130" border="0" alt="" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjiYdSHV5bhZ_zaF_NWltuuibT7hEVqy4rhpmk6kQ8pYw1aLSpVmqxkrwvDU3J3QkBmZaKrUyWomzJsn3rR51-_bRWnLK4KH3JaLqFDav5XF8St6djUV1-WsF5yWrvGB0HhX3Moin9uup0/s400/Velocity1.JPG" /></a><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjLT0I7NTYv49HkU9Oi11HcxyeL_CKggbm1dBOFN5hTjnznu0znr2kyVonIkFMfdeIPyaZf1Hs91sdIL-rWE9me-jBunNIuuVBlk8tfV6OSRp8oWO_vfiMAipwVr018-zNQp2gMhIq1IKw/s1600-h/Velocity2.JPG"><img style="TEXT-ALIGN: center; MARGIN: 0px auto 10px; WIDTH: 430px; DISPLAY: block; HEIGHT: 337px; CURSOR: pointer" id="BLOGGER_PHOTO_ID_5348189738795691570" border="0" alt="" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjLT0I7NTYv49HkU9Oi11HcxyeL_CKggbm1dBOFN5hTjnznu0znr2kyVonIkFMfdeIPyaZf1Hs91sdIL-rWE9me-jBunNIuuVBlk8tfV6OSRp8oWO_vfiMAipwVr018-zNQp2gMhIq1IKw/s400/Velocity2.JPG" /></a>Let me know your thoughts.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com2tag:blogger.com,1999:blog-4886064834625370180.post-43772334384626846092009-06-17T08:45:00.002+02:002009-06-25T13:35:59.207+02:00Why estimate using Story points?The other day I was talking about why bothering using Story Points instead of just estimating everything in hours. <a href="http://hem.ektv.nu/%7Eekt013631/RKronfalt-EstimationUsingStoryPoints%28scrumftw.blogspot.com%29.ppt"></a><a href="http://hem.ektv.nu/%7Eekt013631/RKronfalt-EstimationUsingStoryPoints%28scrumftw.blogspot.com%29.ppt">Here's a link to the slides</a>.<br /><br />Traditionally, the aim has been to try to estimate time by looking intensely at a problem (or a task, activity, requirement,…) – so traditionally there’s a lot of effort spent on breakdown, analysis & estimation. But at the same time, we all know that estimating time is very hard and often pretty inaccurate – because software development is research-oriented and there are things that surface only once we start digging in, which then change the picture. We all know this – yet those time estimates tend to become commitments down the line.<br /><br />I argue that it’s not only the problem (task, activity, requirement,…) that is hard to foretell; the <span style="font-style: italic;">environment</span> where we solve the problem also has a significant effect on the amount of time it will take to complete. And often the environment is much harder to foretell than the problem itself. So, in the end it doesn’t matter how long time you spend analyzing, you will still have a large unknown in the shape of the environment.<br /><br />The point I want to make is that estimating in Story Points is about recognizing that <span style="font-style: italic; font-weight: bold;">Time </span>is a result of the <span style="font-style: italic; font-weight: bold;">Size </span>of a problem solved within a certain <span style="font-style: italic; font-weight: bold;">Context</span>.<br /> <span style="font-family:courier new;">Time = Size x Context</span><br /><br />Story Points is a unit for representing Size. This way Context becomes something we can grasp by comparing Size to Time – which is why we measure Velocity.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com2tag:blogger.com,1999:blog-4886064834625370180.post-6763139466389810782009-06-08T22:32:00.010+02:002009-06-17T09:19:23.938+02:00Agile Version Control - another magic bulletI have previously posted articles about what the magic bullet of agile software development is; to achieve flexible scope. As you may recall, the article talks about the three most important aspects of your Scrum implementation which make up the fundament for being able to achieve this scope flexibility:<br /><ul><li>Strict prioritization (having it and following it)</li><li>Definition of Done (having one and following it)</li><li>Story breakdown & formulation skills (understanding its importance, and constantly trying to improve) </li></ul>In hindsight, I feel I have left out one important success factor when it comes to reaching a truly flexible scope; version control.<br /><br />Most of us use one form of version control or another, but in my experience it is often (mistakenly so) only a matter of choosing the tool. The options are many, and range from “open source” to “incredibly expensive”. Once you decide on the tool, you use it for version tracking your codebase by checking out, committing and merging files. Perhaps you use branches in order to separate some work from other. But you may be missing an important tool; an <span style="font-style: italic;">Agile Version Control Policy</span>.<br /><br />If you do Scrum or some other form of Agile Development, you want to be able to actually finish your product increment every iteration, right? The purpose is to be able to achieve a flexible scope so that you can potentially ship on any day, at any given time. And what I am trying to get to here is that it doesn’t matter how well you succeed with your adherence to a Definition of Done if you don’t combine it with applying an Agile Version Control policy (completely regardless of which version control system you’re using). If you don’t have an Agile Version Control policy in place you risk mixing up your “Done-Done” code (code and assets related to User Stories that have been completely done according to the Definition of Done) with code which is in progress.<br /><br />And guess what: if you mix Done code up with Code in progress, you’re no longer able to release at any given time!<br /><br />Without Agile Version Control, shipping your software will mean that you first have to perform a series of tasks related to isolating code that is Done-Done from code that is in progress at that moment, and also often tasks related to doing last-minute polishing “while you’re at it”. The result is that shipping code is hard and a “big deal” and something that takes a lot of time. And what else does it cause? Yeah: crunch.<br /><br />So how do you achieve this separation of Done-Done code from code in progress? Well, there are plenty of good articles out there to read: <a href="http://www.infoq.com/articles/agile-version-control">this one</a> for example, written by Henrik Kniberg.<br /><br />In short, what you need to do is dedicate a branch for containing that Done-Done code (let’s call this branch “Done Branch”), and define some rules for it. For example "all code on the Done Branch must adhere to the Definition of Done", "no code may be published to Done Branch without being reviewed", "code may only be published there by the branch owner", and so on.<br /><br />Simplicity ftw! Here is a very simple Agile Version Control policy that I’ve been using;<br /><br /><span style="font-weight: bold;">Live Branch</span><br />Description: Create a branch from the trunk when you make a public/final release, that you will maintain for a while (until next release). Maintenance (patching) happens (for sake of simplicity) directly against this branch.<br /><br />Branch policy:<br /><ul><li>All code in Live Branch must be tested and working.</li><li>All code in Live Branch must compile & build. In short: all code in Live Branch must follow Definition of Done.</li><li>Code may only be published to Live Branch by branch owner (who may delegate it).</li><li>Patches on Live Branch are immediately published to Trunk as the last step, and any conflicts are resolved on Trunk until code adheres to the branch policy. Note that you don’t resolve the conflicts on the Live Branch because it would imply updating Live with whatever is on Trunk (which can be a lot of changes).</li></ul><br /><span style="font-weight: bold;">Done Branch</span> (which happens to be the Trunk, aka Main)<br />Description: Use the trunk (aka main branch) as “Done branch”. This will contain only code from stories that are Done-Done.<br /><br />Branch policy:<br /><ul><li>All code in Done Branch must be tested and working.</li><li>All code in Done Branch must compile & build. In short: all code in Done Branch must follow Definition of Done.</li><li>Code may only be published to Done Branch by branch owner (who may delegate it).</li></ul><br /><span style="font-weight: bold;">Development Branch </span><br />Description: Create a branch from the Trunk in which the team works during the sprints. The branch exists across several sprints.<br /><br />Branch policy:<br /><ul><li>All code in Development Branch must compile & build.</li><li>The Development Branch should be updated from Trunk often (suggest daily).</li><li>Conflicts with Trunk are resolved in Development Branch until code adheres to the branch policy.</li></ul>Remember to update your code often from Development Branch (i.e. spark merges as often as possible!).<br /><br />This simple policy relies only on three branch types; Live, Done and Development. Your Trunk (aka Main) is your Done Branch. There is a drawback with this policy though; if you have <span style="font-style: italic;">multiple teams</span> who are developing (and finishing) stories <span style="font-style: italic;">which are supposed to be able to release independent of each other</span>, then you will not be able to use the policy above (because Done-Done code from the two teams will be mixed up in the Done Branch). But, do you really have the requirement of teams to be able to release code independent of each other at different dates? Think carefully about this – do you really? If you do, fine: in that case you have to have a slightly more sophisticated setup (with a separate Done Branch + a separate Development Branch per team, and consequently you can’t use the Trunk as your Done Branch). You can read more about such a setup (Agile Version Control in a multi-team environment) in the paper by Kniberg that I referenced above.<br /><br />As always, I’d be glad to hear about other peoples’ experience in this area. Please leave comments.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com5tag:blogger.com,1999:blog-4886064834625370180.post-43898874417222931942009-05-28T16:15:00.003+02:002009-06-17T09:11:18.300+02:00When Scrum meets traditional quality assuranceThe contents of this post has been growing on me for some time. It’s about the challenge of working with Scrum in an organization where there’s a lot of traditional (eg waterfall based) ways of doing things.<br /><br />Let’s say you’re the manager of a team that develops and maintains some software system. Let’s say you’ve successfully introduced Scrum in that development team and they’re doing well and things are progressing. But, you don’t have any “Testers” on your team. Yet. Whatever testing is done is performed by the programmers themselves, in a more or less ad hoc way. Now, there’s a whole “QA Department” in your company, with resource(s) available for you. But it is an entirely different department that is not under your control. All you can do is request and allocate one or more resources from QA – but you’re not in a position to affect how they work. They are used to working according to a waterfall style project model. The processes that they follow rely on a “requirement specification” to exists ahead of time, before the implementation begins, together with a detailed and approved UI design ahead of time, a detailed and approved system design ahead of time, and so on. So the Testers from the QA Department will not be able to assist with any testing unless you have these things in place for them to start building test cases and test specifications on. What do you do?<br /><br />One of the most central challenges for me right now with regard to Scrum & Agile Development is exactly that: How to continue working with Scrum in my development team and still manage to cooperate and integrate smoothly with another department that is not yet working according to Scrum or the Agile philosophy.<br /><br />Is it possible to follow agile principles in only one part of the software development process?<br /><br />So far, since I haven’t had any testers on my team, I have more or less been ignoring the problem and simply done things cowboy-style. I’ve run the project as a pure Scrum project, with user stories in a Product Backlog, with a Scrum Product Owner, with velocity measurement, etc, etc. And – in line with Agile – we’ve worked in a strictly prioritized order, so consequently we haven’t spent much time yet on those lower priority backlog items, and they would certainly not yet be possible to use for formulating any “Test Cases” in the QA Department’s meaning of the word. But the time is coming where my Scrum team and their way of working will meet the QA Department and its way of working. Will the two fit?<br /><br />Don’t misunderstand me! I’m really looking forward to getting those QA resources on the team, and I’m 100% confident, regardless of philosophies and project models, that quality will benefit from the addition of QA resources – no question about it. But I’m worried that the benefit may be at the expense of “quality” in the development process itself (in the sense of me having to “sacrifice” certain Agile cornerstones).<br /><br />In my view, “testing” and “quality assurance” is not something that is applied on top of programming as a separate stage. Quality assurance is something that is intertwined with the entire software lifecycle; from idea, through analysis, design and development, to integration and system testing, rollout, handover and maintenance. And since it is all intertwined inside the software lifecycle, it is not possible to limit Agile philosophies to programming only. To be precise, and to answer my own question above; No I don’t think you can be “agile” in an environment where you finalize a “Requirement Specification” at the beginning of the project, and then base everything on it; plans, designs, test cases, etc.<br /><br />So, my plan is that together with the coming QA resource we will try to find a way for us to meet half-way; to find a way of working that requires minimal change in the QA processes and still minimal change in the Scrum implementation. I really think this can be done.<br /><br />Here’s the approach so far;<br /><br />What does the QA Department do? Well, they test software. What information do they need in order to be able to test? Well, they need a test plan, and they need a set of test cases. And what information is needed in order to create the test plan? A schedule, probably. Great! I can deliver a schedule, no problem. I just have a slightly different way of creating it than traditional projects.<br />And what information is needed in order to formulate test cases? “Requirements”! Could I deliver the backlog as “the requirements”? I suspect no. Darn. Why? Well, the User Stories alone are probably not detailed enough for QA to base test cases on; the level will be too high and there will be too much room for ambiguity, especially before we start working on the story. However, once we’re done with each story we’ll know more about the requirements. I don’t want to have to deliver the requirements ahead of time.<br /><br />But wait. Didn’t I say that QA is an integral part of the software lifecycle? Yes I did :-). So what is Scrum? Iterative and Incremental. Can’t the “Requirement Specification” also be created Iteratively and Incrementally? And consequently; can’t the set of Test Cases (the Test Specification) also be created Iteratively and Incrementally?<br /><br />So, the goal for us now is to make incremental deliveries of the “Requirement Specification” and of the “Test Specification”, in parallel to the incremental deliveries of software – sprint by sprint. We’re just getting started and are working out the practical bits in order to achieve this. For example, we’ll include in our Default Definition of Done that Requirements should be formulated. Secondly, we’ll keep track of which Stories are Done-Done (meet Definition of Done) at the end of each Sprint. The tester will use that information as input for his work. So at the end of each sprint there’s a new set of finished Stories accompanied with Requirements, that the tester can use as input to create a Test Specification increment. This way, the formulation of test cases is done one sprint behind the development. It might not be optimal, but considering that the tester is not full-time allocated to the development team, doesn’t sit with us, and that I’m not really attempting to reshape the entire QA department’s process all at once at this point :-), I think it’s a fair construction and a good trade-off.<br /><br />So. That’s where I am right now. I’ll post an update as we progress!<br /><br />I’d be glad to hear about other people’s experience about this type of situation.Richard Kronfälthttp://www.blogger.com/profile/03311642377622034282noreply@blogger.com10