In lean software development, task switching is considered as a significant example of waste. It should be avoided as much as possible, so that a minimum amount of time is lost or wasted by people having to refocus on new tasks.
In smaller organizations you often see developers having to switch from development to maintenance tasks, because the organization isn’t large enough to support separate teams for new product development and activities to support the already released code. In these organizations, developers get frustrated because they are often disturbed by customers (or their representatives) in order to address an issue or question concerning the released code. This leads to:
- Development of value-adding features is delayed
- High risk of introducing errors or bugs
- Reduced team morale
- Unhappy customers
Here are some proven ways to minimize the disruptions caused by the need to support code:
- Depending on the size of the team, have some team members rotate off the team every week, month or iteration to handle all maintenance during the duration of this cycle.
- Set aside a couple of hours each morning where the team collectively handles all issues related to the production code. Focus on new development for the remainder of the day.
- Triage support requests as aggressive as possible so that only the real urgent work is handled immediately. The remaining non-urgent maintenance requests can be handled later, during a period of time set aside for this kind of requests.
- Keep all users on a single code base and release new versions as often as possible, preferably after each iteration. This will result in at least some of the non-urgent support requests being solved by a new version of the production code.
Combine multiple items for a maximum effect. For example, it’s always a good practice to triage support requests, regardless of whether you’re in the above situation of mixed responsibilities or not.
Additionally there are some more generic practices that will reduce the number of maintenance requests:
- Prevent defects as much as possible
- Find defects as early as possible in the process
- Keep defects from reoccuring
Of course, all of the above can be achieved by implementing TDD, automated testing, unit tests and properly defined acceptance tests, in combination with short iterations with well-defined definitions of done.
This is an example of how one type of waste (defects) can reduce another one (task switching).