Мне нравится термин «технический долг», потому что для среднего владельца бизнеса является легкая метафора, чтобы понять и поставить в реальные условия. Особое преимущество метафоры долга заключается в том, что это очень удобно для общения с нетехническими людьми. Так же, как и финансовый долг, технический долг будет нести процентные платежи, которые приходят в форме дополнительных усилий, которые мы должны сделать в будущем развитии из -за выбора, который мы делаем сейчас.
Технический долг не всегда плох, как и то, как бизнес может заимствовать и понести долг, чтобы воспользоваться преимуществами рыночной возможности, разработчики также могут понести технический долг, чтобы достичь важного срока или получить конкретную функцию на рынке быстрее, чем если бы они имели » сделал это правильно в первый раз. «Также может быть осторожный долг в системе, в которой члены команды признают, что, возможно, не стоит заплатить, если процентные платежи достаточно малы, например, в рамках части системы, которые редко обновляются или затрагиваются разработкой — нам не нужно. заботиться о плотности комментариев, сложности или рефактории, если эта подсистема никогда не получит обновления функций. Сложно в техническом долге заключается в том, что, в отличие от денег, иногда трудно эффективно измерить, как это повлияет на вашу будущую скорость, и, в некоторых случаях, в будущем никогда не понадобится. Каждый тип технического долга должен быть взвешен против конкретной системы и ее жизненного цикла.
Технический долг исходит из различных источников, некоторые из которых могут быть хорошими, а некоторые — плохие, но идея технической метафоры долга заключается в том, что существует стоимость, связанная с тем, чтобы сделать короткие сокращения, делать ошибки или преднамеренный выбор и что стоимость не рассмотреть С этими проблемами со временем увеличатся. Не секрет, что я большой поклонник Sonarqube ( https://www.sonarqube.org ), панель управления с открытым исходным кодом для управления качеством кода. Он пытается рассчитать технический долг (называемый «запах кода») для базы кода, используя результаты анализа статического кода, такие как охват кода автоматизированных тестов, сложность кода, дублирование, нарушения практики кодирования, плотность комментариев и следующее базовое стандарты кодирования.
И хотя она и имеет хорошую работу по сообщению о областях технического долга, которые он может с помощью анализа кода, что на самом деле значат цифры для бизнеса? И именно здесь попадают в нечеткость технического долга и то, как это влияет на долгосрочную жизнеспособность проекта. Когда я думаю о самых больших стоимости технического долга, он обычно вращается вокруг того, как реализованные проекты или код, реализованные сегодня, могут замедлить нашу способность предоставлять будущие функции, создавая таким образом альтернативные затраты на потерянный доход. Имея это в виду, при измерении технического долга важно и специфично для каждого проекта определить влияние, которое оказывают эти различные виды технических долга. Именно путем оценки каждого типа технического долга может повредить и выяснить, когда существует слишком много определенного типа технического долга, мы можем начать разумно управлять им. Рассматривая проект и оценивая различные виды технических долгов и сколько они могут стоить вам, это включает в себя более нечеткий подход, чем просто рассмотрение панели инструментов Sonarqube. Вот некоторые из категорий, которые мне нравятся, при обсуждении различных типов технических долгов и процентов, которые мы можем заплатить за них:
Различные виды технического долга
Архитектурный ($$$$)
Если вы создаете систему, в которой ключевой компонент или платформа принципиально ошибочны, так что она не будет масштабируемой или надежной, это может быть огромной проблемой, которую вы даже не осознаете, пока реальные клиенты не будут работать на вашем продукте. Если вы не можете масштабировать свою архитектуру так, как вам необходимо из -за проблем с основными зависимостями или неправильных предположений о том, как ваши клиенты будут использовать вашу систему, у вас не будет выбора, кроме как переписать или переоценить огромные куски системы. Хорошим примером этого может быть Game Star Citizen и их выбор создать игру на платформе Cryengine ( https://www.extremetech.com/gaming/237434-star-citizen-single-player delayed- бесконечно )
Хрупкий код ($$$)
В каждой большой системе всегда есть пара модулей, которые, кажется, дают разработчикам больше всего проблем. Это подсистемы или компоненты с кодом, который трудно понять, дорого и опасно измениться, потому что он был плохо написан с начала или использует чрезвычайно устаревшие технологии. Поскольку эти подсистемы настолько хрупкие, ни один разработчик не хочет прикоснуться к ним, и когда они это делают, это обычно и применить очень конкретное исправление для их ситуации, а затем двигаться дальше. Поскольку эти близорукие исправления накапливаются с течением времени, проблема только ухудшается. Эти хрупкие компоненты должны быть идентифицированы и оценены для полного переписывания, чтобы «защищать от пули», иначе они будут оставаться дорогостоящим долгом в бухгалтерской книге проекта.
Untestable или зарезервированный код ($$$)
Написание модульных тестов занимает время. Также требуется, чтобы разработчики писали свой код, чтобы он мог быть протестирован в модуле. Разработчик, который пишет свой код так, чтобы его можно было протестировать, имеет тенденцию разбить их функциональность на небольшие атомные компоненты, которые облегчают тестирование модуля. Если в вашей системе есть монолитные функции, которые плохо автоматизируют хорошо, и вы решите не тратить время на то, чтобы рефакторировать их, вы в конечном итоге испытывают тесты, которые хрупкие и медленные и продолжаете разваливаться, когда вы меняете код. Это приводит к увеличению ваших расходов на тестирование с течением времени, так как в базу кода добавляются дополнительные опции и функции. Еще хуже, когда хрупкие автоматизированные тесты игнорируются при сбое, потому что «в любом случае он всегда терпит неудачу». Это может привести к увеличению затрат на ручное и исследовательское тестирование, а также к дополнительным затратам на незапланированную работу, когда код возвращается с множеством сообщений об ошибках, которых можно было бы избежать с помощью надлежащего автоматического тестирования.
Нет автоматического развертывания ($$)
Я включаю это по техническому долгу, потому что мы платим «проценты» по этому поводу каждый раз, когда выпускается с точки зрения человеческих часов и неотъемлемых рисков. Это одна из тех скрытых затрат, о которых, кажется, никто не думает, пока вы не сядете и не рассмотрите, как это влияет не только на ваши релизы, но и на вашу каденцию развития. Процессы ручного выпуска по своей природе подвержены ошибкам. Таким образом, каждый релиз в конечном итоге становится все ручным сценарием «на всякий случай». Эти затраты продолжают составлять улавливать с течением времени. Не только с поздними ночами, но и с тем, чтобы уйти из обычного цикла команды разработчиков, чтобы подготовиться к выпуску и потерять производительность во время их нынешнего цикла. Стоимость автоматизации развертывания дороже, чем планирование одного ручного релиза? Наверное. Но автоматизация выплачивает огромные дивиденды при каждом последующем выпуске продукта и, вероятно, имеет один из лучших долгосрочных окупаемости.
Код черного ящика ($$)
Это код, который только что работает, написанный каким-то давно потерянным мастером кода джедая, который с тех пор покинул компанию или на пенсию. Мы все знаем, что это работает, и видим, как он работает в наших системах, но никто не может объяснить, почему это работает так, как это делает. Это также действительно сложная область, потому что бизнес может решить, что можно носить этот технический долг в бухгалтерской книге проекта, потому что нет никаких планов изменить какую -либо функциональность, за которую отвечает этот черный ящик. И это нормально. Пока что -то не изменится. И это не работает. Этот тип технического долга похож на те ипотеки с огромным платежом на воздушном шаре в конце. Вы можете сойти с рук не платить его годами, а затем либо укусить пулю, и заплатить ее, либо если ваш продукт достигнет окончания жизни, вы сможете уйти в отставку системой, даже не заплатив ее.
Устаревшие библиотеки ($-$$$$)
Это может быть небольшая сумма технического долга или может быть огромным количеством технического долга. Это потому, что это должно быть оценено на риск, который он представляет бизнесу. Это особенно важно, когда устаревшие библиотеки содержат вновь обнаруженные недостатки безопасности (например, устаревшая библиотека стойки, которая была эксплуатирована во время эксперианского взлома https://www.cyberscoop.com/quifax-freach-apache-pruts-fbi-investigation или уязвимость сердца ( http://heartbleed.com/ ). Устаревшая библиотека может считаться небольшим количеством технических долгов, пока не будет, и тогда она станет упражнением по восстановлению палубы, чтобы исправить ваши системы, прежде чем их эксплуатировать.
Плохая обработка ошибок и инструменты ($$-$$$)
Если у вас нет надлежащей обработки ошибок в вашем коде, трудно устранить устранение неполадок, когда что -то пойдет не так. Хуже того, вы можете не заметить, что определенные подсистемы ошибочны, если у вас нет способа инструментов этих ошибок и проблем с производительностью. Когда система не работает так, как она должна быть, если у вас нет инструментов на месте, трудно определить основную причину проблем, если только вы не встроили различные окна в процессы ваших систем.
Код копирования и вставки ($$)
Когда код работает, он работает; А Sonarqube делает довольно приличную работу по выяснению дублированных кодовых блоков с помощью анализа статического кода. Таким образом, мы можем в конечном итоге получить много разных вариантов кодовых структур, которые разработчики вырезали и встали, а затем слегка изменялись на итерациях Мы всегда говорим себе: «В какой -то момент я могу вернуться назад и параметризировать код, чтобы консолидировать и рефактор функций». Но это время редко запланировано во время итераций проекта и долга Любые изменения в том, как работает код, теперь требуют, чтобы разработчик запомнил, где находятся множественные места кода, и внесли те же обновления снова и снова. Если это всего лишь несколько мест, это может не иметь большого значения, но игнорирование проблемы вызывает затраты на повышение дополнительных обновлений в течение жизни проекта.
Противоречивые методы программирования ($-$$)
Иногда легко сказать, кто написал какую часть системы, просмотрев код. Один разработчик, возможно, всегда, кажется, использует один конкретный шаблон по сравнению с другой, или он создает обертки вокруг определенных модулей очень конкретным образом, что отличает их использование, чем то, как другой разработчик создает этот код или имеет переменные, названные определенным способом. Эта практика может остаться незамеченной в небольших командах, но чем больше разработчиков, которые участвуют в обновлении системы, тем сложнее становится эта проблема и тем сложнее передать другим разработчикам. Код должен быть нейтральным для разработчика, насколько это возможно, и должен быть в состоянии сказать, кто написал конкретную строку кода, просмотрев журналы регистрации.
Назад Совместимость ($-$$)
Обычно это необходимый долг, который следует нести на краткосрочной основе. Вы захотите сохранить какую -то совместимость с предыдущей версией. Но как насчет версии до этой или той до этого? Чем дальше вы идете, чтобы поддерживать обратную (или вперед) совместимость ваших систем, тем больше затрат на поддержание и проверку всех сценариев совместимости, с которыми может обработать ваша система.
Неэффективный дизайн ($)
В сегодняшний день аппаратное обеспечение дешево. Иногда вы можете сойти с рук с расточительными практиками, бросив немного оборудования на проблему, и это исчезнет на некоторое время. Это может привести к некоторым ленивым методам программирования, где неэффективное использование памяти или обработка не появится во время начальных развертываний. По мере того, как вы масштабируете свои вычислительные потребности, будут расти, и эти проблемы начнут появляться.
Волшебные числа ($)
В целом, магические числа являются уникальными значениями со значениями или множественными случаями, которые предпочтительно могут быть заменены на именованные константы. Их использование в коде, как правило, является низким содержанием висящих фруктов, что означает, что их можно легко заменить, но они затрудняют для других кодировщиков, не так знакомых с системой, чтобы ускорить, как и почему использование определенного магического числа. Замена этих значений на именованную константу в вашем коде позволяет использовать более описательный идентификатор в коде и, следовательно, более легкое понимание блоков кода в целом.
Пользовательские функции для встроенных функций (0- $)
У каждого программиста будет другой уровень опыта с определенной структурой. Поскольку они создают функции для системы, они могут в конечном итоге создавать определенные функции, которые уже обрабатываются в рамках. Как только эта функция будет построена (при условии, что она не связана с серьезными ошибками, связанных с ней), она становится утопленной стоимостью. Конечно, это неэффективно, но до тех пор, пока он работает, на самом деле нет никакого технического долга, связанного с дубликацией функциональности.
Документация (0- $)
Никто не читает документацию. Любая документация, которая написана, обычно устарела к тому времени, когда она опубликована. Итак, это действительно технический долг? Может быть, нет, это будет зависеть от сложности программы и почему документация создается. Для небольших проектов разработчику может быть проще просто прочитать код и считать, что он «самоокументирование» (при условии, что у нас есть хорошие методы комментариев). Но для более крупных проектов или систем, которые требуют регулирующего контроля или подвергаются аудиту, документация может считаться необходимым злом, которое должно быть произведено.
Резюме
Метафора технической задолженности полезна, потому что она дает нам модель, которую нетехнические члены команды могут использовать для оценки выбора, сделанного на протяжении всего жизненного цикла проекта. Существует также полезное различие между долгами, которое должно быть выплачено, и долгами, которые можно носить с течением времени.
Продютный долг можно считать приемлемым, если команда признает, что они берут на себя этот долг, и понимают компромисс более раннего освобождения по сравнению с затратами на его оплату. Важной частью этого процесса оценки является то, что команда признает, что они фактически принимают эти риски и приводят их в действие против усилий, необходимых для исправления проблем, дополнительно снижая жизненный цикл продукта и планируйте эту возможную оплату Piper.
Даже лучшие команды будут иметь долг, с которыми будет иметь дело, поскольку проект продвигается в течение его жизненного цикла — Поэтому важно, чтобы члены команды узнали это и сделали сознательный выбор, когда принимать технические долги и когда потратить время на его исправление.
Пост Есть ли такая вещь, как хороший технический долг? появился первым на Опыт внутренней империи папа Анкет
Оригинал: «https://dev.to/iedaddy/is-there-such-a-thing-as-good-technical-debt-490b»