New Team – First Retrospective October 20, 2009
Posted by mdenomy in Agile, Rally, Retrospectives.1 comment so far
Rally recently held a “success tour” event in Boston. I have been using Rally for about 18 months, but recently began using it on a team that is new to Agile, so I was interested in seeing if I could pick up anything that would help ease the transition. The event started with a roundtable of executives who have successfully used Rally, and a quote that hit home for me was from Jochen Krebs who said “every team needs to find its own unique path within the Scrum framework”. Joechen’s presentation at the Boston event can be found here (you have to hit the “older” button a few times to get to his presentation).
An interesting follow-up to Jochen’s presentation was given by Heather Kanser who pointed out the danger of teams “cherry-picking” the parts of Agile that they wanted. Their talks were complimentary as Jochen’s comment about teams finding their own path was “within the Scrum framework”.
I came from a team that has had good success using Rally and Agile in a particular way, and one of the challenges for me has been to tailor the approach for a new team. We’ve been introducing some new processes and adoption has been a challenge for both sides. We introduced some new processes about how we do releases and validation, and recently pushed out a new release of the software. It seemed like a good time for a retrospective. Of course, if I read my own posts, I would have remembered that the right time for the first retrospective may have been right when I first joined the team.
The comments for “what did we do well” were very encouraging. Collaboration, better testing, delivering what we promised, fixing architectural issues were all mentioned. I was particularly pleased that delivery of promised features and improved testing were included. These were areas that I pushed hard for and it was gratifying for the team to see the value. It is always nice too when you hear team members say “that can wait for the next release”. I think one of the hardest parts of initially adopting Agile is having faith that regular releases will provide an opportunity for more incremental improvements down the road. Delivering what you promised is more important than trying to add more features near the end of the development cycle.
There was some good discussion about what we could do better. This was one of those times where as I heard at the Rally event, the team needed to find its own flavor. I tried to stay back a bit from the technical aspects and work more to facilitate the discussion. It was very interesting to see how what we thought were the most important items to address evolved over the meeting. We have some actions and a follow-up meeting scheduled. Should be interesting.
Convincing Developers on the Value of Pair Programming July 1, 2009
Posted by mdenomy in Agile, Extreme Programming (XP), pair programming.add a comment
Something that often comes up when discussing the topic of pair programming is the notion of convincing management of its value. Am I paying twice as much to have two developers to work on a task instead of just one?
My experience with convincing management of the value of agile and XP methods has been if you deliver software on time and with few defects management will accept whatever practices get them those results.
The problem I often face and find much more challenging is how to convince other software developers of the value of pair programming. Getting comfortable with pair programming can be a challenge. The evolutionary nature of software development in an iterative, TDD environment means we don’t have all the answers up front. That can be an uncomfortable feeling. Nobody wants to look like they don’t have a clear vision of where the design is going or be uncertain about the best way to implement it. My advice is to get over it. The other person you are pairing with is in the same boat. When you switch seats and they are at the keyboard, they are going to be leaning on you to see the big picture and help guide the design.
Some people advocate code reviews and feel they can serve the same purpose as pairing. That is true in a sense, but one of the problems I have with code reviews is grasping the subtleties of the design and what trade-offs went into a particular design decision. With pairing you are intimately involved in the design, coding, and testing. You talked out the trade-offs as you went along. The tight feedback loop in pairing also reduces the likelihood of having to make a major refactoring that may come out of a code review. I am not opposed to code reviews, I just think pairing provides a better mechanism for good design and coding practices.
A lot of successful pair programming has to do with the two engineers developing a good working relationship and respecting one another. Talk through alternatives, try different implementations, write good tests, listen to one another, and learn from one another. My pair programming experiences have been some of the most gratifying development experiences in my career.
Getting Started with Rally October 25, 2008
Posted by mdenomy in Agile, Rally.add a comment
I have been using Agile techniques on a regular basis for about 3 years now. The team I work in has gone through some interesting evolutions with our iteration and release planning, and at the moment we are using Rally as our planning tool.
A little history first might be helpful in how we got here. Early in the project it was just 2-3 developers and we were all developing C# code, using Visual Studio Team System. Team System has a pretty good work item and defect tracking system. You can enter defects, tasks, provide time estimates, and have dependencies between tasks. Another really nice feature was that your check-ins could be linked to a task/defect, so to go back and see what changes were made in the code against the work item was pretty easy to do.
When the team was smaller this approach worked pretty well. Our iteration planning meeting involved going through the open defects and work items (tasks, essentially). Most of what had to be done was implicitly understood by the stakeholders, so priorities were typically pretty clear and mostly it came down to a scheduling exercise. Team System did not seem to have any good mechanism for defining user stories and linking them to tasks, but with a smaller group of stakeholders and developers we were able to get by without a lot of user stories. Was it a mistake to not put more effort into user stories? Maybe, but that was the world we lived in.
All this worked pretty well while the team was small, but as the team grew it became more unwieldy. There was no mechanism to graphically display the tasks and do any long term planning. It was just a big task list. You could sort it, but being able to lay it out graphically was not supported. For a time we used a manual process where major tasks were put into a Visio diagram and grouped into iterations. That allowed the team to see how functionality would be rolled out, but keeping it in sync with the work item system was a manual process and difficult and time consuming at best. There was also no automated way to see if we were overloaded.
As the size of the team grew both in terms of developers and other stakeholders, we needed to find another solution. We looked at several tools and decided to try out Rally. Rally’s Community edition is free for up to 10 developers. It also has some of the features that I found were missing in our previous process.
- Graphical- Easy to drag and drop stories into different iterations and see when new functionality will come online
- Supports resource loading, so we can see how our iteration and release plans measure up against available resources
- Hierarchical – Everything starts with a user story or a defect. Tasks are grouped under the user story or defect. It is also possible to have a hierarchy of user stories to group and plan related functionality.
- Supports releases and iterations, so I can plan when formal releases will be available and easily see what feature sets (user stories and defects) will be in them.
- Built in reporting tools for defects, and iteration burn down rate.
Like any tool it has a few warts, and I am sure I will get around to posting about them. But in the two months I have been using it I am pretty pleased.
Project Retrospective October 2, 2008
Posted by mdenomy in Agile, Extreme Programming (XP).2 comments
I held my first project retrospective this week. It was probably overdue, but there is no time like the present right?
I found Peter Steven’s blog and Boris Gloger’s paper on Heartbeat Retrospectives helpful in setting the format. I decided to cover the following topics in our retrospective
- What did we do well?
- What can we improve on?
- Who has ownership of the things that can be improved?
- What are the priorities?
We used sticky notes and a white board. You need to be succinct to state your point on a sticky note. Plus once they go up on the whiteboard they tend to lose ownership and they become the team’s ideas. There were only a few times when we had to ask who wrote something and that was only to clarify an idea. The group ownership of ideas keeps things flowing and prevents the meeting from being driven by one or two strong personalities.
Starting with “what went well” set the tone that the meeting is going to be positive and constructive. At other companies I have been at these type of meetings often turned into a finger pointing exercise and went downhill rapidly. Our team has a lot to be proud of, and it was great to reflect on the things we did well. And if it ain’t broke…..
The things we thought we did well broke down into 3 catgories: Team, Process, and Technology. I am not sure if that categorization was planned or an impromptu decision. Grouping them into categories didn’t really serve any purpose other than it allowed us to acknowledge each point as we decided where it belonged.
Like any project there are things that we can do better. We purposely did not put any limits on what people thought we could do better. Once we put everything up on the board we broke it down into two groups: Team and Organization. Team means we can do it within the framework of our own team structure. Organization meant we had to bring others (HR, management, etc) into the mix to help address the problem.
Once we had things broken down into 2 categories, it was time to prioritize the lists. There are a couple of different schemes you can use here. Seeing the same issue raised by multiple people may indicate something that is important. Ultimately we decided to do a simple voting scheme where everyone got one vote, and that seemed to work pretty well. Next time we may try giving everyone three votes, but that’s for next time. We have a small team, so there were only a few items in each category that got votes, but even that tells you something, and we were able to prioritize those items. The reality is you can’t fix everything, so you focus on what is most important.
Probably the most important part of a retrospective is that you take action on the high priority things to improve. I am anxious to seize the momentum and teamwork of the meeting. That is the challenge for me and the team in the very near future.
Energized Work – Part II October 2, 2008
Posted by mdenomy in Agile.add a comment
To paraphrase one of my favorite quotes from The Mythical Man Month
How does someone go from blogging about Energized Work to being too busy to blog for 6 months.
One day at a time.
Weekend Reading March 27, 2008
Posted by mdenomy in Agile, Extreme Programming (XP).add a comment
I went away for a relaxing weekend, far from cell phone reception and internet access. Given my recent post about not being able to turn it off at the end of the day, maybe it is slightly ironic that I packed two books: The Art of Agile Development and The Art of War.
The Art of War is one of those books I like to pick up from time to time. I am not a fan of comparing war to sports or work, there is no comparison. The book is a good read though for understanding strategy, how to utilize resources, and human interactions. Many of the concepts are applicable to daily life.
I found an interesting passage in The Art of War that could be applied to the concept of Energized Work.
In War, Victory should be swift If victory is slow, Men tire, morale sags Sieges exhaust strength; Protracted campaigns Strain the public treasury. If men are tired, Morale low, Strength exhausted, Treasure Spent; Then the feudal lords Will exploit the disarray And attack. This even the wisest Will be powerless To mend.
Energized Work and Personal Responsibility March 27, 2008
Posted by mdenomy in Agile, Extreme Programming (XP).3 comments
Logically, I believe in the concepts behind what the XP community refers to as Energized Work. Software engineering is a complex activity and it requires you to be fully engaged and focused. That is hard to do if you are working long hours. The problem I have with it is that over 20+ years of working as a software engineer, I have conditioned myself to work to the limits.
I was talking with another developer about this recently and I said that it really takes buy-in from management to make Energized Work possible. He turned it around and put the burden back on me. His thinking was it only worked if I made the decision to follow the principles and it would never work if I waited for someone else to make it happen.
That meant I had to make the decision to leave work at a regular time. That I had to make the decision to spend time with my family instead of sneaking off to do work. This developer and I have worked together in the past and he knows my work habits pretty well. His analysis stopped me in my tracks.
Bad habits are hard to break. One of mine is not being able to turn it off at the end of the day. I have to put the blame for that squarely on me. I have no problem saying to another developer “Go home, you’ll get it in the morning”. I need to remember to apply that advice to myself from time to time.
Agile Haiku March 19, 2008
Posted by mdenomy in Agile.1 comment so far
Inspired by James Shore’s recent Energized Work haiku (and feeling temporarily brainlocked) I decided to tap my inner muse
Commented out code! Detritus of method's past Time to refactor
I know…..don’t give up the day job. And give me a break, I know refactoring is a lot more than removing commented out code, but there is only so much you can say in 5-7-5 syllables.
Plus, I really wanted to work in detritus. Not a word you get to use everyday.
Pair Programming Follow-Up February 6, 2008
Posted by mdenomy in Agile, Extreme Programming (XP), pair programming.add a comment
In my last post I described some of my early impressions on my first pair programming experience. Still no complaints, although a few additional observations.
I am surprised at the end of the day to find that I am a little mentally drained and I think that is a good thing. The effort that we are putting in is sustainable, but it is also very focused. There is little down time since at any given moment at least one of us is “on” and good progress is being made. Even when we are at a point where we are stuck the ideas are still flowing and we are both mentally engaged in the process.
Given the focus that we both have on the task, I find it beneficial to take breaks from time to time to check email, grab coffee, and even read a few blog posts. It would be a tough pace to maintain continuously and I think the occasional 5-minute break keeps both of us fresh.
We are doing a good job of share time at the keyboard, and I see a real difference in the approach I take depending on whether I am at the keyboard or not. When I am at the keyboard my focus is on the details of programming: variable names, style, and yes…just being able to type with someone looking over my shoulder. When I am not at the keyboard I seem to see the big picture better: are we repeating code, what is the complexity like, is this code easily testable.
I just started reading James Shore’s The Art of Agile Development and I hope to learn more about the mechanics of pair programming and tips/techniques to be more successful at it. Mike and I are pairing well together (I think), but I am also looking forward to pairing with someone else on our next iteration , getting a better understanding of how they work and how we can work together.
Pair Programming February 1, 2008
Posted by mdenomy in Agile, MbUnit, NUnint, pair programming.add a comment
I’ve been doing some pair programming this week and have found the experience to be extremely productive and informative. I am pairing with a guy named Mike, who is someone I have worked with in the past and really enjoying working with. We are in the midst of a fairly significant refactoring effort for a particular component.
Although Mike and I often bounce ideas off each other when we are working individually, I think the quality and flow of ideas is significantly better now that we are pairing. That only makes sense I guess. Even if it is code that you are familiar with, when someone asks you a question while you are working on something else it is difficult to grasp the subtleties of the problem. During this pairing effort we are both intimately familiar with the underlying problems and can quickly comment on strengths and weaknesses of a particular approach. The design is really coming along well and we have been able to address issues regarding complexity, IOC, and enhanced testing.
Speaking of testing, this component has a good suite of tests and that is a real blessing when you are refactoring. I feel a lot more confident after a significant change to see “All tests passed”. I have been using NUnit/MbUnit for about 3 years now and I am trying to remember what programming was like before I had these tools. We are trying to work incrementally and each time we get to a stable point we are checking in the changes.
I have to admit that at times pair programming was tough to get used to. On the first day I found myself saying things like “if you want to go work on XYZ I can run with this for a bit and we can get back together later”. Usually this would happen when we hit a snag and I needed time to think though the problem. I was uncomfortable not writing code in front of someone else, even though when I am working alone I recognize this non-coding time as part of moving forward. Something about not having an immediate answer in front of someone else made me feel very uncomfortable.
There have been a lot of positives to the effort, and so far no negatives. I am sure that some of that is due to that fact that Mike and I work well together and have similar beliefs about software development. That is not to say we have always been in agreement, and indeed have had some spirited discussions. We have come up with a design that is stronger than either of us would have come up with individually. We are pushing each other to develop and maintain good tests, and also to push back with the occasional YAGNI criticism. We are also sharing productivity tips, comments about programming styles, ideas about new tools, blog posts, etc, etc.
One unexpected benefit of this pair programming effort has been that people have been less willing to interrupt us when we are working together. Maybe it is seeing two people working productively and enthusiastically that makes people hesitate before interrupting. There have been interruptions but they are fewer and we have also been more willing to say “let me finish up what we are doing here and I can swing by in 30 minutes”.
I am really looking forward to doing more of this. Based on the quality of the code and tests and our overall productivity I would feel confident defending the use of two developers for one task to management. I would also like to try pairing up with other members of the team. I am sure we will go through some of the same awkward startup moments but I think there is a lot to be learned and shared.