Managing Multi-Tasking in a Small Group

A reader sent me email with this question: “We have a group of four people (3 developers and a tester). We work on 4 products, releasing one about once a month (each product is released once a quarter). The developers are devoted to one product when they're developing, but have to fix problems immediately if someone finds a problem and reports it. How do I manage the multi-tasking?”

I've asked the reader a few questions. I still don't know everything about the environment, but here's what I suspect is happening, based on my questions:

Each product has technical debt, from insufficient testing (all the way through development) from previous releases.

There are a ton of ways to deal with insufficient testing. I would first start with peer review of fixes. If someone is interrupted from new development to deal with an already-existing, but newly discovered problem, have the developer ask a peer to review the fix. Part of the peer review would be to create automated tests for this fix. (Yes, I realize this now interrupts two people. I find that if there's a Big Problem in one product, there are frequently other related Big Problems in the related products.)

After peer review and automated tests, I would (gently) ask the tester how the tester missed this problem. This is for root cause analysis, not to assign blame. The tester doesn't read or write code, so the tester can only perform black box testing. Black box testing, by its very nature, is unlikely to find most of the gotcha's in a product. After a short root cause analysis, I would add some form of automated test development activity to each project.

I can see some heads shaking from here. “If we take time to add tests, we can't add as many features.” You're absolutely right. But here's the problem. You're not adding the features now. You're adding broken almost-features. That's not helping the customers. The customers deserve to have features that work.

So, to deal with multi-tasking from defects in a small group, I recommend changing the way you work. If you keep the same lifecycle you have now, add the practice of peer review of all code and all fixes. Add in automated testing for all defects that have to be fixed from the field. Change the testing, because it's not exposing the Big Problems before you release. If you choose to change lifecycles, I suggest an agile lifecycle with test-driven development.

Whatever you do, don't assume that wishing away the problem will make it go away. Some practices need to change. Maybe not the ones I've suggested, but some of them do. The change will take time, depending on how much technical debt you have. Otherwise, you're left with the quality pledge and no muscle behind it.

2 Replies to “Managing Multi-Tasking in a Small Group”

  1. Seconded on the automated testing.
    Depending on the scope of the products, I’d go farther:
    – coders should produce unit tests for all code they write, and those unit tests should be added to the regression suite
    – testers should produce tests that reproduce problems
    Given the size of the team and the length of the schedules, I’d suggest reading up on extreme programming. I don’t think all the XP practices would necessarily be appropriate, but some of the tools for handling change management, scoping, and testing may come in handy.

  2. Johanna is absolutely correct in her suggestions on fixing the root causes of the problems this organization is experiencing. I would make a couple of suggestions on dealing with the symptoms. We should remember that the problems are never going to disappear completely, no matter how good we are.
    First, the key phrase is “have to fix problems immediately.” You don’t HAVE TO do this. This is a management decision, just as the decision to ship the product with latent defects is a management decision. Most bug fixes can be deferred, and put on the list for consideration for inclusion with the next release of the product.
    Second, based on historical data, estimate how much time is consumed in bug fixes during each three month release cycle and subtract that from the time available to work on the release. You can assign one developer to handle all “critical” bug fixes during that cycle, on a rotating basis, thereby isolating the other two developers to work exclusively on the release (except for the peer review that Johanna suggests). If more than one developer on a part time basis is required to deal with problem fixes, you have a far more serious problem.
    Incidentally, why haven’t you been doing peer reviews all along?

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.