And sometimes the problem is human nature. It’s our own difficulty with breaking out of an existing perspective, breaking old habits and old ways of looking at things. These are the most difficult problems to solve, but solving them provides the biggest payback.

Example: Scrum Iteration Planning

To illustrate this issue, let’s say you’re using the RTC Scrum process template. You think that it takes too long to load an iteration plan. You perceive a performance problem. Fair enough.

So we look at your plan and see that you’re loading many hundreds of work items when you display your plan. In other words, you have planned to do hundreds of things in the course of a single Scrum iteration. And these are higher-level items, Epics and Stories, not just tasks and bugs. The problem is, a Scrum iteration shouldn’t have that many planed items. You should generally have dozens of plan items, not hundreds. What gives?

It turns out that you have nested iterations (which is fine), and your iteration plan is focused on the highest level iteration (which is not fine). We find that the timeframe of this high-level iteration lasts for more than a year.

Scrum iterations are designed to be short and provide a deliverable at the end. Four to eight weeks is common. If you have longer iterations, it’s harder to do the planning, estimating, and managing that makes Scrum so useful. Instead of looking at all the planned items in your project, you want to look at just those that are planned for the current (or possibly the next) short iteration. Scrum focuses the team on the “now”, partly because Scrum allows for a lot of change to a project in the future. In fact, Scrum embraces and encourages change, so we can’t know, in a detailed way, what’s going to happen past the next iteration.

This means that you are losing a lot of the value of Scrum if you are trying to see the entire project in one iteration plan. And, if you only look at the plan items for a fine-grained iteration, you’re not going to have performance issues because you’re not loading hundreds of plan items.

It also means that in this example, RTC looks like it has a performance problem, but what’s really happening is that the Scrum template is being used in a way it’s not designed for. You’re trying to pound a square peg into a round hole.

Right Process, Wrong Perspective. Or, Right Perspective, Wrong Process.

So now you’re saying “OK smart guy, but I really want to see the entire scope of my project. I’m used to looking at Gantt charts and critical paths in Microsoft Project. It’s how I’m successful at delivering my software!”

This is the crux of the problem. Scrum (or any process) is designed to deliver value in a certain context. For Scrum that context is small teams that can deliver in short cycles and who embrace plenty of changes as you go. But maybe you’re working on a project that can’t do that. Perhaps you have a large project that must try to define all requirements up-front because of contractual constraints. Or you’re required to report progress against a specific total estimate so you can bill the customer. Or your organization is used to working in a way that’s not the least bit Scrummy, and old habits die hard.

We can argue all day about what’s “good” and “bad” about the process you’re using, but that’s not the point here. It may be that the nature of your project prevents you from adopting all of Scrum (or whatever process you’re trying to adopt). A better way to say that is that the nature of your project should define the type of process you adopt. Maybe you actually do need to look at all plan items across the entire project at all times.

That’s OK, I’m not judging. But let’s not fool ourselves into thinking that Scrum will solve our problems because Scrum is all good, hail mighty Scrum. Let’s use RTC to model the process that we can do and must do, the process that we’re contractually obligated to do or that has proven to be effective in our organization for our particular set of circumstances. Or, use RTC to model the process that we need to do, that will solve some problem in the way we develop our software.

The real problem in the scenario described above is that people want to do Scrum “because it’s Agile”. People want to get that Agile mojo and make their projects less painful and more predictable. But first their project needs to be amenable to Scrum practices, and if so they need to change their perspective and the old, ingrained, unconscious habits they’ve developed.

It’s very, VERY hard to change habits and perspectives. You have to have a clear target and keep that in front of you while your body and mind try to yank you back to your habituated way of doing things. The good news is that a tool like RTC can help you by enforcing new process elements that you want to adopt.

But if you try to use the Scrum template (for example) because you want to adopt Scrum, but you want to view reports and plans like you did in your old Waterfall process, you’re going to be frustrated. You’ll be banging a square peg into a round hole. There’s nothing wrong with square pegs or round holes, but we need to pick the right peg for the right hole.

This means we may choose the Traditional process template in RTC instead of Scrum. Or we choose the Simple process template and add Scrum elements to it, along with some custom stuff we like. Or we choose the Scrum template and add some elements from the Traditional template to it.

We do what we need to do to make sure we:

• Do things that make us successful in delivering software IN OUR PARTICULAR ORGANIZATION.
• Consciously change what doesn’t work, and enforce what does work.
• Continuously review our process and incorporate new best practices. In other words, make a habit of creating new good habits.

And when we bump up against a problem in RTC, we want to ask ourselves if:

• Something is wrong with RTC
• We lack some knowledge we need to acquire
• We’re using the chosen process in the way it was meant to be used

I guess the moral of the story is that there’s no such thing as a free lunch. If you want the advantages of Process X, you need to understand how Process X delivers the value that it does. Then embrace that behavior by forming new organizational habits.

In my experience, this is the most difficult part of adopting a process. Teams and organizations who get good at this are much more successful than those that don’t

Ralph is from Germany and Jorge is from Spain, so if your native language is English, German or Spanish we can promise to answer your questions in your mother tongue! Go to the Sessions page and search for “ruehlin” to see the abstract.

Many of us from the Jumpstart Team are going to innovate. Check out the team bios and see if you want to visit any of their presentations as well.

If you’d like to meet with me, please email me and we’ll try to get something set up during the conference. I’m imagining a group process enactment discussion over Mai Tais at the pool…

The Jazz Jumpstart team is lucky enough to have Grant Covell join us. He’s a performance guru, and has done a lot of work calculating and validating performance on CLM. 

I’ve added his blog, RATL Perf Land, to the blog roll. If you’re interested in performance issues, you should check out is work.

My colleague Ralph Schoon, Germany’s best export, described a way to customize a work item attribute that shows you the current state and available states in your work item. It’s based on original work done by Kristina Florea.¹

Here’s what you need to know about this: IT’S TOTALLY COOL! This should be a built-in feature of RTC. But if you do a little work item customization (and create a simple graphic of your WI states), you can have this extremely cool feature as well.

Here’s a new, unsaved work item. You can see where you are in the flow, the states that are available, and how to get to the other states. The Workflow Information field shows a graphic of all the states, with the current state in green. The Workflow Information field is of type “wiki”.

You can see that the work item is “New”, and it will be “Proposed” after we save it.

After we save the work item, the graphic changes to the following:

We are now in the Proposed state (which is also shown in the field at the top of the window). We can see in green that there is just one possible thing for us to do in this state: research the work item. We can also see that if we want to Reject the work item, we must first Research it.

This makes it much easier to get the work item into the state you want it to be in. It also makes it clear what the entire workflow is, which makes understanding the purpose and direction of work items much easier.

Currently, you can only see the workflow for a work item type (not a specific work item instance), and that can only be viewed from the Process Configuration tab of the project description. Usually the only people who look at that (or know to look there) are the process engineer and the project lead.

Using Ralph’s technique, you can see the workflow for a specific work item (not just the general WI type), and you can see what the current state is in context. From a process perspective, this is a big shortcoming in RTC that Ralph has addressed.

You can do this yourself by using JavaScript to customize work items. Ralph provides easy-to-follow instructions in Lab 5 of the CLM Process Enactment Workshop. I recommend doing the whole workshop, or at least the work item customization labs. But if you want to jump right to the section that describes how to display the work item flow, it’s in section 5.6, Calculated Value to Visualize the State of the Technology Review.

You also might want to request that this feature be added to RTC so it’s easier to implement.

1. Ralph was incorrectly identified as the creator of this feature in the original article. The passage was corrected to show Kristina Florea as the creator.

Every discipline has best practices. These are the behaviors and skills that contribute the most to success. They aren’t objectives in themselves. You don’t “complete” a best practice and then you’re done. Best practices are perspectives and disciplines that you always apply almost every day to make you better at what you do.

To illustrate, I heard a story once about salespeople taking training classes at a conference. All the younger sales folks were going to the cool classes about new sales techniques, the latest psychology of sales, etc. But the more experienced salespeople were going to classes on how to negotiate better, how to close the sale, how to do a better job of networking, etc.

You might wonder why the more experienced people were going to those basic sales classes instead of classes about special circumstances or new trends in sales. The reason is because those basics – negotiating, advancing the sale to the next level, connecting with customers – are fundamental practices that contribute the most to being successful with sales. Negotiation and advancing the sale may be 50% or 80% of actually making a sale. Getting better in those areas, even if they’re areas you’re already good at, will give you more “bang for the buck” for your efforts.

Another example: When I was doing karate, the particular school I was in insisted that you memorize a bunch of tenants and purposes of that particular style. The very first one was “Practice basic techniques all the time”. And every class we did so.

Why practice the most basic blocks and kicks all the time after already practicing them for years? Because they focus on balance, on protecting your must vulnerable areas, on improving your core and speed. These are the things that not only give you the foundation to do dramatic (but not very effective) jump-spinning kicks. They also continue to make you better dealing with the kinds of attacks and defenses that you’re most likely to encounter. Block, block, kick, punch. Don’t worry about flying through the air, just avoid getting hit and disable your opponent. Or better yet, run away!

It’s the same for software development. There are fundamental practices that transcend technology and fads. If you get good at those areas you’ll significantly reduce your risk of failure, you’ll be much more likely to create a product that will solve someone’s problems, and you’ll create more robust and high-quality software. If you don’t focus on those best practices, you’re much more likely to fail to deliver a product on-time that solves someone’s problems.

I started to learn best practices by failing a lot. Like many people, I finally started to migrate to doing what seemed to work and avoiding what didn’t. In fact, after you work on some projects over the years, you can start to “smell failure”. That’s the visceral sense of dread you get when you see too many things happening that just aren’t right. When this happens, you’ve started to get a sense that best practices (even if dimly perceived) are not being performed. Run away!

Rational Software (later purchased by IBM) defined 6 specific best practices of software development and organized their products and solutions around them. That was GREAT! We could actually talk to customers about how to solve their problems and discuss where their shortcomings were. For almost 15 years I’ve used the thinking around those practices to help lots of people get better at delivering software.

These days, it feels to me like we have less understanding of what these best practices are in our industry. Teams do “agile” (whatever that means nowadays), or they repeat what their organization has done for many years, or they just make it up as they go along. While we’ve come a long way over the last 30 years, we’re still addressing the same kinds of problems. And we still need to address the same best practices to be successful.

One more thing about best practices in our industry: they give us a way to help measure the value we deliver. Measuring value can be hard. Is a programmer good because he writes three times as much code as someone else, or is the other person better because it’s hard to find bugs in her code? Is a tester good because she finds a lot of bugs, or is the other tester better because he identifies ways for developers to avoid writing bugs? Is an analyst good because he writes requirements that people can understand? Or is the other person better because she writes requirements that developers can design from?

The fact is, bad software can succeed with good marketing. Good software can fail in the marketplace even if the developers are delivering on their minimum SLOCs. Rewards and punishments for these kinds of results may have little to do with the skills of the practitioners and their contributions. It’s often hard to draw that line between what a practitioner does and the success of a specific product.

So instead of looking at how well a product does in the market as a way to reward practitioners, we want to encourage the behavior that’s most likely to make the product successful, and discourage behavior that won’t. If we identify best practices, we can focus on encouraging behavior that realizes those practices. It doesn’t guarantee success or assure failure will be avoided. But it does give use a way to perform that is more likely to make us successful. That’s what we should be measured by.

I thought I’d do a series of blogs on the best practices for software development as I see them. There aren’t very many practices, but they cover large areas. I would love to see the industry re-dedicate itself to best practices instead of embracing are dearly loved process philosophies. Software development processes should make us better at performing best practices, not be ends unto themselves.

Here are the best practices I’ll be covering in future posts. Stay tuned!

• Define the problem and a general solution. If you only do one thing right, do this.
• Manage requirements. At the least, manage the 20% of critical requirements.
• Test continuously. Like voting in Chicago, do it early and often.
• Deliver iteratively. Always get back to solid ground, aka stable software.
• Model the software. The people currently in the room with you are not the only people who need to understand what you’re doing.
• Define the architecture. No, really. Define the architecture!

Ralph once again makes it easy to understand things that are hard in Rational Team Concert. Another awesome addition to his technical oeuvre.

My colleague Ralph Schoon has posted an article on how to programmatically upload attachments to the appropriate work items when importing those work items from another system. 

This is very useful when migrating from another type of change management system to RTC, since attachments are not automatically copied over.

Here’s an excerpt:

600 people reached the top of Mt. Everest in 2012. This blog got about 8,700 views in 2012. If every person who reached the top of Mt. Everest viewed this blog, it would have taken 15 years to get that many views.

Click here to see the complete report.

So what do we do with this lighthearted week of the year? How about some fun enablement! This is the perfect time to settle in with a warm cup of cocoa (perhaps spiced with your favorite holiday pick-me-up) and run through some interesting labs that will make it seem like Santa put an extra frontal lobe under the tree for you.

We recently posted the latest version of the CLM 2012 Process Enactment Workshop (PEW) on Jazz.net. This one includes Lab 4, which dives deeper into work item customization. Now the PEW will teach you how to:

• Set up your workspace for Process Enactment
• Understand the Process Development Lifecycle using integrations between Rational Team Concert and Rational Method Composer
• Configure work items (basic changes to work items)
• Customize work items (advanced changes to work items)

We’ll soon post the fifth and final lab for this version of the PEW, which covers using JavaScript to create highly customized work items.

What could be better than learning something new by doing a workshop designed to help you customize developer tools? It’s better than watching A Christmas Story again.

Well, almost better.

Happy New Year!