Тактика внедрения 6. Плохое решение лучше никакого

Успешное внедрение ERP - это умение вовремя организовать принятие нужных решений. Именно отсутствие решения или задержка в принятии решения заказчиком или исполнителем является самым большим фактором риска в проекте. Проекты часто заканчиваются провалом не потому что у клиента кончились деньги или лопнуло терпение, и не потому что от вас ушел ключевой программист. Чаще всего проекты рушатся из-за нагромождения нерешенных вопросов, приводящего к невозможности продолжать работу.
Накопившиеся нерешенные вопросы быстро превращаются в огромные завалы. При попытке разгрести их вы обнаруживаете, что для решения одной проблемы нужно решить две других, что невозможно понять, с какого конца взяться, и какой вопрос самый важный и срочный.
Внедрение ERP - это пулемет, расстреливает вас вопросами и проблемами, требующими срочного решения. За время внедрения его участникам необходимо принять несколько тысяч решений! Часто они взаимосвязаны, и задержка с одним решением вызывает задержку десяти других, а те - еще сотни.
Что можно сделать для того, чтобы проект не завяз в непреодолимой паутине из непринятых решений? Нужно принимать их вовремя! И поскольку решения обычно нужно готовить, как можно больше подобных вопросов нужно предусмотреть заранее. Принятие решений начинается еще в ходе переговоров. Каждый последующий этап должен выявить как можно больше вопросов, требующих решения в ходе дальнейших работ, и принять все эти решения заранее.
Тем более, нельзя допускать системного возникновения множества ненужных решений, когда сам способ, которым вы управляете, заставляет вас, заказчика или разработчиков постоянно, раз за разом принимать решения по одному и тому же поводу. Например, если вы сдаете работы по листам учета рабочего времени, то заказчик вынужден принимать отдельное решение по каждой строчке документа. Или если вы подготовили техническое задание, охватывающее несколько подразделений заказчика, сразу несколько человек должны будут одновременно принять решение о его согласовании, и по чисто математическим причинам вероятность успешного решения в отведенное на это время будет ничтожной.
Не смотря на попытку предусмотреть все заранее, вам все равно придется принимать решения уже на ходу. Нельзя уклоняться от принятия решений, нельзя динамить! Каждый вопрос должен быть решен максимально быстро, в идеале - мгновенно. Самое лучшее решение в проекте внедрения - не самое лучшее, а самое быстрое.
К сожалению, решения в ходе проекта принимаете не только вы, но и заказчик. Не все участники проекта с его стороны одинаково замотивированы или склонны принимать решения быстро. Задача руководителя проекта – не допускать появления вопросов, требующий одновременного участия большого числа людей. Чем больше людей участвует в решении, тем дольше оно будет приниматься. Лучше приложить усилия к тому, чтобы один сложный коллективный вопрос распался на несколько индивидуальных.
Это относится не только к организационным проблемам, но и к техническим. Нельзя позволять неожиданно возникшим техническим сложностям сбивать темп проекта. "Времянка" - дешевое решение на время - это способ превратить долгую и сложную внеплановую разработку (отправляющую весь план работ в мусорное ведро и приводящую к новому циклу переговоров) в быструю внеплановую плюс длительную плановую когда-то потом.
Главная задача руководителя проекта - максимально быстрое принятие всех решений по проекту, превращение сложных решений, требующих долгого времени и большого числа участников в простые, принимаемые мгновенно. Опыт и тщательное планирование помогут предвидеть все моменты, где может потребоваться чье-то решение и сделать это заранее. Ежедневное общение со всеми участниками проекта позволит вовремя разглядеть зарождающееся решение и принять меры по его нейтрализации, до того, как оно превратилось в остановку работы.

Тактика внедрения 5. Нарезка задач и сквозной контрольный пример

Чем сложнее и объемнее задача, которую вы собираетесь решить в ходе проекта, тем труднее будет сдать ее заказчику. Объем, на котором это становится практически невозможно, не так уж и велик. При сдаче работы объемом более 100 часов у вас гарантированно будет по крайней мере одна проблема. Задачу объемом более 300 часов вообще невозможно сдать без критической потери времени, денег и нервных клеток. Какой-нибудь «этап» «классического» проекта объемом 500-600 часов вообще не сдается, там решения о приемке с оформлением проектных и финансовых документов и реальное выполнение работ находятся в двух параллельных вселенных, жители которых не даже знают о существовании друг друга.

Поэтому, если вы и впрямь настроены выполнить для заказчика работу таким образом, чтобы вы ее сдали, он ее принял и получил именно то, что хотел, необходимо разбить ее на как можно мелкие отдельные задачи. Сколь мелки должны быть эти задачи? Главный принцип звучит так: если участок разработки можно сдать отдельно, его надо сдавать отдельно. Все, что можно сдать отдельно, независимо от других доработок, должно оформляться, как отдельная задача, которая проходит отдельную сдачу-приемку.

Главному принципу противоречит необходимость проведения для каждой задачи определенных управленческих процедур: подготовки точной формулировки, согласования с заказчиком объемов и срока работы, подготовки контрольного примера, собственно сдачи-приемки. Полный жизненный цикл для задачи на один час – это через чур. Поэтому оптимальный объем для отдельной задачи находится в диапазоне от 20 до 80 часов, наиболее удобный объем составляет 40 часов.

Так как внедрение 1С:ERP, как правило, заключается в большом числе отдельных доработок на разных участках системы, то большинство отдельных проектных задач спокойно укладываются в этот интервал. Таким образом, соблюдать это правило при подготовке и согласовании с заказчиком списка задач не так уж и сложно.

Тем не менее, в крупных проектах может возникнуть необходимость разработать какой-то большой блок или целую подсистему, которые предполагают сдачу заказчику целиком. Объем у такой работы может быть значительный, что однозначно приведет ее в зону риска. Что можно сделать в такой ситуации?

Прежде всего, к подобной разработке нужно отнестись максимально ответственно, понимая, что она является рискованной просто из-за своего объема. Планируемую крупную разработку необходимо тщательно проанализировать. Цель анализа – вытащить из единого блока максимум задач, которые можно описать и сдать заказчику отдельно. В идеале, вся разработка должна быть разбита на отдельные задачи приемлемого размера, и часто это, действительно, удается.

Иногда это требует специальных договоренностей с заказчиком, который обычно согласен пойти навстречу, ведь чем сложнее разработка, тем труднее ему принять ее. Например, часто можно договориться вынести в отдельные задачи разработку отчетов и печатных форм, разработку прав доступа, создание облегчающих работу сервисных функций, улучшения интерфейса и красивый дизайн форм, автоматический запуск по расписанию и «защиту от дурака».

При этом, разумеется, есть риск потерять связность вашего большого блока, особенно, если работа занимает длительное время и разные задачи поручены разным разработчикам. Если этот риск высок, и ваш заказчик разделяет ваши опасения, имеет смысл кроме задач разработки запланировать подготовку сквозных контрольных примеров для проверки единой и согласованной работы разных функций, созданных в нескольких предшествующих задачах. Сквозной контрольный пример – это сложный сценарий действий пользователя (или пользователей), который включает несколько последовательных операций в системе, имеющих общую цель, и дающих конкретный конечный результат.

Проверка набора выполненных задач на сквозном контрольном примере проводится только после сдачи заказчику каждой задачи в отдельности. Недостатки, выявленные в ходе проверки сквозного примера, не могут являются для заказчика поводом отыграть назад и объявить уже сданные задачи «некачественными». Договоренность об этом между вами и заказчиком должна быть достигнута еще «на берегу», до начала работы над крупным блоком, или, еще лучше – до начала проекта. Устранение выявленных в ходе проверки на сквозном контрольном примере недостатков включается в план последующей разработки, как новая задача.

В ходе разработки крупного программного модуля может быть подготовлено 2-3 промежуточных сквозных примера, и один – финальный, проверяемый после завершения всех задач, из которых состоит разработка модуля. Создание, согласование с заказчиком и последующее прохождение сквозного контрольного примера в разрабатываемой системе – сложная трудоемкая работа. Которая сама по себе является отдельной задачей, а следовательно ее необходимо заранее предусмотреть, согласовать с заказчиком и включить в план работ.

Тактика внедрения 4. Макетирование

Чаще всего разработка в ходе внедрения 1С:ERP заключается в выполнении множества разрозненных доработок в разных местах системы. При общем большом количестве доработок, отдельная задача обычно невелика, и может быть описана небольшим документом, типа функциональной спецификации, или вовсе строчкой в перечне функциональных требований. Как правило, доработка – это описание каких-то локальных изменений типовой системы: добавить такой-то реквизит, так-то изменить алгоритм формирования отчета, включить в расчет суммы дополнительный параметр. Это достаточно понятно для заказчика, даже если он не очень разбирается в возможностях системы и программировании, а является обычным пользователем. Собственно, требования так и формируются – заказчик смотрит на объект типовой системы и говорит – добавьте сюда вот такую кнопку.

Но что делать, если нужно выполнить действительно объемную доработку? Например, разработать рабочее место с большим числом функций или создать с нуля целый модуль из множества объектов? Разумеется, вы можете спроектировать такую разработку при помощи графических нотаций, типа UML или EPC, а также подробно описать структуру данных, функции и автоматизируемый процесс в документации (иначе вы не внедряли бы ERP). Вот только заказчик обычно не является опытным проектировщиком, не умеет читать графические нотации, и не может достаточно внимательно проанализировать подробные текстовые описания функций, особенно если она разрастаются в целые технические задания на десятках листов.

В этом случае можно воспользоваться методом макетирования. Макет – это разработка, внешне изображающая нужные функции системы. Пустой «не работающий» интерфейс с теми реквизитами и кнопками, необходимость которых ясна уже в самом начале. Если это, например, макет нового документа, то он не выполняет никакие отражения в учете, не проверяет корректность данных, ничего не вычисляет при заполнении, не встроен в структуру данных системы, не учтен в правах доступа. Все, для чего он пригоден – показать его заказчику и обсудить с ним дальнейшие доработки, превращающие макет в полноценный работающий документ.

Для заказчика гораздо проще объяснить вам, как должны работать нужные ему программные механизмы, глядя на «что-то» в системе, чем рисуя на листке или пытаясь все-то вообразить. Затем, в несколько итераций к макету добавляются новые реквизиты, кнопки и рабочие области, забытые заказчиком при первом подходе, проведения по регистрам, вводы на основании, автоматические заполнения, печатные формы и права доступа. Каждая отдельная доработка макета может быть оформлена простыми описаниями или краткими функциональными спецификациями.

Используя макеты, мы избавляемся от необходимости тратить много времени на проектирование и написание технических заданий, с непременным риском того, что при приемке результата заказчик заявит, что его это не устраивает, и он представлял все по-другому. Заказчик с самого начала вовлечен в доработку макета и является соавтором решения. Кроме того, мы не создаем ситуации, в которых разработчики простаивают, пока выполняется объемное проектирование. Проектирование в виде подготовки небольших задач по доработке макета происходит одновременно с разработкой. Наконец, мы снижаем финансовые риски, исключая из проекта разработку с большим временем выполнения и высокой стоимостью, превращая ее в набор последовательно выполняемых небольших задач.

Тактика внедрения 3. Код наш, данные – ваши

Этап внедрения, запуска системы в работу, операция рискованная, потому что в ней начинают работать пользователи. Откровенно говоря, лучше бы пользователи вообще никогда не начинали работать в системах, потому что они всегда все только портят. Программа, безупречно работающая в добрых родительских руках разработчиков, при появлении незнакомых ей пользователей начинает капризничать, отказывается работать, выдает самое неожиданное поведение. И ее можно понять! Пользователи напрочь лишены такта, они беззастенчиво заявляют, что программа неудобная, непонятная интуитивно, и что в их старой программе все было намного лучше. К сожалению, пока деньги за внедрение платятся всегда при обязательном условии работы в системе пользователей. Поэтому вместо того, чтобы прогнать бесцеремонных невежд, не способных оценить красоту программного решения и классическую лаконичность интерфейса, проектной команде приходится внимательно их выслушивать, и устранять причины их недовольства.

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

Система может работать неправильно по двум причинам: либо в ней неправильный программный код, либо код правильный, но на вход поданы неправильные данные. Проще говоря, в систему введены (или неким образом «появились» в ней) кривые данные, на обработку которых система не рассчитана.

Причем, ситуация с ошибкой в коде – самая простая для решения. Есть документация, где написано, как данная функция должна работать. Есть уже готовый код, в который заложена правильная логика (пусть где-то в нем и есть ошибка). Есть единое представление в головах разработчика и пользователя о конечном результате. Найти ошибку, исправить ее – и проблема решена. Да, пользователь недоволен, что столкнулся с ошибкой, но если она будет быстро исправлена, он отнесется к этому с пониманием.

А вот ошибка данных – совсем другое дело. Прежде всего, разработчику исправлять нечего – код правильный. Исправление неправильных данных занимает больше времени и требует тесного взаимодействия с пользователями – нужно выяснить, какие правильные данные должны быть указаны вместо этих, проверить все остальные данные на наличие аналогичных ошибок, согласовать исправления. Что еще хуже, возникает вопрос – а кто виноват в том, что в системе находятся неправильные данные? Пользователи склонны обвинять в этом разработчиков (вплоть до заявлений типа «Система не должна позволять пользователю сделать ошибку!»), а разработчики – пользователей. Возникает конфликт интересов, который затрудняет сотрудничество, приводит к потере времени и лишним эмоциям.

Чтобы исключить такие ситуации и связанные с ними очень опасные риски, достаточно при выполнении проекта придерживаться простого принципа:

Разработчики создают только программный код, и никогда не вводят данные. Любые данные вводят только пользователи.

Этот простой принцип всегда вызывает много вопросов от внедренцев, не знакомых с такой практикой, поэтому ниже приведены ответы на наиболее частые вопросы.

Вопрос: Как же в этом случае выполнять сдачу работ?

Ответ: Сдача работ никогда не выполняется на рабочей базе, потому что разработчики не контролируют находящиеся в ней данные. Там может оказаться что угодно, в том числе и некорректные данные. Сдача-приемка всегда выполняется на согласованном контрольном примере, введенным в тестовую базу данных. Таким образом по крайней мере при сдаче-приемке новый программный код отработает на правильных данных.

Вопрос: Как выполнять загрузку начальных данных?

Ответ: Для загрузки начальных данных разрабатываются обработки, сдача-приемка которых выполняется на согласованных контрольных примерах. Выполняют загрузку данных сами пользователи. Конечно, крайне желательно, чтобы обработка информировала пользователя о том, что и куда она загружает, давала возможность отбора и другой минимальной настройки. Таким образом, любое несоответствие загружаемых данных контрольному примеру и алгоритму загрузки находится в зоне ответственности пользователя.

Вопрос: Что делать, если в базе нужно произвести групповую корректировку данных?

Ответ: Для групповой корректировки данных разрабатывается обработка, сдача-приемка которой выполняется на согласованном контрольном примере. Как и в случае с загрузкой начальных данных, она снабжается средствами для отбора и другой минимальной настройки. При необходимости, разрабатывается инструкция. Запускает эту обработку всегда только пользователь.

Вопрос: Что делать, если требуется изменить настройки системы, и пользователь не знает, как это сделать?

Ответ: В этом случае готовится подробная инструкция, где прямо указано, какие настройки и в каком месте должен изменить пользователь.

Вопрос: Что делать если пользователь настаивает на том, чтобы какие-то данные были внесены в систему именно разработчиками (например, если ввод этих данных у пользователя вызывает трудности или носит технический характер)?

Ответ: Если уж не удается отвертеться от такого задания, необходимо получить у пользователя точное содержание вводимых данных (например, в виде файла MS Excel) и оформить их проектным документом под подпись. А после ввода обязательно организовать сверку пользователем введенных данных с тем, что он предоставил. То есть, оформить все это, как сдачу-приемку доработки.

Ситуации в ходе проекта могут возникнуть самые разные, и всегда можно что-то придумать для того, чтобы следовать принципу «код наш, данные – ваши». Большинство рисков проекта, чреватых неприятным ситуациями, простоями и бесплатной работой имеют своей причиной недостаточно четкое разделение ответственности между исполнителем и заказчиком за результат, и нужно использовать любую возможность, чтобы устранить любую неясность и любой конфликт интересов. Следование принципу, в соответствии с которым проектная команда отвечает только за программную реализацию (а также – инструкции, проведенное обучение и другую работу, которую выполняет своими руками), а за данные (и, в целом, за использование системы) отвечают только пользователи, устраняет множество «мутных» ситуаций и дисциплинирует как разработчиков, так и пользователей. Для заказчика эта логика очень понятна, потому что идея о том, что разработчик отвечает за исправность созданного им инструмента, но не отвечает за то, как заказчик им пользуется – проста и очевидна.