Значительно ли дороже исправить ошибку в конце проекта?

В сообщении Эндрю Хэя была изложена следующая аксиома:

Исправление ошибки в конце проекта стоит значительно дороже, чем исправление той же ошибки ранее в проекте.

Тем не менее, это не кажется точным, особенно после прочтения поста в блоге «Менее неправильный» , и данные, которые я видел, чтобы подтвердить это, чрезвычайно стары.

Верна ли эта аксиома сегодня?

Единственные достоверные данные, которые я когда-либо видел, - это Бем и Папаччо, «Понимание и контроль стоимости программного обеспечения» .

Это относится к 1988 году и было изучено около 80 программных проектов. Они пришли к выводу, что решение, принятое досрочно и исправленное поздно, может стоить в 50-200 раз больше, чем оно было бы, если бы оно было скорректировано досрочно. Но о самых ранних решениях, о которых они говорят, является то, какую ОС использовать, какой язык и базу данных использовать.

Таким образом, эти цифры могут быть искажены в отношении сегодняшней разработки программного обеспечения. Тем не менее, теперь у нас большой опыт в этой области, и мы инстинктивно знаем, что он по-прежнему остается верным.

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

Редактировать: Док Браун делает хорошее замечание в своем комментарии.

Исследование Бема было выполнено на проектах COBOL и FORTRAN во времена, когда время компиляции и выполнения было смехотворно медленным. Я начал свою карьеру в начале 90-х годов на COBOL, и цикл компиляции и тестирования занимал так много времени, что стоило потратить усилия на то, чтобы протестировать код до прохождения цикла (или, по крайней мере, на этапе сборки, на всякий случай Вы можете поймать что-то и отменить это раньше, сэкономив себе около часа)

В свою очередь, наши начальники смеялись над нашими жалобами, потому что не так давно им приходилось приносить коробку перфокарт, отсортированных вручную, в серверную комнату и оставлять ее там на один день.

Так что это было определенно более верно тогда, чем сейчас.

И все же совсем недавно я видел блоги, повторно использующие визуализацию этой проблемы Стивом Макконнеллом ( ссылка 1996 года), как будто этот график действительно основан на точных числах. Это не так. Это визуализация, чтобы объяснить его точку зрения просто.

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

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

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

Кроме того, если вы исправляете ошибки на ранних этапах, реализация все еще свежа в сознании разработчика. В зависимости от продолжительности любого конкретного проекта, если вы исправляете ошибки в конце, разработчику нужно потратить время на выяснение того, что они написали, и (возможно) того, как работают подсистемы, от которых зависит их код. Время потраченное на переучивание это = $.

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

• Общий объем кода в проекте имеет тенденцию расти к концу. Чем дольше вы ждете исправления ошибки, тем больше кодовая база, к которой вы должны прикоснуться.
• Качество нового кода, добавляемого в проект, снижается ближе к концу, по крайней мере, при наличии давления (которое обычно является данностью): приближающийся крайний срок заставляет людей выбрасывать лучшие практики за борт только для того, чтобы вовремя. Это означает, что чем позже вы исправите ошибку, тем больше плохого кода вам придется просмотреть.
• Несмотря на то, что дублирование кода, как правило, вызывает недовольство, оно происходит постоянно, и, поскольку его легко скопировать и вставить, но сложно повторно объединить дублирующиеся фрагменты кода, объем кода, вставленного после копирования, обычно увеличивается в течение времени жизни кода. проект. Чем больше скопированного кода, тем выше вероятность того, что ваша ошибка будет продублирована и ее нужно будет найти и исправить несколько раз (и, следовательно, больше вероятность того, что некоторые из ее случаев останутся незамеченными).
• Исправление ошибки - это изменение кодовой базы; Вы надеетесь сделать вещи лучше, но изменения всегда несут риск. Изменения, которые вызывают серьезные проблемы в проекте, на который уйдут месяцы, должны оставить достаточно места для управления ущербом, но за два дня до отправки вы столкнетесь с серьезными проблемами.
• Чем дольше существует сама ошибка, тем больше вероятность того, что другие части приложения начнут полагаться на ее неправильное поведение. Затем, когда вы исправляете это, вы внезапно высвобождаете кучу вторичных ошибок в коде, которые не ожидают, что ваша функция действительно даст правильные документированные результаты.

Это основной принятый материал от системного проектирования - и он применим к любой форме технического развития (будь то строительство мостов, ракет, линкоров или программного обеспечения).

По сути, стоимость вещей возрастает примерно на порядок при прохождении этапов разработки.

Что-то, что стоит 10 долларов, чтобы исправить в момент зачатия идеи ...

Будет стоить около 100 долларов, если вам нужно будет обновить спецификацию ....

Или стоит около $ 1000, если что-то было реализовано, и вам нужно внести изменения в этот момент (и обновить спецификацию, и получить одобрения и т. Д.), Но это не прошло какой-то формальный приемочный тест / распродажу

Или стоить около $ 10000, если что-то было реализовано и принято заказчиком, и вам нужно внести изменения в этот момент (и обновить спецификацию, и получить одобрения, и повторно протестировать и повторно запустить приемку и квалификацию клиента и т. Д.)

И стоимость после развертывания / развертывания / ввода в эксплуатацию еще больше.

Примеров предостаточно, и их легко понять: банковская система с серьезным изменением объема, сделанным после того, как 25 000 сотрудников ее используют, обойдется во время переобучения пакета ... еще до того, как вы даже подумаете об определении объема, кодировании, тестировании, регрессии, и т. д. и т. д.

Ясно, что ваш пробег будет отличаться: стоимость и последствия изменения электронного веб-сайта электронной коммерции по согреванию носков Фреда Нурке несколько отличаются от стоимости смены программного обеспечения на компьютере управления полетом самолета.

У меня нет доступа к достоверным данным или фактам, поэтому я могу только предложить вам отдельные примеры, полученные из моих последних 20 лет в ИТ.

Я считаю, что существует большая разница между тем, как большинство разработчиков создают программное обеспечение сегодня, по сравнению с тем, что было 20 лет назад. Благодаря быстрому движению Agile, особенно за последние 5-6 лет, я увидел реальное изменение отношения на рабочем месте. Настолько, что качество того, что мы делаем, кажется, стремительно растет с каждым годом, и с каждым проектом, когда мы применяем уроки, которые мы извлекли из проекта в проект. Процессы Leaner в сочетании с акцентом на первоочередную разработку превратились из очень противоречивых в обычное явление. Настолько, что сегодня, когда вам не по душе Agile, вы вошли во многие компании, и вам повезет, если они не покажут вам дверь.

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

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

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

Итак, в конце концов, что это значит в отношении вопроса ОП? Что ж, это означает, что ответ на самом деле не такой резкий, как мы когда-то могли подумать. 15 лет назад я бы наверное ответил на вопрос как да, но теперь я чувствую, что более реалистично сказать, что на самом деле слишком сложно измерить эмпирически, потому что характер того, что мы делаем для разработки программного обеспечения, сильно изменился по сравнению с тем, когда мы впервые начали задавать себе вопрос ОП в то время. В некотором смысле, чем больше мы продвигаем наши методы и навыки как отрасль, тем дальше вопрос растет от окончательного «да» до такой степени, что я подозреваю, что через несколько лет мы будем говорить, что это не имеет значения когда мы исправляем ошибки, потому что наши тесты и процессы будут намного более надежными, что время исправления ошибок будет меньше зависеть от усилий по экономии наших бюджетов, и больше от приоритетов для удовлетворения потребностей наших клиентов, а относительная стоимость будет стать практически бессмысленным в контексте.

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

Ранние ошибки будут распространяться на другие части системы, поэтому, когда вы исправите ошибку, вы можете быть вынуждены переписать некоторые части системы, которые полагались на саму ошибку.

Кроме того, со временем вы поймете, как строятся некоторые части программы, и вам нужно будет напомнить себе. Это какая-то форма технического долга (если вы поторопите проект на ранней стадии, у вас будут проблемы с его завершением из-за ярлыков, которые вы выбрали).

Это так просто, и доказывать нечего.

Я думаю, что вы пытаетесь поспешить как можно быстрее, чтобы представить работнику какое-то рабочее решение. Хорошая новость в том, что у вас это будет очень быстро, плохая новость в том, что вы, вероятно, никогда не закончите его без полного переписывания, если просто продолжите писать дерьмо как можно быстрее и планируете исправить все через пару месяцев. Вы, вероятно, даже не сможете рефакторинг этого.

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

Мы добавили функцию, обеспечивающую возможности управления рабочим процессом в нашем продукте. Типичный материал BDUF, спецификации подписаны и одобрены клиентом. Реализовано по спец. Жалобы с первого дня на развертывание.

Мы не сделали реальное пошаговое руководство по использованию с клиентом, просто взяли его слово за то, что они хотели. Результат: сотни часов доработки - анализ, проектирование, внедрение и обеспечение качества пришлось переделать. Все потому, что в спецификации пропущены конкретные варианты использования. Ошибка в спецификации, если хотите.

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

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

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

Спросите у Intel, сколько стоит Pentium Bug. Еще одним хорошим примером является Ariane 5 Rocket. Эти ошибки были исправлены в конце проекта. Я работал над системой, в которой «попытка» выпуска программного обеспечения имеет бюджет в 6 цифр. В этих крайних случаях легко увидеть стоимость. В других (большинстве?) Случаях стоимость скрывается шумом, но она все еще там.

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

Если ошибка вылетает в дикую природу, стоимость имеет скачкообразный скачок ...... Является ли «Конец проекта» до или после выпуска программного обеспечения?

Однажды я прочитал статью, в которой были два интересных момента (к сожалению, у меня давно нет ссылок, поэтому мне придется просто постулировать здесь). Первое, что они отметили, было то, что около 50% всех ошибок были внесены в спецификацию требований и что около 90% всех ошибок были обнаружены во время UAT или тестов системы.

Вторым моментом, который они имели, было то, что для каждой фазы в V-модели стоимость была увеличена в 10 раз. Является ли этот фактор правильным или нет, я считаю, что это не имеет значения, но наиболее дорогостоящие ошибки возникают, когда ваш дизайн основан на неверном допущении. Это приводит к огромному количеству переписывания. Весь код, который работает из-за этого предположения, но терпит неудачу при применении правильного предположения, должен быть переписан.

Я испытал необходимость переписать всю модель предметной области из-за одного неверного предположения в спецификациях требований. Если такая ошибка обнаружена на ранней стадии, то есть при рассмотрении технических требований, стоимость очень низкая. В этом конкретном случае потребовалось бы десять строк текста. В случае, когда он обнаружен во время UAT (как это было), стоимость является суммарной (в данном примере стоимость проекта была увеличена на 50%)

Нет статистических данных, но личный опыт:

У кода управления ракетным двигателем, над которым я работал, была такая строка powerCutoff = someCondition && debugOptions.cutoffIsAllowed;. Опция по умолчанию была запрещена. «Окончательная» сборка должна была удалить все параметры отладки, поэтому строка была изменена на powerCutoff = someCondition;.

Вы поймали ошибку во время проверки кода? Мы не сделали. Первый раз, когда условие триггера появилось в тесте, вызвавшем неожиданное отключение, было всего за несколько месяцев до первого полета.

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

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

К сожалению, как и многие вещи, это зависит.

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

Если ошибка заключается в том, что вывод критического метода, который имеет более 100 страниц спецификации и доказательств неверен, то само расследование может занять несколько часов или дней. Это то, к чему относится старая «аксиома», и чего, помимо прочего, TDD и agile пытаются избежать (провалиться рано и ясно, добиться безопасного постепенного прогресса, яда).

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