Years ago, back when I was dumber…
Once every three months or so we'd have some incomplete story and we'd split the points, allocating some to this iteration and some to the next iteration. That's dumb.
Instead, for the last couple years when this happens I give no points to this iteration and points remaining (we estimate the remaining work) to the next iteration. Back then, the lower velocity would have caused angst in upper management, but read on.
We estimated our stories in points. We did not estimate our tasks. Our tasks were very fine grained. Most tasks were half an hour to half a day. We did not come up with tasks in planning. I wouldn't change any of that. In fact, it's what I currently try to get my clients to do. The difficult part seems to be the very fine grained tasks.
For us, 0 and 1 point stories were trivial. Normal estimates could be 5, 10, 15, 20, 30, or 40 points. If it was 40 or below, the story could go into an iteration. We would also use 60 and 100 point estimates, but those stories had to be split. Our problem was that the 30s and 40s were always underestimated relative to the 5s through 20s. The scale wasn't linear. We knew this. Knowing it didn't fix it. That made our velocity unstable.
Our unstable velocity caused lots of heart-burn in the upper management ranks and contributed to a lack of trust. If I had a do-over, I would solve this by narrowing the range of estimates allowed which would drive more of the larger stories to be split. I'd limit the range to, say, 5 to 20.
I've also considered solving an unstable velocity by clearly setting a high level of commitment for each iteration. Not stretch goal. Not aggressive goal. A high level of commitment. The team would of course still say what they would commit to. But I would have expected them to meet it. (This has sense been deemphasized in Scrum, and I didn't do it then and I wouldn't do it on most teams now, but it might have helped in this situation, as I describe next.) This surely would have initially led the team to commit to a smaller amount of work. And it would have eventually led to more care being made at the start of the iteration and in advance of the iteration in order to have a well thought out plan. We would have gotten back to committing to the normal amount of work over the long term, but would have given us a much more stable velocity and more predictable pace. Maybe. If done wrong it would have just angered the programmers.
Another way of getting at smaller stories and better planning would have been for us to drop from two-week to one-week iterations. That would also force us to split the larger stories. We already had a great design/task-creation/review approach, but we did that design just in time, during the iteration, immediately before development. With one-week iterations, we could do that work for each story on the 1st day of the iteration between planning and commitment.
And yet another way to crack this nut would have been to switch to a cycle time metric (as in Kanban) or publish only an average velocity measured over four to six iterations.
A blog about product development, product management, team and program management, lean, agile, and software development. Occasional posts about bicycling, Christianity, or racism.
September 13, 2011
September 12, 2011
A BVC for Tech Debt
Thinking back to some of my days in management years ago, if I had a do-over, I would create a better big visible chart for our technical debt. What we had was a list of code examples to not follow, some cleanup tags in the code, the occasional debt reduction story card, and sometimes a list of debt-full areas written on the whiteboard.
What else we needed was a consolidated list of our debt on a single Big Visible Chart (BVC). We'd write each technical debt on the BVC as we either encounter it the first time or when we knowingly introduce it. Then each time we encounter it thereafter we could put a dot next to it. A dot for each day it slows us down or for each day of impact it causes.
Most teams I've seen could benefit from quantifying technical debt in this way. You've got to make the impact visible. Otherwise it can be difficult to get the understanding of, or even support from, others in the business. It easy for those who don't interact regularly with the developers and who don't have a recent development background and experience with better practices to lack trust. Not only that, quantifying debt can help a team prioritize their debt reduction efforts and keep them on top of it.
What else we needed was a consolidated list of our debt on a single Big Visible Chart (BVC). We'd write each technical debt on the BVC as we either encounter it the first time or when we knowingly introduce it. Then each time we encounter it thereafter we could put a dot next to it. A dot for each day it slows us down or for each day of impact it causes.
Most teams I've seen could benefit from quantifying technical debt in this way. You've got to make the impact visible. Otherwise it can be difficult to get the understanding of, or even support from, others in the business. It easy for those who don't interact regularly with the developers and who don't have a recent development background and experience with better practices to lack trust. Not only that, quantifying debt can help a team prioritize their debt reduction efforts and keep them on top of it.
September 6, 2011
Off the Road Again
Working with Pillar Technology was fun. They are a great bunch of people and have some amazing programmer talent. I'm glad I followed Mike Cottmeyer to Pillar and really enjoyed working with him. I can't thank him enough for the help he gave me early on. I'm appreciative of the slack and the support Matt VanVleet gave me. Working with Pillar also gave me lots of opportunity to work with and be challenged by Matt Barcomb. Always a plus. But going independent gives Pillar and I some relief from the costs and pressures of my travel to the Northeast.
I am engaged with a great client here in Sandy Springs but my calendar through the end of the year isn't full. Help me fill it! I’d enjoy talking through your projects and the challenges they bring and how we can work together. Let's meet up. Give me a call or drop me an email.
These last couple of years I've re-learned how passionate I am about coaching and training. I've never had more joy from work than when I help a team improve their environment and see their appreciation. I've been blessed to be able to do that as part of my job from '99 through '09. And I have been even more blessed to make it my sole focus since then.
Each context is different, a unique challenge requiring a unique prescription. I'm looking forward to bringing this passion and experience to new challenges, in your context, to your environment.
August 23, 2011
Bias
The other night I found a credit card receipt from The Pampered Chef. This is one of those Tupperware party kind of things that women go to and overpay for stuff because they feel guilty for insulting the party giver if they don't buy something. I told Laura before she went to that party to not buy anything. I had just started my own business and had made it clear in a Family Meeting that we're going to restrict our spending until I see what kind of cash flow we're going to have. We were to buy nothing unless we could eat it.
So, as Laura was heading off to this Pampered Chef party the other day and I told her not to buy anything, she told me she was getting a free meal out of it so I should relax. I can't remember if she explicitly agreed to not buy anything but I know she heard and understood my request to not-buy-anything.
What was she thinking? I stewed over this all night. Laura was already asleep when I found the receipt. I didn't think I should wake her up to discuss this. I knew that wouldn't go over well. So I stayed up thinking about how I'd approach this in the morning.
I avoided my wife for a while the next morning. When I could avoid her no longer I told her I thought we agreed that she wasn't going to buy anything at that party. Laura calmly told me she bought me a birthday present. A $22.26 birthday present. She bought something inexpensive which is exactly what I would have wanted her to do. And I bet it's an incredibly thoughtful gift.
Man did I feel like a heel.
I've been reading lately about biases. In The Principles of Product Development Flow, Donald G. Reinertsen says that psychologists know that "…[humans] have a general bias to interpret the behavior of other people negatively."
There is a nice list of cognitive biases on wikipedia. Some that are particularly relevant to this topic are:
But why would I assume the worst of my spouse? That's ridiculous. Of all the people in the world, I should not have these biases towards her. If this can happen within my family, how much more so can it happen in the workplace?
What I learned from this experience is how real these biases are and how on-guard we as humans need to be. Poor communication skills (or just a simple mismatch in communication styles), fear of reprisal and fear of confrontation can make matters worse. The problem with poor communication is we always assume it's the other person who can't communicate.
Kerth's Retrospective Prime Directive hints at a solution:
And in Coaching Agile Teams, Lyssa Adkins says to "...create a positive regard for them. Do this by changing your view of them. Regard the person as a human being with hopes, dreams and desires (like your own) so that you can approach them with love and compassion..."
How do you foster this in an organization?
Reinersten offers this advice:
Chats around the water cooler, going out to lunch together, after-work drinks, post iteration and post release celebrations and kick offs beforehand are good things to try. Fantasy football and office baby birth date/weight pools and the like can help. Team working agreements (norms) posted on a big visible chart can help. Praying daily for your co-workers by name helps remarkably well. Other ideas?
We can bring up the elephant in the room in our retrospectives, but other than just hashing it out, what techniques or exercises have you found useful?
Most of us don't enjoy a tense and confrontational workplace. Likewise, most of us don't recognize how much we ourselves contribute to that situation.
What additional advice do you have to combat bias, increase non-task-related interpersonal communication and improve interpersonal relationships?
So, as Laura was heading off to this Pampered Chef party the other day and I told her not to buy anything, she told me she was getting a free meal out of it so I should relax. I can't remember if she explicitly agreed to not buy anything but I know she heard and understood my request to not-buy-anything.
What was she thinking? I stewed over this all night. Laura was already asleep when I found the receipt. I didn't think I should wake her up to discuss this. I knew that wouldn't go over well. So I stayed up thinking about how I'd approach this in the morning.
I avoided my wife for a while the next morning. When I could avoid her no longer I told her I thought we agreed that she wasn't going to buy anything at that party. Laura calmly told me she bought me a birthday present. A $22.26 birthday present. She bought something inexpensive which is exactly what I would have wanted her to do. And I bet it's an incredibly thoughtful gift.
Man did I feel like a heel.
I've been reading lately about biases. In The Principles of Product Development Flow, Donald G. Reinertsen says that psychologists know that "…[humans] have a general bias to interpret the behavior of other people negatively."
There is a nice list of cognitive biases on wikipedia. Some that are particularly relevant to this topic are:
These are amplified by an additional set of biases:
• Actor–observer bias – the tendency for explanations of other individuals' behaviors to overemphasize the influence of their personality and underemphasize the influence of their situation (see also Fundamental attribution error), and for explanations of one's own behaviors to do the opposite (that is, to overemphasize the influence of our situation and underemphasize the influence of our own personality).
• Fundamental attribution error – the tendency for people to over-emphasize personality-based explanations for behaviors observed in others while under-emphasizing the role and power of situational influences on the same behavior (see also actor-observer bias, group attribution error, positivity effect, and negativity effect).
• Bias blind spot – the tendency to see oneself as less biased than other people.
• Negativity bias – the tendency to pay more attention and give more weight to negative than positive experiences or other kinds of information.
• Availability cascade – a self-reinforcing process in which a collective belief gains more and more plausibility through its increasing repetition in public discourse (or "repeat something long enough and it will become true").
• Halo effect – the tendency for a person's positive or negative traits to "spill over" from one area of their personality to another in others' perceptions of them (see also physical attractiveness stereotype).
• Illusion of asymmetric insight – people perceive their knowledge of their peers to surpass their peers' knowledge of them.
• Illusion of transparency – people overestimate others' ability to know them, and they also overestimate their ability to know others.
• Illusory superiority – overestimating one's desirable qualities, and underestimating undesirable qualities, relative to other people. (Also known as "Lake Wobegon effect," "better-than-average effect," or "superiority bias").
• Ingroup bias – the tendency for people to give preferential treatment to others they perceive to be members of their own groups.
• Projection bias – the tendency to unconsciously assume that others (or one's future selves) share one's current emotional states, thoughts and values.
But why would I assume the worst of my spouse? That's ridiculous. Of all the people in the world, I should not have these biases towards her. If this can happen within my family, how much more so can it happen in the workplace?
What I learned from this experience is how real these biases are and how on-guard we as humans need to be. Poor communication skills (or just a simple mismatch in communication styles), fear of reprisal and fear of confrontation can make matters worse. The problem with poor communication is we always assume it's the other person who can't communicate.
Kerth's Retrospective Prime Directive hints at a solution:
Regardless of what we discover, we understand and truly believe that everyone did the best job they could, given what they knew at the time, their skills and abilities, the resources available, and the situation at hand.How do you encourage that other than posting it and reviewing it before retrospectives?
And in Coaching Agile Teams, Lyssa Adkins says to "...create a positive regard for them. Do this by changing your view of them. Regard the person as a human being with hopes, dreams and desires (like your own) so that you can approach them with love and compassion..."
How do you foster this in an organization?
Reinersten offers this advice:
This tendency [toward bias] is reduced when we get to know others as complex hum beings, much like ourselves. Task related (job related) communications by itself is not enough to create an appreciation of this complexity. Non-task-related interpersonal communication that comes from colocation is key to developing cohesive teams.
Chats around the water cooler, going out to lunch together, after-work drinks, post iteration and post release celebrations and kick offs beforehand are good things to try. Fantasy football and office baby birth date/weight pools and the like can help. Team working agreements (norms) posted on a big visible chart can help. Praying daily for your co-workers by name helps remarkably well. Other ideas?
We can bring up the elephant in the room in our retrospectives, but other than just hashing it out, what techniques or exercises have you found useful?
Most of us don't enjoy a tense and confrontational workplace. Likewise, most of us don't recognize how much we ourselves contribute to that situation.
What additional advice do you have to combat bias, increase non-task-related interpersonal communication and improve interpersonal relationships?
August 16, 2011
Sizing with Incomplete Information
Some teams that I work with that are new to agile struggle to size their first big agile release. The team is often still trying to gel, assimilate new members, and increase their velocity while spending lots of time creating, understanding and refining the product backlog. One of the challenges they face is learning to estimate with imperfect and incomplete information. How quickly they adapt seems to depend on what they are presented with during their 1st agile/relative estimating session.
Some teams new to agile start with a new project and need to estimate the whole thing with little info, perhaps during a "sprint 0". Those teams are forced to deal with ambiguity right from the start. From then on they accept that they'll have to estimate fuzzy stories. This helps them accept that stories will change, both the details of individual stories as well as what stories make up the backlog. Sometimes revealed detail changes an estimate (up or down). Sometimes it doesn't. But that's life and we can deal with that quite well on an agile project. More on that in a moment.
Other teams I work with already have a project well underway. They have a product in maintenance when they go agile. They've got lots of small and well understood stories. Or if they aren't well understood, they can get that way quickly. The 1st stories they estimate are detailed and certain. But a day will come when the team is forced to estimate some new release or some new product with less than full information. That can be frightening. As these estimates are recorded, we can note that the estimates were made with less info and certainty, but that seldom provides much comfort to this type of team.
However, what you'll find (on a healthy team) is that:
Seeing is believing
On the second type of team this learning happens slowly. You can have a conversation around these things to try to speed up the learning or to provide some comfort. It's certainly worth trying. But don't be surprised if your convincing arguments are met with disbelief.
Some teams new to agile start with a new project and need to estimate the whole thing with little info, perhaps during a "sprint 0". Those teams are forced to deal with ambiguity right from the start. From then on they accept that they'll have to estimate fuzzy stories. This helps them accept that stories will change, both the details of individual stories as well as what stories make up the backlog. Sometimes revealed detail changes an estimate (up or down). Sometimes it doesn't. But that's life and we can deal with that quite well on an agile project. More on that in a moment.
Other teams I work with already have a project well underway. They have a product in maintenance when they go agile. They've got lots of small and well understood stories. Or if they aren't well understood, they can get that way quickly. The 1st stories they estimate are detailed and certain. But a day will come when the team is forced to estimate some new release or some new product with less than full information. That can be frightening. As these estimates are recorded, we can note that the estimates were made with less info and certainty, but that seldom provides much comfort to this type of team.
However, what you'll find (on a healthy team) is that:
- Large estimates on the larger stories tend to drive the Product Owner to decompose those behemoths and then ask for new estimates.
- The team is allowed and even encouraged to revise the estimates (up or down) as more information is revealed.
- Many of the estimates will not need to be revised. Any additional detail or certainty often doesn't affect the estimate after all.
- Consistency is good, but accuracy and precision are not necessary. Wrong estimates have an offsetting impact on velocity. That's the beauty of using relative estimates and the empirically measured velocity to compute a release end-date -- an incorrect increase in one gives an offsetting decrease in the other.
- There will be details that are overlooked. Developers tend to be optimistic with estimates. But that too will soon be taken into account in the velocity (unless you implement all the well understood stories 1st and always save the others for later). (Do note, however, that the shorter your release is the shorter your iterations need to be in order for a change in velocity to be noticed in time.)
- And management will heed the warning signs when presented with the estimates and velocity and not pressure the team into short-cutting craftsmanship, quality or sustainable pace. (Remember that I said /healthy/ team.)
Seeing is believing
On the second type of team this learning happens slowly. You can have a conversation around these things to try to speed up the learning or to provide some comfort. It's certainly worth trying. But don't be surprised if your convincing arguments are met with disbelief.
June 2, 2011
Engineering Practices Necessary for Scrum
Atlanta has a wonderful tech community. User groups abound. We even have three different agile user groups that meet each month (or more than that if you count the craftsmanship meetup as an agile group and SPIN as partly so). Earlier this year Semeer Bendre asked on twitter why we have these different communities, copying Mike Cottmeyer, Dennis Stevens and I. I tweeted back that #atlantascrum tends to focus more on #scrum whereas #agileatlanta is more free to cover other stuff, such as dev practices. Mike Cottmeyer quickly corrected me, saying they cover fundamentally the same material and XP isn't oob at #scrumatlanta. Then to prove his point, to show just how wrong I was, Mike signed me up to do a talk at #atlantascrum on "Exploring the Engineering Practices Necessary for Scrum." (Let that be a warning to you to tweet wisely.) This blog post came out of that talk. It's pretty much what I said, edited some for this format.
If I have any bias concerning this topic it is that I'm a long-time strong believer in eXtreme Programming. Heck, I was agile when agile wasn't cool. In fact, it wasn't even called agile yet back then. We founded XP Atlanta before the manifesto meeting in Snowbird. And back in 2000 my team gave me a red cape with a big XP on the back. It wasn't until later that I realized that they thought of me more as a super-villain than a super-hero. They wanted me to wear the cape so they could see me coming. And hear me when I made the swooshing noises. But I digress.
I'm otherwise fairly balanced with half my career using a plan driven approach and the later half using an agile approach; and most of my career as a programmer but more than several years in management and product management.
ENGINEERING PRACTICES IN XP
So, first, before we look at Scrum, let's look at the engineering practices in XP. This is the briefest of summaries of these practices.
As an aside, the non-programmers on our teams need to understand and appreciate what this stuff is. Be kind and explain it to them in a way they can understand. Offer them a non-technical, or at least very lightly technical, lunch and learn. This will help us all work together in harmony.
Pair Programming is far more than continuous code review. The pair is thinking on multiple levels: one about the low-level details, names, indentation and syntax while the other is thinking about the big picture, whether this test is sufficient, whether it's the right test, what's the next step, about the next refactoring, and may be helping look up something in the language or API docs. Pairing improves quality and speed of development, or it at least increases the longevity of the codebase by holding entropy at bay. Pairing supports simple design and helps enforce the use of these other practices (peer pressure).
If you are just watching the other guy code, you aren't pairing. Pairing is active. Who has the keyboard should change every minute or three. Try using the ping-pong technique whereby one programmer codes a failing test. The other programmer then makes that test pass and codes the next failing test. Then the first programmer takes over again, and so forth.
Test-Driven Development is where a test (that fails) is coded before the production code (that makes the test pass) is written. TDD supports Refactoring and Collective Code Ownership and Continuous Integration and other things like small releases and iterative development. Out of doing TDD you get automated unit tests for all code. (Or automated acceptance tests for all stories for ATDD.) A related technique is to write an automated test to reveal a defect before the defect is addressed.
Continuous Integration is where you integrate changes daily and preferably much more often. The opposite, of course, is leaving integration until later, which is often a tedious, lengthy, buggy and painful process. A student of lean will learn that leaving integration for later will lessen the likelihood of good luck. Or, delay causes waste.
Refactoring is improving the design without changing the functionality. Many don't do this right or well. It's best done "in the small" all the time, not in large steps and infrequent. The later may be design change, but I'm loathe to call it refactoring. Good examples are small things like rename class, extract method, move method, introduce variable, etc. Most of these common refactorings are supported by the IDEs we use today, such as Eclipse, Intellij, and VisualStudio with Resharper. Proper Refactoring supports simple design and testing.
Coding Standards supports Pairing and Collective Code Ownership. I don't recommend writing your own. There are many published coding standards. I suggest adopting one of those.
Collective Code Ownership is where everyone on the team is responsible for that team's code. All team members may change all the code. We're assuming we have a small team (or teams) of 7 +/- 3 coders. This practice reduces delay (waiting/blocks) and risk. For this, you need pairing and tests.
Simple design -- It's simple design, not simplistic design. Simple design makes code understandable and therefore more maintainable and modifiable.
System Metaphor is a story that everyone can tell about how the system works. This usually yields a system of names. It supports Collective Code Ownership and Simple Design.
So, that's just the XP engineering practices, not all of XP's practices. And that's about XP. That's not about Scrum.
BACK TO SCRUM
But the topic proposed for Atlanta Scrum group was "Exploring the Engineering Practices Necessary to Support Scrum".
So let's get around to that, but before we do, let me take one more detour. If I wanted to find a definition of agile on the internet, where might I look? I'd look on Wikipedia: http://en.wikipedia.org/wiki/Agile_development
Lo and behold, a definition of agile. And, there's a picture of Sutherland. I'm a little miffed that Scrum gets top billing, but at least if I page down, I see a picture of a couple pair-programmers practicing XP.
Now, what are agile engineering practices? I've shown you the XP ones above. What are the 'Scrum' or 'agile' engineering practices? Can't I find that on wikipedia too? Not as of today, but it was suggested to me during my talk that I should fix that.
My point here is that there is no commonly accepted definition of what the agile engineering practices should be, at least not well enough to make it to wikipedia. I say all that to point out that the stuff written below is more of my opinion than are the facts about XP I've stated above.
ENGINEERING PRACTICES NECESSARY FOR SCRUM
What are the engineering practices necessary to support scrum? Go ahead. Write them down. I'll wait.
That's a nice list you have there, but does Scrum make them necessary? Are they necessary because you are doing Scrum? Is it specific to Scrum or is it agile in general? Here's my list of engineering practices necessary to support Scrum:
I categorically say no to all the practices on your list. None. There are no engineering practices necessary to support Scrum.
The question is a non-starter for me. And I say that as an XP fan, a process that believes in the importance of a specific set of engineering practices. I take exception on two grounds. The first is the word necessary.
Necessary is a bit of a strong word. It's kind of like saying always or never. You never take out the trash. You always make me walk the dog. You never put your dirty clothes in the hamper. You always leave the car on empty. You never say you love me any more. Things like that.
The second is the assumption that if you are doing Scrum you must also be involved in software development somehow. You might not be engineering anything at all.
Lots have blogged on this and there was a good debate on twitter about it (involving Jeffries or Shalloway or Sutherland or Schwaber?). It was about Scrum being sufficient or whether it needs development practices. One side said Scrum by itself is insufficient. The other said Scrum is what it is, it's fine as defined, please do use engineering practices, but Scrum doesn't need to be changed.
My wife runs our household using scrum. She's not the housewife, homemaker, domestic engineer: She's the product owner. (My 13 year old daughter who is made to clean the bathrooms is the scum master. But that's another story.) The point is, there are no engineering practices needed for Scrum to be useful in a household.
A team I once coached was the payroll department. They weren't engineering anything. They were building nothing. But they had initiatives and duties that they managed using Scrum. No engineering practices needed.
Pillar's recruiting team uses an agile approach. Pillar's on-boarding process uses an agile approach. Pillar's management uses an agile approach to manage our internal process improvement initiatives. These don't need engineering practices.
However, I know what you mean. I understand the real question. Maybe this is the question to ask:
When you are doing software development and Scrum, are there engineering practices that help?
Now you can bring out your list again.
But does Scrum make them necessary? Or are they universally necessary when doing software development in the current set of popular high level programming languages, namely Java and C# and Ruby? For the most part, I'd say universally helpful. So, we should scratch Scrum from that question and state it thusly:
Are there engineering practices that help if you happen to be on a project involving computer programming?
Absolutely.
Given that, here's my ordered list of useful software engineering practices. I am representing these as tiers upon which the more basic and most important are the foundation upon which the others are built.
FIRST TIER
Starting at the bottom, we have Continuous Integration and Automated Unit Testing. You get a lot out of this. It can hook most people, being a gateway drug, I mean, can help most people and it's a great place to start. Everything else is harder without this
I didn't list source code control, because, everyone does that now, right? I guess there are some things I just assume, and that's one of them.
I could put pairing in the bottom and that would make the other things more likely, but the rest could happen without pairing, so that is later. Besides, the business reality is that it's hard to find enough pair-programmers, so I'm resigned to think that I'll often have a non-pairing team somewhere in my organization.
Similarly, TDD makes sure UTs, refactoring, and emergent-design happen and has other advantages. But you canunit test without TDD, so TDD is higher up in my list.
How about sustainable pace? Is that a technical practice? I'm thinking it's more of a (project) management practice than a strictly technical practice. Otherwise, I'd stick it here.
SECOND TIER
You need tests before refactoring. Some would argue that you need refactoring to do automated testing. Lots of truth to that, but strictly speaking, you could test without refactoring. But you need TDD and Refactoring to support Tier Three.
THIRD TIER
In this tier is Simple Design. Simple is hard. To make things simple, you have to be quite knowledgeable about numerous design concepts. And you also need to be just plain good. You have to be knowledgeable in areas that can make your designs anything but simple if misused, which is why I said you also have to be 'just plain good' in addition to knowledgeable.
Also in this tier is Knowledge of Design Patterns. I didn't say use of design patterns. Use them in your conversations as shorthand, for a concise, rich with meaning way of communicating. But use them in your code carefully.
You should know SOLID design principles if your system is object oriented.
Emergent Design and Emergent Architecture is about recognizing the fact that we aren't going to get it right the first time. Let the design emerge/evolve over time as we learn. Even very very smart folks, the top folks in this field say they don't get it right the 1st time. (Seems like I should try to give a reference to that. Eh, I'll just put an unsubstantiated claim that I bet Cunningham, Jeffries, Uncle Bob, Joshua Kerievsky, Kent Beck, Corey Hanes, and may others would agree.)
This tier is really all supported with 'Ongoing Education', continuous learning. I really think there's lots to learn there and the field continues to grow. This is so difficult to do really really well, that we can never stop learning.
FOURTH TIER
Collective Code Ownership and Pair Programming require a Coding Standard.
As I mentioned earlier, Pair Programming is really a foundational technique, but I can't say that it's for everyone. I'm a strong believer in the technique and have required most of my employees give it a try for at least a month, though it can take two or three to really get accustomed to the approach.
FIFTH TIER
This is the just good old good to know tier. In here are some things that may change or be replaced by something else over time, more so than the ones in the other layers. This tier also includes things to have in your tool box, though you may never pull them out to use them:
Some might argue with me for putting ATDD or maybe BDD so high up. There are numerous techniques for automated testing at a higher level than unit testing that teams can choose from. I didn't want to list them all and I didn't want to say that one was better than others in all cases.
Likewise, Domain Driven Design is a useful technique, but I can't say every team must use that technique over another.
BACK TO SCRUM
Is there anything in Scrum that should lead us to do these things? You need these things to be agile software development team and these things support time boxed iterations. But there is also the Definition of Done. Some Scrum teams define what done means and hopefully it includes explicitly or implicitly some of these things.
After my talk at Atlanta Scrum on this topic last week I gave a demonstration/explanation of TDD. Surprisingly, I got more positive feedback about that than I did the presentation. Not that either was stellar, but I was expecting a different crowd than what showed up.
Contact me for a TDD demonstration or agile lunch-n-learn at your office.
If I have any bias concerning this topic it is that I'm a long-time strong believer in eXtreme Programming. Heck, I was agile when agile wasn't cool. In fact, it wasn't even called agile yet back then. We founded XP Atlanta before the manifesto meeting in Snowbird. And back in 2000 my team gave me a red cape with a big XP on the back. It wasn't until later that I realized that they thought of me more as a super-villain than a super-hero. They wanted me to wear the cape so they could see me coming. And hear me when I made the swooshing noises. But I digress.
I'm otherwise fairly balanced with half my career using a plan driven approach and the later half using an agile approach; and most of my career as a programmer but more than several years in management and product management.
ENGINEERING PRACTICES IN XP
So, first, before we look at Scrum, let's look at the engineering practices in XP. This is the briefest of summaries of these practices.
As an aside, the non-programmers on our teams need to understand and appreciate what this stuff is. Be kind and explain it to them in a way they can understand. Offer them a non-technical, or at least very lightly technical, lunch and learn. This will help us all work together in harmony.
Pair Programming is far more than continuous code review. The pair is thinking on multiple levels: one about the low-level details, names, indentation and syntax while the other is thinking about the big picture, whether this test is sufficient, whether it's the right test, what's the next step, about the next refactoring, and may be helping look up something in the language or API docs. Pairing improves quality and speed of development, or it at least increases the longevity of the codebase by holding entropy at bay. Pairing supports simple design and helps enforce the use of these other practices (peer pressure).
If you are just watching the other guy code, you aren't pairing. Pairing is active. Who has the keyboard should change every minute or three. Try using the ping-pong technique whereby one programmer codes a failing test. The other programmer then makes that test pass and codes the next failing test. Then the first programmer takes over again, and so forth.
Test-Driven Development is where a test (that fails) is coded before the production code (that makes the test pass) is written. TDD supports Refactoring and Collective Code Ownership and Continuous Integration and other things like small releases and iterative development. Out of doing TDD you get automated unit tests for all code. (Or automated acceptance tests for all stories for ATDD.) A related technique is to write an automated test to reveal a defect before the defect is addressed.
Continuous Integration is where you integrate changes daily and preferably much more often. The opposite, of course, is leaving integration until later, which is often a tedious, lengthy, buggy and painful process. A student of lean will learn that leaving integration for later will lessen the likelihood of good luck. Or, delay causes waste.
Refactoring is improving the design without changing the functionality. Many don't do this right or well. It's best done "in the small" all the time, not in large steps and infrequent. The later may be design change, but I'm loathe to call it refactoring. Good examples are small things like rename class, extract method, move method, introduce variable, etc. Most of these common refactorings are supported by the IDEs we use today, such as Eclipse, Intellij, and VisualStudio with Resharper. Proper Refactoring supports simple design and testing.
Coding Standards supports Pairing and Collective Code Ownership. I don't recommend writing your own. There are many published coding standards. I suggest adopting one of those.
Collective Code Ownership is where everyone on the team is responsible for that team's code. All team members may change all the code. We're assuming we have a small team (or teams) of 7 +/- 3 coders. This practice reduces delay (waiting/blocks) and risk. For this, you need pairing and tests.
Simple design -- It's simple design, not simplistic design. Simple design makes code understandable and therefore more maintainable and modifiable.
System Metaphor is a story that everyone can tell about how the system works. This usually yields a system of names. It supports Collective Code Ownership and Simple Design.
So, that's just the XP engineering practices, not all of XP's practices. And that's about XP. That's not about Scrum.
BACK TO SCRUM
But the topic proposed for Atlanta Scrum group was "Exploring the Engineering Practices Necessary to Support Scrum".
So let's get around to that, but before we do, let me take one more detour. If I wanted to find a definition of agile on the internet, where might I look? I'd look on Wikipedia: http://en.wikipedia.org/wiki/Agile_development
Lo and behold, a definition of agile. And, there's a picture of Sutherland. I'm a little miffed that Scrum gets top billing, but at least if I page down, I see a picture of a couple pair-programmers practicing XP.
Now, what are agile engineering practices? I've shown you the XP ones above. What are the 'Scrum' or 'agile' engineering practices? Can't I find that on wikipedia too? Not as of today, but it was suggested to me during my talk that I should fix that.
My point here is that there is no commonly accepted definition of what the agile engineering practices should be, at least not well enough to make it to wikipedia. I say all that to point out that the stuff written below is more of my opinion than are the facts about XP I've stated above.
ENGINEERING PRACTICES NECESSARY FOR SCRUM
What are the engineering practices necessary to support scrum? Go ahead. Write them down. I'll wait.
That's a nice list you have there, but does Scrum make them necessary? Are they necessary because you are doing Scrum? Is it specific to Scrum or is it agile in general? Here's my list of engineering practices necessary to support Scrum:
- none
I categorically say no to all the practices on your list. None. There are no engineering practices necessary to support Scrum.
The question is a non-starter for me. And I say that as an XP fan, a process that believes in the importance of a specific set of engineering practices. I take exception on two grounds. The first is the word necessary.
Necessary is a bit of a strong word. It's kind of like saying always or never. You never take out the trash. You always make me walk the dog. You never put your dirty clothes in the hamper. You always leave the car on empty. You never say you love me any more. Things like that.
The second is the assumption that if you are doing Scrum you must also be involved in software development somehow. You might not be engineering anything at all.
Lots have blogged on this and there was a good debate on twitter about it (involving Jeffries or Shalloway or Sutherland or Schwaber?). It was about Scrum being sufficient or whether it needs development practices. One side said Scrum by itself is insufficient. The other said Scrum is what it is, it's fine as defined, please do use engineering practices, but Scrum doesn't need to be changed.
My wife runs our household using scrum. She's not the housewife, homemaker, domestic engineer: She's the product owner. (My 13 year old daughter who is made to clean the bathrooms is the scum master. But that's another story.) The point is, there are no engineering practices needed for Scrum to be useful in a household.
A team I once coached was the payroll department. They weren't engineering anything. They were building nothing. But they had initiatives and duties that they managed using Scrum. No engineering practices needed.
Pillar's recruiting team uses an agile approach. Pillar's on-boarding process uses an agile approach. Pillar's management uses an agile approach to manage our internal process improvement initiatives. These don't need engineering practices.
However, I know what you mean. I understand the real question. Maybe this is the question to ask:
When you are doing software development and Scrum, are there engineering practices that help?
Now you can bring out your list again.
But does Scrum make them necessary? Or are they universally necessary when doing software development in the current set of popular high level programming languages, namely Java and C# and Ruby? For the most part, I'd say universally helpful. So, we should scratch Scrum from that question and state it thusly:
Are there engineering practices that help if you happen to be on a project involving computer programming?
Absolutely.
Given that, here's my ordered list of useful software engineering practices. I am representing these as tiers upon which the more basic and most important are the foundation upon which the others are built.
FIRST TIER
Starting at the bottom, we have Continuous Integration and Automated Unit Testing. You get a lot out of this. It can hook most people, being a gateway drug, I mean, can help most people and it's a great place to start. Everything else is harder without this
I didn't list source code control, because, everyone does that now, right? I guess there are some things I just assume, and that's one of them.
I could put pairing in the bottom and that would make the other things more likely, but the rest could happen without pairing, so that is later. Besides, the business reality is that it's hard to find enough pair-programmers, so I'm resigned to think that I'll often have a non-pairing team somewhere in my organization.
Similarly, TDD makes sure UTs, refactoring, and emergent-design happen and has other advantages. But you canunit test without TDD, so TDD is higher up in my list.
How about sustainable pace? Is that a technical practice? I'm thinking it's more of a (project) management practice than a strictly technical practice. Otherwise, I'd stick it here.
SECOND TIER
You need tests before refactoring. Some would argue that you need refactoring to do automated testing. Lots of truth to that, but strictly speaking, you could test without refactoring. But you need TDD and Refactoring to support Tier Three.
THIRD TIER
In this tier is Simple Design. Simple is hard. To make things simple, you have to be quite knowledgeable about numerous design concepts. And you also need to be just plain good. You have to be knowledgeable in areas that can make your designs anything but simple if misused, which is why I said you also have to be 'just plain good' in addition to knowledgeable.
Also in this tier is Knowledge of Design Patterns. I didn't say use of design patterns. Use them in your conversations as shorthand, for a concise, rich with meaning way of communicating. But use them in your code carefully.
You should know SOLID design principles if your system is object oriented.
Emergent Design and Emergent Architecture is about recognizing the fact that we aren't going to get it right the first time. Let the design emerge/evolve over time as we learn. Even very very smart folks, the top folks in this field say they don't get it right the 1st time. (Seems like I should try to give a reference to that. Eh, I'll just put an unsubstantiated claim that I bet Cunningham, Jeffries, Uncle Bob, Joshua Kerievsky, Kent Beck, Corey Hanes, and may others would agree.)
This tier is really all supported with 'Ongoing Education', continuous learning. I really think there's lots to learn there and the field continues to grow. This is so difficult to do really really well, that we can never stop learning.
FOURTH TIER
Collective Code Ownership and Pair Programming require a Coding Standard.
As I mentioned earlier, Pair Programming is really a foundational technique, but I can't say that it's for everyone. I'm a strong believer in the technique and have required most of my employees give it a try for at least a month, though it can take two or three to really get accustomed to the approach.
FIFTH TIER
This is the just good old good to know tier. In here are some things that may change or be replaced by something else over time, more so than the ones in the other layers. This tier also includes things to have in your tool box, though you may never pull them out to use them:
- Code Coverage
- Cyclomatic Complexity
- Other Code Metrics
- BDD
- ATDD
- Domain Driven Design
Some might argue with me for putting ATDD or maybe BDD so high up. There are numerous techniques for automated testing at a higher level than unit testing that teams can choose from. I didn't want to list them all and I didn't want to say that one was better than others in all cases.
Likewise, Domain Driven Design is a useful technique, but I can't say every team must use that technique over another.
BACK TO SCRUM
Is there anything in Scrum that should lead us to do these things? You need these things to be agile software development team and these things support time boxed iterations. But there is also the Definition of Done. Some Scrum teams define what done means and hopefully it includes explicitly or implicitly some of these things.
After my talk at Atlanta Scrum on this topic last week I gave a demonstration/explanation of TDD. Surprisingly, I got more positive feedback about that than I did the presentation. Not that either was stellar, but I was expecting a different crowd than what showed up.
Contact me for a TDD demonstration or agile lunch-n-learn at your office.
February 23, 2011
Comprehensive Documentation - Bad Assumptions
Agile is easy to dismiss. Many people hear something that doesn't sound right, something that sounds different than what they are accustomed to, and they develop misconceptions. They share their misconceptions with others. They dismiss agile without any more thought. A common misconception concerns documentation.
This came across my inbox recently:
Are his assumptions incorrect? There are likely a lot of assumptions in that short statement:
Agile simply warns against using documentation as a measure of progress. Instead, agile favors working software as a measure of progress. If comprehensive documentation helps you get to working software, or adds value after the software is written, then create comprehensive documentation. If you have a regulatory environment you can't get around, then meet your regulatory requirements, but be creative and try to find an automated approach to generating it. If we're talking end user documentation and you can't make your application usable without end-user documentation, then write end-user documentation. If we're talking about installation instructions, agile favors automation, but if you can't automate and can't make it easy, then document it. If you have published APIs, create them with great care, provide great documentation and treat them as contracts.
If we're talking about requirements specifications, agile prefers requirements documentation in the form of user stories, constant collaboration between the givers of the requirements and the implementers of the requirements, and automated story tests. If you aren't there yet, if you don't know how to do that yet, then keep writing requirements documents for now, and strive for continuous learning and continuous improvement.
If we're talking about comprehensive technical documentation of the implementation, agile favors the software craftsmanship approach of refactoring towards small methods with very clear and descriptive method, variable, and class names. This leads to readable and self-documenting code. Agile also favors high code coverage through automated unit tests, which documents how to use the implementation and the intent of it.
Every instance of agile is unique. Each adoption of agile must be tailored for the context in which it will live -- the organization.
Usually, however, comprehensive documentation is waste. If the documentation doesn't match the source code, the documentation is wrong. Documentation is almost always wrong. Using misleading documentation is wasteful. Maintaining documentation is expensive and it rarely achieves a defect free state. More waste.
At the very least, this person shouldn't throw the baby out with the bath water. A lot of value remains in agile even if he disagrees with its warnings about documentation. I'm not saying that agile is suitable in his environment -- it in fact might not be. He may have no change or uncertainty in his environment. He may have a very repeatable and predictable situation, ideally suited for a plan driven approach.
In any event, this person is most assuredly concerned about how something will be handled, be it support (handled by pair-programming and a coded test suite) or design (handled by design-all-the-time, pair-programming, test suite, refactoring) or coordination (handled by collaborative space, published and documented APIs as contracts), or etc... I could assuage his fears if I new what was underlying them. That would require a face to face conversation. I'd welcome that opportunity. With him, or with any of you, my readers, or with any of your colleagues. My email address and phone number are noted at the top of my blog. Contact me at any time.
This came across my inbox recently:
I spoke to …, and he doesn’t have a requirement for Agile. He is familiar with the methodology, and his concern is comprehensive documentation. He believes that is a critical part of development that becomes less critical with the Agile methodology. If his assumptions are incorrect, please let me know.
Are his assumptions incorrect? There are likely a lot of assumptions in that short statement:
- "Comprehensive documentation is a critical part of development." That may be true for his project. But it is not true for many projects. If he assumes that comprehensive documentation is too critical to do without on any project, his assumption is incorrect.
- "Comprehensive documentation becomes less critical with the Agile methodology." Often this is true. But that's a good thing. So, he's probably concerned about this…
- If he assumes you can't write comprehensive documentation on agile projects, his assumption is incorrect.
You can write all the documentation you want.
Agile simply warns against using documentation as a measure of progress. Instead, agile favors working software as a measure of progress. If comprehensive documentation helps you get to working software, or adds value after the software is written, then create comprehensive documentation. If you have a regulatory environment you can't get around, then meet your regulatory requirements, but be creative and try to find an automated approach to generating it. If we're talking end user documentation and you can't make your application usable without end-user documentation, then write end-user documentation. If we're talking about installation instructions, agile favors automation, but if you can't automate and can't make it easy, then document it. If you have published APIs, create them with great care, provide great documentation and treat them as contracts.
If we're talking about requirements specifications, agile prefers requirements documentation in the form of user stories, constant collaboration between the givers of the requirements and the implementers of the requirements, and automated story tests. If you aren't there yet, if you don't know how to do that yet, then keep writing requirements documents for now, and strive for continuous learning and continuous improvement.
If we're talking about comprehensive technical documentation of the implementation, agile favors the software craftsmanship approach of refactoring towards small methods with very clear and descriptive method, variable, and class names. This leads to readable and self-documenting code. Agile also favors high code coverage through automated unit tests, which documents how to use the implementation and the intent of it.
Every instance of agile is unique. Each adoption of agile must be tailored for the context in which it will live -- the organization.
Usually, however, comprehensive documentation is waste. If the documentation doesn't match the source code, the documentation is wrong. Documentation is almost always wrong. Using misleading documentation is wasteful. Maintaining documentation is expensive and it rarely achieves a defect free state. More waste.
At the very least, this person shouldn't throw the baby out with the bath water. A lot of value remains in agile even if he disagrees with its warnings about documentation. I'm not saying that agile is suitable in his environment -- it in fact might not be. He may have no change or uncertainty in his environment. He may have a very repeatable and predictable situation, ideally suited for a plan driven approach.
In any event, this person is most assuredly concerned about how something will be handled, be it support (handled by pair-programming and a coded test suite) or design (handled by design-all-the-time, pair-programming, test suite, refactoring) or coordination (handled by collaborative space, published and documented APIs as contracts), or etc... I could assuage his fears if I new what was underlying them. That would require a face to face conversation. I'd welcome that opportunity. With him, or with any of you, my readers, or with any of your colleagues. My email address and phone number are noted at the top of my blog. Contact me at any time.
February 22, 2011
Scrum Fundamental: Planning and Iterating
This is my last post, for now, in this series on common issues teams have with fundamental Scrum concepts. Here are a few tips, reminders actually, for planning and iterating.
Make story estimates visible to the Product Owner. Understanding the relative costs of features helps make better trade-offs.
Product Owners reprioritize work not started. Always work on the highest value story and risk reduction stories first.
Plan a second release from the start. This takes the pressure off. “We’ve just got to have feature X!” becomes “ok, we’ll put feature X in the second release and not worry about it now.” You may never do feature X, or release two, but it helps the first release move along unhindered.
If you need to know when you’ll be done, make a build up chart for the release. See Alistair Cockburn’s article on this topic.
Minimize the amount of work in process (WIP). Limit this in two ways: In each iteration, have the whole team work on just a few stories (like, three to six, depending on size). I put some rules of thumb on this in an earlier post. Don’t start work on something that cannot be completed in the iteration. With traditional project management using Gantt charts, you identify and care for the critical path. With agile projects, you limit WIP and increase cross-training, teamwork, team goals and collaboration to care for the critical path.
In addition to limiting the number of stories in the iteration, limit how many stories can be in progress at any one time. Limiting WIP to, say, one-third of the number of stories committed to the iteration might be about right. Then work towards limiting it to just one.
That’s it for now. But there is so much more that can be said. I welcome your own thoughts and lists and links to other relevant information in the comments below.
Make story estimates visible to the Product Owner. Understanding the relative costs of features helps make better trade-offs.
Product Owners reprioritize work not started. Always work on the highest value story and risk reduction stories first.
Plan a second release from the start. This takes the pressure off. “We’ve just got to have feature X!” becomes “ok, we’ll put feature X in the second release and not worry about it now.” You may never do feature X, or release two, but it helps the first release move along unhindered.
If you need to know when you’ll be done, make a build up chart for the release. See Alistair Cockburn’s article on this topic.
Minimize the amount of work in process (WIP). Limit this in two ways: In each iteration, have the whole team work on just a few stories (like, three to six, depending on size). I put some rules of thumb on this in an earlier post. Don’t start work on something that cannot be completed in the iteration. With traditional project management using Gantt charts, you identify and care for the critical path. With agile projects, you limit WIP and increase cross-training, teamwork, team goals and collaboration to care for the critical path.
In addition to limiting the number of stories in the iteration, limit how many stories can be in progress at any one time. Limiting WIP to, say, one-third of the number of stories committed to the iteration might be about right. Then work towards limiting it to just one.
That’s it for now. But there is so much more that can be said. I welcome your own thoughts and lists and links to other relevant information in the comments below.
February 16, 2011
Scrum Fundamental: Communication, Delegation
I’ve been blogging lately on common issues in teams practicing Scrum or otherwise trying to be agile, and not having complete success. Yesterday's post covered a hodgepodge of items very loosely related to measuring progress. Last week's post covered user stories. Today I thought I’d talk about communication and delegation.
Communication
The purpose of the daily stand-up/scrum is communication. This is very important. The idea is to keep the meeting short (so make everyone stand) and have everyone share just the info that most everyone else needs to know. This can often be done in five or ten minutes.
Some teams cover what they did yesterday, what they plan to do today and roadblocks. It’s useful to mention some significant change that they are about to commit to source control.
Teams that are co-located and that pair-program with collective code ownership and limited Work In Process don’t typically need to discuss those topics because everyone already knows what everyone else is working on. Those teams just talk about less about what they are doing and more about their impediments – things that are slowing them down.
Decide what is most important for your situation. Whatever your standard topic is, don’t go into much detail or resolve anything during the meeting. Those that need to follow-up or work together or have a deeper discussion get together afterwards.
Whatever your standard topic is, vary it. Don’t get stuck in a rut. If you usually go in order by person, once in a while go in order by story. Throw in a different question to answer, perhaps related to something you are trying to improve upon identified in a retrospective.
The standup is a start, but don’t stop there. Stop using email. Get out of your seat and speak to someone face to face. And working with the whole team in an open space is a really really really good idea.
Delegation
Let go of assigning tasks to people. Let the team manage task assignment themselves. People will choose the correct tasks most of the time. When they don’t, let that be a learning experience.
Let the team estimate the stories.
Let the team come up with the tasks.
Make time for yourself. Take time to think about and to improve the system. By ‘system’ I’m referring to the process and the organization, not the software you are developing.
Next
Next up should be a post on planning.
What is on your short list of common problems related to some fundamental aspect of Scrum?
Communication
The purpose of the daily stand-up/scrum is communication. This is very important. The idea is to keep the meeting short (so make everyone stand) and have everyone share just the info that most everyone else needs to know. This can often be done in five or ten minutes.
Some teams cover what they did yesterday, what they plan to do today and roadblocks. It’s useful to mention some significant change that they are about to commit to source control.
Teams that are co-located and that pair-program with collective code ownership and limited Work In Process don’t typically need to discuss those topics because everyone already knows what everyone else is working on. Those teams just talk about less about what they are doing and more about their impediments – things that are slowing them down.
Decide what is most important for your situation. Whatever your standard topic is, don’t go into much detail or resolve anything during the meeting. Those that need to follow-up or work together or have a deeper discussion get together afterwards.
Whatever your standard topic is, vary it. Don’t get stuck in a rut. If you usually go in order by person, once in a while go in order by story. Throw in a different question to answer, perhaps related to something you are trying to improve upon identified in a retrospective.
The standup is a start, but don’t stop there. Stop using email. Get out of your seat and speak to someone face to face. And working with the whole team in an open space is a really really really good idea.
Delegation
Let go of assigning tasks to people. Let the team manage task assignment themselves. People will choose the correct tasks most of the time. When they don’t, let that be a learning experience.
Let the team estimate the stories.
Let the team come up with the tasks.
Make time for yourself. Take time to think about and to improve the system. By ‘system’ I’m referring to the process and the organization, not the software you are developing.
Next
Next up should be a post on planning.
What is on your short list of common problems related to some fundamental aspect of Scrum?
February 15, 2011
Scrum Fundamental: Measures of Progress
In my user stories blog post last week I claimed that problems on Scrum teams are often due to lack of knowledge about a Scrum fundamental. Today I’ll tackle the next item in my short-list of common problem areas:
Requirements and Design
One way, the traditional way, to try to build trust and understanding between a development team and the business or client is to spend a lot of time on designs, analysis, and wirefames. The problem is that it’s difficult to predict the future with much accuracy. You will likely miss details and misunderstand how the app will be used in practice. Requirements and priorities will change.
The agile prescription, therefore, is to not spend much time figuring out details for some story that you may never implement or that may change drastically in the ensuing months. Understand the stories at a high level. Get into development and begin delivering working software as soon as possible. Get feedback sooner and begin reaping the benefits of the software sooner.
Defer any decision and any work that can be deferred. You’ll be smarter next month, you’ll understand the system and the requirements better. Let the design speak to you, refactoring as you go.
This would be a good place to say something about lean and systems thinking and Pillar Technology’s “Business value over working software” appendage to the Agile Manifesto and about not building software when it would be better to redesign the system, without IT, then automate what makes sense. But that’s another whole post.
One good thing about working software is that you can have demos.
Demos
Favor demos over status reports. After completing each small story, demo it at least internally. Get to where you can have frequent (weekly or bi-weekly) demos to your clients/users. That early feedback is very important. This also holds staff accountable for quality, for “keep it working”, and for getting to done.
The demo isn’t for the Product Owner. Your Product Owner should have been involved with the team while the story was being implemented. Your Product Owner should have seen the story before the demo. There was an interesting discussion on the Agilistas LinkedIn group about who should do the demo, and why.
Keep it Working
Employ the “keep it working” principle. Build a usable system early on and keep it working continuously. The source in the version control system must always be usable. Set up an automated build/test process using a tool like CruiseControl, Cruise, or Hudson. Have it inform everyone when the build breaks. You should have a demoable product at all times. At the end of each iteration you should have a shippable product.
This requires automated testing. Pick a level with which to start coding test cases. Most often this is at the lowest level, unit tests. I recommend the xUnit framework or RSpec, but there are other good choices. [Hmmm. I feel compelled to say something about cucumber or BDD, but I intend this to be a fundamentals post. BDD ought to be fundamental, but it isn't as fundamental as this other stuff, particularly if I'm talking about Scrum. Admittedly, this post has left Scrum and is off in generic agile-land. But I digress.]
Sometimes, however, your methods are too large and have too many dependencies to be tested well at this level without first doing much refactoring. In those cases, automate your tests at a higher layer, then refactor and employ unit testing as you go. I’ve used Selenium and Rational Functional Tester for UI-based testing, but there are other choices out there. Working Effectively With Legacy Code by Michael Feathers comes highly recommended.
If you do a good job here, you’ll reduce the amount of manual testing you have to do. You can limit that to usability, break-the-box, and exploratory testing rather than regression testing.
Just a short word about testers. QA professionals think differently and approach testing in ways that developers do not. I like getting QA involved with the developers, pairing. I like getting development involved with anything that QA is taking the lead on automating. And I really like getting QA involved with the Product Owner to help define good stories and good acceptance criteria.
Parting Note
I almost abandoned this series of posts. There’s really nothing new here. I’ve said nothing better than it has been said before. I’ve just said it differently. Sometimes ‘different’ resonates with someone who hadn’t understood the way it was put to them before. So, I’ll press on with these posts. Unless I change my mind.
- measures of progress,
- delivering value,
- demos,
- getting feedback,
- keeping it working,
- continuous integration,
- and testing.
Requirements and Design
One way, the traditional way, to try to build trust and understanding between a development team and the business or client is to spend a lot of time on designs, analysis, and wirefames. The problem is that it’s difficult to predict the future with much accuracy. You will likely miss details and misunderstand how the app will be used in practice. Requirements and priorities will change.
The agile prescription, therefore, is to not spend much time figuring out details for some story that you may never implement or that may change drastically in the ensuing months. Understand the stories at a high level. Get into development and begin delivering working software as soon as possible. Get feedback sooner and begin reaping the benefits of the software sooner.
Defer any decision and any work that can be deferred. You’ll be smarter next month, you’ll understand the system and the requirements better. Let the design speak to you, refactoring as you go.
This would be a good place to say something about lean and systems thinking and Pillar Technology’s “Business value over working software” appendage to the Agile Manifesto and about not building software when it would be better to redesign the system, without IT, then automate what makes sense. But that’s another whole post.
One good thing about working software is that you can have demos.
Demos
Favor demos over status reports. After completing each small story, demo it at least internally. Get to where you can have frequent (weekly or bi-weekly) demos to your clients/users. That early feedback is very important. This also holds staff accountable for quality, for “keep it working”, and for getting to done.
The demo isn’t for the Product Owner. Your Product Owner should have been involved with the team while the story was being implemented. Your Product Owner should have seen the story before the demo. There was an interesting discussion on the Agilistas LinkedIn group about who should do the demo, and why.
Keep it Working
Employ the “keep it working” principle. Build a usable system early on and keep it working continuously. The source in the version control system must always be usable. Set up an automated build/test process using a tool like CruiseControl, Cruise, or Hudson. Have it inform everyone when the build breaks. You should have a demoable product at all times. At the end of each iteration you should have a shippable product.
This requires automated testing. Pick a level with which to start coding test cases. Most often this is at the lowest level, unit tests. I recommend the xUnit framework or RSpec, but there are other good choices. [Hmmm. I feel compelled to say something about cucumber or BDD, but I intend this to be a fundamentals post. BDD ought to be fundamental, but it isn't as fundamental as this other stuff, particularly if I'm talking about Scrum. Admittedly, this post has left Scrum and is off in generic agile-land. But I digress.]
Sometimes, however, your methods are too large and have too many dependencies to be tested well at this level without first doing much refactoring. In those cases, automate your tests at a higher layer, then refactor and employ unit testing as you go. I’ve used Selenium and Rational Functional Tester for UI-based testing, but there are other choices out there. Working Effectively With Legacy Code by Michael Feathers comes highly recommended.
If you do a good job here, you’ll reduce the amount of manual testing you have to do. You can limit that to usability, break-the-box, and exploratory testing rather than regression testing.
Just a short word about testers. QA professionals think differently and approach testing in ways that developers do not. I like getting QA involved with the developers, pairing. I like getting development involved with anything that QA is taking the lead on automating. And I really like getting QA involved with the Product Owner to help define good stories and good acceptance criteria.
Parting Note
I almost abandoned this series of posts. There’s really nothing new here. I’ve said nothing better than it has been said before. I’ve just said it differently. Sometimes ‘different’ resonates with someone who hadn’t understood the way it was put to them before. So, I’ll press on with these posts. Unless I change my mind.
Subscribe to:
Posts (Atom)