четверг, 3 апреля 2014 г.

Как разбивать задачи и увеличить эффективность ваших процессов?

О чем статья и зачем это вам?

Все всегда разбивают задачи на более мелкие чтобы их было удобнее анализировать/разрабатывать/тестировать. Всегда были Epic задачи в беклоге, которые мы били на более мелкие User stories. Но именно формат User stories и потребность в том, чтобы любая задача давала после своей реализации бизнес-ценность Заказчику, останавливает многих от разбиения на мелкие задачи. То есть мы не видим возможности разбить задачу кроме как разделить ее на технические задачи, и решаем остановиться.

Хочу описать свой подход к разбиванию задач, которые я использую в рамках Kanban-системы (почитать можно здесь), и который предлагаю командам, которых коучу. Если вы сомневаетесь чем это может быть полезно, но в конце статьи я описал возможные результаты от внедрения подхода.  

В чем проблема больших задач?

Что дают большие задачи?
  1. Лучше видна основная проблема, которую нужно решить. Команда видит не кусок проблемы, а всю ее, что дает лучший vision и дает принимать решения лучше. (Это можно решить другими способами).
  2. Что-то еще?
Какие проблемы больших задач?
  1. Они увеличивают вариативность процессов. Меньше предсказуемость в успешном закрытии спринтов, меньше вероятность в успеть закрыть такие задачи в релиз.
  2. Они увеличивают нагрузку на команду. Разработчики "пилят" большую задачу 3 недели, тестировщики - курят. Затем тестировщики пилят, а разработка ждет.
  3. Они увеличивают очереди и время цикла. Задача 3 недели в разработке. За это время никакие "приоритетные" задачи не будут закрыты.
  4. Они уменьшают эффективность обратной связи и увеличивают риски. Только через 2 недели мы узнаем что не поняли проблему Заказчика.
  5. Они снижают качество. Мы внедряем 2-х недельный функционал разом и получаем большое количество ошибок. Они стоят "дороже" по сравнению с тем, что мы бы могли внедрять функционал раз в 2 дня и решать проблемы постепенно. 
  6. Наверное есть еще много производных проблем от тех, что описаны выше.  
На самом деле редко у кого есть большие задачи в работе. Команда легко бьет любую задачу на более мелкие, но они это делают в рамках своего понимания. И понимание у них техническое. В результате у таких мелких задач огромная связность, и проблема никуда не уходит.
  1. Сделали за 2 дня изменение в Модели в БД. РО смотреть нечего.
  2. Сделали за 1 день новые формы, которые еще не работают. РО это не интересно. 
  3. Сделали за 3 дня логику, которая еще не полная и потому не позволяет проверить весь процесс. "Эй, РО. Пока не смотри, скоро все будет".
  4. Доделали за 3 дня логику. Но нужен еще рефакторинг.
  5. Сделали за 1 день рефакторинг. "РО, все готово".
  6. В результате через 2 недели - "Но я же хотел чтобы инфляция применялась в рамках расчетов", "Мне не нужен выбор проектов, мне нужно выбрать сразу весь портфель проектов", "Расчет эффективности проектов не правильный. Зачем вы учитываете инвестиции для расчета социальной эффективности"
  7. ОК, еще +1 неделя чтобы все доделать. 

Делали 4 небольшие задачи, но проверить их смогли лишь в самом конце после закрытия последней.
Без понимания бизнес-части задач разбить большую задачу на мелкие довольно сложно.
  

Почему здесь может помочь Story Map?

Ранее я использовал предложение Dan Rawsthorne, которое услышал на AgileDays'12. В любой задаче можно определить backbone (основной костяк, который необходим для закрытия задачи), beef-up (бесконечные улучшения по задаче), alters (реализация альтернативных сценариев, fail cases), UI (так же бесконечные улучшения по UI/UX). Все фичи мы нарезали на эти части (в голове) и формировали по этому пониманию User stories. Но так как это разрезание было в голове у аналитика, то часто в процессе разработки были различные споры, что входит в scope задачи, и что нет.



Так же есть - The hamburger method. Пару раз мы к нему обращались, резали задачи как предлагается, но видимо из-за того что это было мало формализовано и большей частью выполнялось в голове, так же плохо сработало для нас.

В результате я вернулся к Story map.

Story map в исходном понимании используется для формирования и ведения карты функционала по продукту. Большая и подробная карта функций/историй. Я нашел эту технику мало полезной пару лет назад. Идея чтобы собрать всех членов команды и за 1-2 дня сформировать 2 сотни историй, которые сформирует исходный беклог продукта, кажется мне не продуктивной. Уже через неделю мы узнаем о продукте гораздо больше и половину историй нужно будет выкинуть, иначе мы их сделаем и это будет никому не нужно.

Потому для ведения scope по продукту я используют Impact mapping, и функционал представляется в виде дерева. В рамках Impact map я нахожу процесс стратегического планирования более эффективным.

Но я вернулся к Story map чтобы разбивать крупные фичи, которые являются атомарными в Impact map. "Стресс-тестирование портфеля проектов", "Оценка эффективности портфеля проектов". Для Impact map это атомарные фичи, Стресс-тестирование - это отдельная фича сценарного анализа, а оценка эффективности - это часть процесса мониторинга. Но в части разработки это будет стоить нам 2-3 недели на каждую из этих задач, потому давайте бить. 

Как я разбиваю задачи?

Как инструмент я использую "Google Sheets".



Сверху слева-направо разбивают задачу на этапы/шаги/части в зависимости от типа задачи.
Сверху-вниз описываю инкремент по задачам, которые можно сделать в рамках этого шага, отсортированные по их ценности/реализуемости. Чаще всего первый шаг - это "мы ничего не делаем".
  1. Нужно позволять делать ввод данных - не делаем ввод данных. 
  2. Нужно делать расчет - не делаем расчет. 
  3. Нужно визуализировать результаты - показываем статику. 
В результате есть матрица из N x M мелких задач, которые можно сделать независимо.

Так как задачи слишком много и они слишком мелкие, то нужно сделать их объединение в рамках одной задачи Вашего беклога. Для этого можно использовать следующую логику:
  1. Задачи по самым рисковым шагам/этапам решаем первыми.
  2. Группируем задачи так, чтобы были все шаги по горизонтали, и можно было максимально быстро показать результат Бизнесу.
  3. Группируем задачи исходя из их сложности. Сколько задач можно объединить чтобы получилась задача на 2-3 дня. 
Далее цветами можно сгруппировать задачи в рамках user stories, и определиться с их приоритетом в беклоге.  



Для разбиения Story map по столбцам я использую следующие подходы:
  1. У нас есть use case на процесс, который имеет ряд шагов. Столбец == шаг процесса.
  2. У нас есть большой функционал, который независим между собой. Столбец == независимая часть задачи.

Какие есть проблемы/примеры их решения?

Какие могут быть проблемы с построением Story Map или разбиением задач?

Интеграция 2-х систем

Есть мнение что статус интеграции систем бинарен - он или есть или нет. В результате это занимает 2 месяца и проходит довольно мучительно. А именно:
  1. Разрабатываем API для интеграции и согласуем его для обоих систем. Неделя.
  2. Реализуем это API для обоих систем. Так главная наша надежда/удача: "мы делаем это параллельно и независимо, потому выйдет дешевле". 1 месяц
  3. Начинаем тестировать интеграцию и вылазят проблемы. В результате мы много раз переделаем весь API и переписываем обе реализации. Еще +1 месяц.
Как это можно сделать:
  1. Формируем Story Map по методам, которые входят в API. 
  2. Реализуем 1 метод, который передает 1 параметр, в обеих системах и начинаем тестировать. 1 день.
  3. Находим все проблемы с сетевой связностью, со различных стандартами SOAP в Java и С++ и тп. Решаем их. Пишем интеграционные тесты, чтобы можно было автоматически тестировать интеграции 100 раз в день. Пишем моки сервисов для каждой системы, чтобы можно было тестировать интеграцию локально. 1 день
  4. Реализуем 1 метод, которые передаем все параметры, в обеих системах и начинаем тестировать. 2 дня.
  5. Находим проблемы с различным представлением строк/многомерных массивов/последовательностей в реализациях SOAP для Java и С++. Решаем их и договариваемся что все дальнейшее API будет это учитывать. 1 день.
  6. Итеративно наращиваем API с постоянным тестированием интеграции. 1 месяц
  7. Остальное время мы съэкономили.        

Модернизация

У нас есть 7 услуг, которые мы оказываем. Нужно внести изменение, которое затронет все оказываемые услуги, причем пока это изменение не реализовано, то все услуги не работают. Это одна большая задача, которая так же имеет бинарный статус - или все 7 услуг изменены или все 7 услуг работают по старому.

Как это можно сделать:
  1. "Сделать изменение для 7 услуг" и "сделать изменение для 7 услуг так чтобы все услуги всегда работали" - это 2 разные задачи и вторая задача сильно дороже. 
  2. Делаем Story map по шагам услуги
  3. Делаем изменение для самых рисковых шагов для 1 услуги. Ломаем все остальные услуги.
  4. Итеративно дорабатываем 1 услугу и показываем Бизнесу. Получаем OK.
  5. Дорабатываем остальные услуг по аналогии.     

Какие результаты вы можете получить?

Какие результаты от разбивания задач на более мелкие, разработка по которым будет стоить 2-3 дня? Не скажу, что все именно из-за мелких задач, но это сильно влияет:

  1. Это СИЛЬНО сокращает время цикла по задачам, как я писал для Kanban-системы. Далее идут уже следствия сокрашения Cycle time.
  2. Это уменьшает вариативность процесса. То есть более предсказуемое и постоянное кол-во задач, закрываемых за релиз (для Kanban), и более постоянный velocity в Scrum.
  3. За счет того, что у вас более предсказуемый и постоянный поток, вы сможете уменьшить WIP и размер очередей в процессе.
  4. Это снизит переработки (когда или очень много работы или ее мало) сотрудников и повысит их загрузку.
  5. Меньше Cycle time и выше Work time -> увеличение эффективности команды
  6. Это повысит качество результатов.
  7. Это сильно ускорит обратную связь от Бизнеса, в результате снизит ваши риски и увеличит доверие Бизнеса.
Готовы попробовать?